.anyMatch(method -> method.isAnnotatedWith(Inject.class));
        }
    };

    private static final DescribedPredicate<JavaClass> injected_by_constructor = new DescribedPredicate<JavaClass>("injected into constructors via @Inject") {
        @Override
        public boolean test(JavaClass javaClass) {
            return javaClass
                .getMethodsWithParameterTypeOfSelf()
                .stream()

   *     constructor that omits the cause.
   */
  @Deprecated
  protected UncheckedExecutionException() {}

  /**
   * Creates a new instance with the given detail message and no cause.
   *
   * @deprecated Prefer {@linkplain UncheckedExecutionException(String, Throwable)} a constructor

        }
    }

    private GradleHandle setupStubs(AbstractContinuousIntegrationTest sampleTest) {
        sampleTest.results = [] // fields are null for some reason, perhaps Spock internally modifies constructors
        def gradleHandle = Stub(GradleHandle)
        gradleExecuter.withStdinPipe() >> gradleExecuter
        gradleExecuter.withTasks(_) >> gradleExecuter
        gradleExecuter.withForceInteractive(_) >> gradleExecuter

    override val name: FqName,
    override val supertypes: Set<FqName>,
    override val properties: List<DataProperty>,
    override val memberFunctions: List<SchemaMemberFunction>,
    override val constructors: List<DataConstructor>
) : DataClass {

    override fun toString(): String = name.simpleName

    companion object Empty : DataClass {
        override val name: FqName = FqName.Empty

   *     #initCause} later, so it is not quite equivalent to using a constructor that omits the
   *     cause.
   */
  @Deprecated
  protected ExecutionError() {}

  /**
   * Creates a new instance with the given detail message and no cause.
   *
   * @deprecated Prefer {@linkplain ExecutionError(String, Error)} a constructor that accepts a

        MemberType.TYPE -> hasTypeFlags(kmClass, jvmSignature, predicate)
        MemberType.FIELD -> hasPropertyFlags(kmClass::properties, jvmSignature, predicate)
        MemberType.CONSTRUCTOR -> hasConstructorFlags(kmClass::constructors, jvmSignature, predicate)
        MemberType.METHOD -> hasFunctionFlags(kmClass::functions, jvmSignature, predicate) ||
            hasPropertyFlags(kmClass::properties, jvmSignature, predicate)
    }
}

   *     constructor that omits the cause.
   */
  @Deprecated
  protected UncheckedExecutionException() {}

  /**
   * Creates a new instance with the given detail message and no cause.
   *
   * @deprecated Prefer {@linkplain UncheckedExecutionException(String, Throwable)} a constructor

import java.util.HashMap;
import java.util.Map;

public class GuidesContributeIncludeProcessor extends IncludeProcessor {
    private static final String CONTRIBUTE = "contribute";

    // Even though these are unused, these constructors are necessary to prevent
    // "(ArgumentError) asciidoctor: FAILED: Failed to load AsciiDoc document - wrong number of arguments (1 for 0)"
    // See https://github.com/asciidoctor/asciidoctorj/issues/451#issuecomment-210914940

      }
    }
  }

  private fun registerTest(
    access: Feature.BeforeAnalysisAccess,
    java: Class<*>,
  ) {
    access.registerAsUsed(java)
    RuntimeReflection.register(java)
    java.constructors.forEach {
      RuntimeReflection.register(it)
    }
    java.declaredMethods.forEach {
      RuntimeReflection.register(it)
    }
    java.declaredFields.forEach {
      RuntimeReflection.register(it)

        val compilationConfigClass = kotlinScriptAnnotation.compilationConfiguration
        val compilationConfigConstructor = compilationConfigClass.java.constructors.single().apply {
            isAccessible = true
        }
        val compilationConfig = compilationConfigConstructor.newInstance() as ScriptCompilationConfiguration