resolve = new ResolveTestFixture(buildFile, "lockedConf")
        resolve.prepare()
        resolve.addDefaultVariantDerivationStrategy()
    }

    abstract LockMode lockMode()

    def 'succeeds when lock file does not conflict from declared versions (unique: #unique)'() {
        mavenRepo.module('org', 'foo', '1.0').publish()
        mavenRepo.module('org', 'foo', '1.1').publish()

        buildFile << """

                assert components.thing instanceof DefaultJvmSoftwareComponent
                assert components.comp instanceof DefaultJvmSoftwareComponent
            }
        """

        expect:
        succeeds "verify"
    }

    def "can instantiate component instances in Kotlin DSL"() {
        given:
        buildKotlinFile << """
            ${factoryRegistrationKotlin()}

            components {

        expect:
        succeeds()
    }

    def canAddExtensionsToProject() {

        buildFile '''
extensions.test = new ExtensionBean()

assert test instanceof ExtensionBean
test { it ->
    assert it instanceof ExtensionBean
    assert it == project.test
}
class ExtensionBean {
}
'''

        expect:
        succeeds()
    }

        LockfileFixture.createCustomLockfile(lockFile,'lockedConf', ['org:foo:1.0', 'org:bar:1.0'])

        when:
        succeeds 'dependencies'

        then:
        outputContains('org:foo:[1.0,2.0) -> 1.0')
        outputContains('org:bar:[1.0,2.0) -> 1.0')

        when:
        succeeds 'dependencies', '--update-locks', 'org:foo', '--refresh-dependencies'

        then:

            BODY
        ]

        when: // already compiled build scripts
        succeeds "help", '-I', 'init.gradle'

        then:
        operations.all(CompileScriptBuildOperationType).size() == 0

        when: // changing cached build script
        buildFile << "println 'appending build logic'"
        succeeds "help", '-I', 'init.gradle'
        scriptCompiles = operations.all(CompileScriptBuildOperationType)

    final buildOperations = new BuildOperationsFixture(executer, temporaryFolder)

    def "settings details are exposed"() {
        settingsFile << ""

        when:
        succeeds('help')

        then:
        verifySettings(operation(), settingsFile)
        operation().details.buildPath == ":"
    }

    def "settings set via cmdline flag are exposed"() {

    }
}
"""
        firstLockFileFixture.createLockfile('compileClasspath', ['org:foo:1.0'], false)

        when:
        succeeds ':first:dependencyInsight', '--configuration', 'compileClasspath', '--dependency', 'foo'

        then:
        outputContains('org:foo:1.0')

        when:
        succeeds ':second:dependencyInsight', '--configuration', 'compileClasspath', '--dependency', 'foo'

        then:

        """

        then:
        succeeds('help')
    }

    def "can dynamically access properties"() {

        given:
        file("gradle.properties") << "someProjectProperty=true"
        settingsFile << """
            if (properties.someProjectProperty == 'true') {
                println('signal')
            }
        """

        when:
        succeeds('help')

        then:

                    java {
                        'Tool.java'('public interface Tool { void execute(); }')
                    }
                }
            }
        }

        when:
        succeeds 'a:compileJava'

        then:
        executedAndNotSkipped ':b:compileJava'
        packagingTasks(compileClasspathPackaging)

        where:
        compileClasspathPackaging | _

        hello(NativeLibrarySpec)
        main(NativeExecutableSpec) {
            sources {
                cpp.lib ${notation}
            }
        }
    }
}
"""

        when:
        succeeds "installMainExecutable"

        then:
        installation("build/install/main").exec().out == app.englishOutput

        where:
        notationName | notation
        "direct"     | "\$.components.hello"