return this
    }

    /**
     * Creates a 'checkDeps' task that resolves the given configuration.
     */
    void prepare(String configToCheck) {
        prepare {
            config(configToCheck, "checkDeps")
        }
    }

    /**
     * Injects the appropriate stuff into the build script. By default, creates a 'checkDeps' task that resolves the configuration provided in the constructor.
     */

                }
            }
        }
    }

    void canHaveCycleInDependencyGraph() {
        given:
        resolve.prepare("compile")

        when:
        run(":checkDeps")

        then:
        resolve.expectGraph {
            root(":", ":test:") {
                module("test:projectA:1.2") {
                    module("test:projectB:1.5") {

                    }
                    '1.1' {
                        expectGetMetadata()
                    }
                }

            }
        }

        run ':checkDeps'

        then:
        resolve.expectGraph {
            root(":", ":consumer:") {
                edge('com.acme.foo:core:1.0', 'com.acme.foo:core:1.1') {
                    byConstraint("platform alignment")

        resolve = new ResolveTestFixture(buildFile, config)
        resolve.prepare()
        resolve.expectDefaultConfiguration("api")
        buildFile << """
            allprojects {
                tasks.named("checkDeps") {
                    def outputFile = rootProject.file("\${rootProject.buildDir}/${config}-files.txt")
                    def files = configurations.${config}
                    doLast {

        buildArgs = args as List
    }

    private void checkDependencies() {
        resolve.prepare()
        execute(buildA, ":checkDeps", buildArgs)
    }

    private void checkDependenciesFails() {
        resolve.prepare()
        fails(buildA, ":checkDeps", buildArgs)
    }

    void checkGraph(@DelegatesTo(ResolveTestFixture.NodeBuilder) Closure closure) {
        resolve.expectGraph {

            .configuration('b', extendsFrom: ["parent"])
            .configuration('c', extendsFrom: ["b"])
            .publish()

        when:
        run ':checkDeps'

        then:
        resolve.expectGraph {
            root(":", "org.test:test:1.0") {
                module("ivy.configuration:projectA:1.2") {
                    configuration("a")

GOLANGCI_DIR = .bin/golangci/$(GOLANGCI_VERSION)
GOLANGCI = $(GOLANGCI_DIR)/golangci-lint

all: build

checks: ## check dependencies
	@echo "Checking dependencies"
	@(env bash $(PWD)/buildscripts/checkdeps.sh)

help: ## print this help
	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' Makefile | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-40s\033[0m %s\n", $$1, $$2}'

getdeps: ## fetch necessary dependencies
	@mkdir -p ${GOPATH}/bin

            }
            dependencies { compile project(path: ':a', configuration: 'compile') }
'''
        resolve.prepare("testCompile")

        when:
        run ":checkDeps"

        then:
        executedAndNotSkipped ":a:aJar", ":b:bJar"
        resolve.expectDefaultConfiguration("compile")
        resolve.expectGraph {
            root(":", ":test:") {

        def constraintVersion = lockMode() == LockMode.LENIENT ? "1.0" : "{strictly 1.0}"
        def extraReason = lockMode() == LockMode.LENIENT ? " (update/lenient mode)" : ""

        when:
        succeeds 'checkDeps'

        then:
        resolve.expectDefaultConfiguration('runtime')
        resolve.expectGraph {
            root(":", ":depLock:") {
                edge("org:foo:1.+", "org:foo:1.0")

import org.jetbrains.kotlin.analysis.api.symbols.KaClassOrObjectSymbol
import org.jetbrains.kotlin.fir.*
import org.jetbrains.kotlin.fir.analysis.checkers.getImplementationStatus
import org.jetbrains.kotlin.fir.analysis.checkers.isVisibleInClass
import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
import org.jetbrains.kotlin.fir.declarations.FirClass