import java.util.Arrays;
import java.util.List;

import static com.tngtech.archunit.base.DescribedPredicate.describe;
import static com.tngtech.archunit.base.DescribedPredicate.doNot;
import static com.tngtech.archunit.core.domain.JavaClass.Predicates.belongToAnyOf;
import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noClasses;

@AnalyzeClasses(packages = "org.gradle")
public class XmlFactoriesTest {

            result
        }
    }

    private fun doGetKotlinReferencesFromProviders(context: PsiElement): Array<PsiReference> {
        val providers: List<KotlinPsiReferenceProvider>? = providersBindingCache[context.javaClass]
        if (providers.isNullOrEmpty()) return PsiReference.EMPTY_ARRAY

        val result = SmartList<PsiReference>()
        for (provider in providers) {

            programId: ProgramId,
            accessorsClassPath: ClassPath?
        ): CompiledScript

        fun loadScriptResource(resourcePath: String): String =
            javaClass.getResourceAsStream(resourcePath).bufferedReader().useToRun {
                readText()
            }
    }

    get() = null

  /** Returns if the event closes this event, or null if this is no open event. */
  open fun closes(event: ConnectionEvent): Boolean? = null

  val name: String
    get() = javaClass.simpleName

  data class ConnectStart(
    override val timestampNs: Long,
    val route: Route,
    val call: Call,
  ) : ConnectionEvent()

  data class ConnectFailed(
    override val timestampNs: Long,

            val keyString = update.key.toString()
            withPropertyTrace(PropertyTrace.SystemProperty(keyString, update.location)) {
                try {
                    writeClass(update.javaClass)
                    write(update.key)
                    write(update.value)
                } catch (error: Exception) {
                    onError(error) {

    var writeCircularMarker = true
    writeCollection(collection) { element ->
        if (element != null && element in circularReferences && element.javaClass.overridesHashCode()) {
            logPropertyProblem("serialize") {
                text("Circular references can lead to undefined behavior upon deserialization.")
            }
            if (writeCircularMarker) {

        /**
         * Causes the evaluation of the compiled [script] against the script host.
         */
        data class Eval(val script: ProgramSource) : Instruction()

        override fun toString(): String = javaClass.simpleName
    }

    data class PluginRequestSpec(val id: String, val version: String? = null, val apply: Boolean = true)

     *     public static void fromSuperClass() { }
     * }
     *
     * // FILE: JavaClass.java
     * public class JavaClass extends SuperClass {
     *     static class NestedClass { }
     *     class InnerClass { }
     *     public static void fromJavaClass() { }
     * }
     * ```
     *
     * The static member scope of `JavaClass` contains the following symbols:
     *
     * ```

        val initializerExpression = firSymbol.fir.initializer
        check(initializerExpression is FirAnonymousObjectExpression) {
            "Unexpected enum entry initializer: ${initializerExpression?.javaClass}"
        }

        val classifierBuilder = analysisSession.firSymbolBuilder.classifierBuilder

    val isSupported: Boolean =
      try {
        // Trigger an early exception over a fatal error, prefer a RuntimeException over Error.
        Class.forName("org.bouncycastle.jsse.provider.BouncyCastleJsseProvider", false, javaClass.classLoader)

        true
      } catch (_: ClassNotFoundException) {
        false
      }

    fun buildIfSupported(): BouncyCastlePlatform? = if (isSupported) BouncyCastlePlatform() else null
  }