softwareTypeRegistry: SoftwareTypeRegistry
): DeclarativeKotlinScriptEvaluator = DefaultDeclarativeKotlinScriptEvaluator(
    schemaBuilder,
    documentChecks = setOf(SettingsBlocksCheck),
    resolutionResultHandlers = setOf(
        ConventionDefinitionCollector(softwareTypeRegistryBasedConventionRegistrar(softwareTypeRegistry)),

	context
}

func (c ContextStub) GetPC() uintptr {
	return c.ip()
}

func NewContextStub() *ContextStub {
	var ctx context
	ctx.set_ip(getcallerpc())
	ctx.set_sp(getcallersp())
	ctx.set_fp(getcallerfp())
	return &ContextStub{ctx}

import java.nio.file.attribute.BasicFileAttributes
import java.util.jar.JarFile
import java.util.jar.JarOutputStream
import java.util.zip.ZipEntry


private
val ignoredPackagePatterns = PackagePatterns(setOf("java"))


object Attributes {
    val artifactType = Attribute.of("artifactType", String::class.java)
    val minified = Attribute.of("minified", Boolean::class.javaObjectType)
}


class JarAnalyzer(

    override fun get(): GradleApiSpecProvider.Spec = KotlinSpec

    private
    object KotlinSpec : GradleApiSpecProvider.SpecAdapter() {
        override fun getExportedPackages() = setOf("kotlin")
    }

func (c *context) set_lr(x uintptr) {}

func (c *context) set_ip(x uintptr) { c.eip = uint32(x) }
func (c *context) set_sp(x uintptr) { c.esp = uint32(x) }

// 386 does not have frame pointer register.
func (c *context) set_fp(x uintptr) {}

func prepareContextForSigResume(c *context) {
	c.edx = c.esp
	c.ecx = c.eip
}

func dumpregs(r *context) {
	print("eax     ", hex(r.eax), "\n")
	print("ebx     ", hex(r.ebx), "\n")

internal
fun conventionsDefinitionInterpretationSequenceStep(softwareTypeRegistry: SoftwareTypeRegistry) = SimpleInterpretationSequenceStep(
    "settingsConventions",
    features = setOf(ConventionDefinition()),
    buildEvaluationAndConversionSchema = { conventionsEvaluationSchema(softwareTypeRegistry) }
)


private

package okhttp3

import java.io.File
import org.junit.jupiter.engine.descriptor.ClassBasedTestDescriptor
import org.junit.platform.engine.discovery.DiscoverySelectors

// TODO move to junit5 tags
val avoidedTests =
  setOf(
    "okhttp3.BouncyCastleTest",
    "okhttp3.ConscryptTest",
    "okhttp3.CorrettoTest",
    "okhttp3.OpenJSSETest",
    "okhttp3.internal.platform.Jdk8WithJettyBootPlatformTest",

        get() = withValidityAssertion {
            KaFe10AnnotationList.create(
                fe10Type.annotations,
                analysisContext,
                ignoredAnnotations = setOf(
                    StandardClassIds.Annotations.ExtensionFunctionType,
                    StandardClassIds.Annotations.ContextFunctionTypeParams,
                )
            )
        }

        def taskOutput = getTaskOutput(result)
        taskOutput.contains('Starting test: MyTest > testExpectation')
        taskOutput.contains('Finishing test: MyTest > testExpectation')
    }

    def "can use setOf() in Kotlin DSL to configure logging no events"() {
        given:
        buildKotlinFile << testLoggingStandardStreamWithEmptyEventSet()

        file(JAVA_TEST_FILE_PATH) << javaTestClass {
            """

shadedJar {
    shadedConfiguration.exclude(mapOf("group" to "org.slf4j", "module" to "slf4j-api"))
    keepPackages = listOf("org.gradle.tooling")
    unshadedPackages = listOf("org.gradle", "org.slf4j", "sun.misc")
    ignoredPackages = setOf("org.gradle.tooling.provider.model")
}

errorprone {
    disabledChecks.addAll(
        "EqualsUnsafeCast", // 1 occurrences
        "FutureReturnValueIgnored", // 1 occurrences