import org.jetbrains.kotlin.analysis.utils.printer.PrettyPrinter
import kotlin.reflect.KClass
import kotlin.reflect.KProperty

internal fun Context.renderKaContractEffectDeclaration(value: KaContractEffectDeclaration, endWithNewLine: Boolean = true): Unit =
    printer.appendHeader(value::class) {
        when (value) {
            is KaContractCallsInPlaceContractEffectDeclaration -> {

                application.serviceRegistered[registrar::class] = true
            }
        }
    }

    private fun <DATA> Application.isRegistrarRegistered(registrar: AnalysisApiServiceRegistrar<DATA>): Boolean =
        serviceRegistered[registrar::class] == true

    private val Application.serviceRegistered
            by UserDataPropertyWithDefault<Application, MutableMap<KClass<out Any>, Boolean>>(

import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.analysis.api.lifetime.KaLifetimeOwner
import kotlin.reflect.KClass

public enum class KaSeverity {
    ERROR,
    WARNING,
    INFO
}

public interface KaDiagnostic : KaLifetimeOwner {
    public val diagnosticClass: KClass<*>
    public val factoryName: String
    public val severity: KaSeverity

    public val defaultMessage: String
}

        TestDomainObject value2 = new TestDomainObject('a')
        repository.put('class1', value1)
        repository.put('class2', value2)
        Closure cl = Mock()

        when:
        repository.each(cl)

        then:
        1 * cl.call(['class1', value1] as Object[])
        1 * cl.call(['class2', value2] as Object[])
        0 * cl._
    }

    def canIterateOverClassesUsingAction() {

  public void testIterator() {
    runTest("analysis/analysis-api/testData/symbols/symbolByFqName/iterator.kt");
  }

  @Test
  @TestMetadata("kclass.kt")
  public void testKclass() {
    runTest("analysis/analysis-api/testData/symbols/symbolByFqName/kclass.kt");
  }

  @Test
  @TestMetadata("listOf.kt")
  public void testListOf() {
    runTest("analysis/analysis-api/testData/symbols/symbolByFqName/listOf.kt");

  public void testIterator() {
    runTest("analysis/analysis-api/testData/symbols/symbolByFqName/iterator.kt");
  }

  @Test
  @TestMetadata("kclass.kt")
  public void testKclass() {
    runTest("analysis/analysis-api/testData/symbols/symbolByFqName/kclass.kt");
  }

  @Test
  @TestMetadata("listOf.kt")
  public void testListOf() {
    runTest("analysis/analysis-api/testData/symbols/symbolByFqName/listOf.kt");

        when:
        scanner.run()

        then:
        1 * detector.startDetection(processor)
        then:
        1 * files.visit(_) >> { args ->
            FileVisitor visitor = args[0]
            assert visitor
            visitor.visitFile(class1)
            visitor.visitFile(class2)
        }
        then:

        """

        file("src/main/java/org/gradle/ruleusing/Class1.java") << breakingDefaultRulesCode()

        expect:
        fails(":pmdMain")
        errorOutput.contains("PMD rule violations were found")
    }

    private static breakingDefaultRulesCode() {
        """
            package org.gradle.ruleusing;

            public final class Class1 {

                void foo() {
                   try {

import spock.lang.Specification

class TestResultTest extends Specification {
    def canOrderResultsByClassNameAndTestName() {
        ClassTestResults class1 = Mock()
        _ * class1.name >> 'name'
        ClassTestResults class2 = Mock()
        _ * class2.name >> 'a'
        ClassTestResults class3 = Mock()
        _ * class3.name >> 'z'

        TestResult result = new TestResult('name', 0, class1)

        decodedSpec.internalServicesRequired
    }

    def filteringClassloaderSpec() {
        def classNames = [ 'allowed.Class1', 'allowed.Class2' ]
        def disallowedClassNames = [ 'disallowed.Class1', 'disallowed.Class2' ]
        def packagePrefixes = [ 'allowed.pkgprefix1.', 'allowed.pkgprefix2' ]
        def disallowedPackagePrefixes = [ 'disallowed.pkgprefix1.', 'disallowed.pkgprefix2.' ]