* limitations under the License.
 */

package org.gradle.integtests.resolve.locking

import org.gradle.internal.locking.LockFileReaderWriter
import org.gradle.test.fixtures.file.TestFile

class LockfileFixture {

    TestFile testDirectory

    def createBuildscriptLockfile(String configuration, List<String> modules, boolean unique = true) {
        internalCreateLockfile(configuration, modules, unique, true)
    }

}
"""


        lockfileFixture.createLockfile('lockedConf', ["org:foo:1.0"], false)
        lockfileFixture.createLockfile('otherLockedConf', ["org:foo:1.1"], false)

        when:
        succeeds 'dependencies', '--write-locks'

        then:
        lockfileFixture.verifyLockfile([lockedConf: ['org:foo:1.1'], otherLockedConf: ['org:foo:2.0']])
        lockfileFixture.assertLegacyLockfileMissing('lockedConf')

import org.gradle.integtests.fixtures.AbstractHttpDependencyResolutionTest

class LockingInteractionsIntegrationTest extends AbstractHttpDependencyResolutionTest {

    def lockfileFixture = new LockfileFixture(testDirectory: testDirectory)

    def setup() {
        settingsFile << "rootProject.name = 'locking-interactions'"
    }

    def 'locking constraints do not bring back excluded modules'() {

import org.junit.Rule

class UsingLockingOnNonProjectConfigurationsIntegrationTest extends AbstractDependencyResolutionTest {

    def pluginBuilder = new PluginBuilder(file("plugin"))
    def lockfileFixture = new LockfileFixture(testDirectory: testDirectory)

    @Rule
    MavenHttpPluginRepository pluginRepo = MavenHttpPluginRepository.asGradlePluginPortal(executer, mavenRepo)

import org.gradle.integtests.fixtures.AbstractDependencyResolutionTest

class MixedDependencyLockingIntegrationTest extends AbstractDependencyResolutionTest {

    def lockfileFixture = new LockfileFixture(testDirectory: testDirectory)

    def setup() {
        settingsFile << "rootProject.name = 'mixedDepLock'"
    }

    def 'can resolve locked and unlocked configurations'() {

    }
}
configurations {
    unlockedConf
}

dependencies {
    unlockedConf 'org:foo:1.+'
}
"""

        when:
        succeeds 'dependencies'

        then:
        lockfileFixture.expectLockStateMissing('unlockedConf')
    }

    def "version selector combinations are resolved equally for locked and unlocked configurations"() {
        ['foo', 'foz', 'bar', 'baz'].each { artifact ->

    }
}
configurations {
    lockedConf
}

dependencies {
    lockedConf 'org:foo:1.+'
    lockedConf('org:foo') {
        version { strictly '1.1' }
    }
}
"""

        lockfileFixture.createLockfile('lockedConf',['org:foo:1.0'], unique)

        when:
        fails 'checkDeps'

        then:
        failure.assertHasCause """Cannot find a version of 'org:foo' that satisfies the version constraints:

    }
}
configurations {
    lockedConf
}

dependencies {
    lockedConf 'org:foo:1.+'
    lockedConf('org:foo') {
        version { strictly '1.1' }
    }
}
"""

        lockfileFixture.createLockfile('lockedConf', ['org:foo:1.0'], unique)

        when:
        succeeds 'checkDeps'

        then:
        resolve.expectDefaultConfiguration('runtime')
        resolve.expectGraph {

        failure.assertHasResolution("For more information on generating lock state")
        lockfileFixture.expectLockStateMissing('unlockedConf')
    }

    def 'fails if update done without lockfile present'() {
        mavenRepo.module('org', 'foo', '1.0').publish()
        mavenRepo.module('org', 'foo', '1.1').publish()

import org.gradle.integtests.fixtures.AbstractDependencyResolutionTest

class MultiProjectDependencyLockingIntegrationTest  extends AbstractDependencyResolutionTest {

    def firstLockFileFixture = new LockfileFixture(testDirectory: testDirectory.file('first'))

    def setup() {
        createDirs("first", "second")
        settingsFile << """
rootProject.name = 'multiDepLock'
include 'first', 'second'
"""
    }