* limitations under the License.
 */

package org.gradle.integtests.resolve.locking

import org.gradle.api.artifacts.dsl.LockMode

class DependencyLockingStrictModeIntegrationTest extends AbstractValidatingLockingIntegrationTest {

    @Override
    LockMode lockMode() {
        LockMode.STRICT
    }

    def 'fails without lock file present and does not create one'() {

        when:
        def lock = createLock(lockMode)

        then:
        lock.isLockFile(tmpDir.createFile(testFile.name + ".lock"))

        cleanup:
        lock?.close()

        where:
        lockMode << [Exclusive, Shared]
    }

    def "can lock a directory"() {
        when:
        def lock = createLock(lockMode, testDir)

        then:

        try {
            return lock.readFile(action);
        } finally {
            lock.close();
        }
    }

    @Override
    public void updateFile(Runnable action) throws LockTimeoutException, FileIntegrityViolationException {
        FileLock lock = manager.lock(targetFile, mode(FileLockManager.LockMode.Exclusive), displayName);
        try {

import static org.gradle.cache.FileLockManager.LockMode.Exclusive
import static org.gradle.cache.FileLockManager.LockMode.Shared

class DefaultFileLockManagerWithNewProtocolTest extends AbstractFileLockManagerTest {
    @Override
    protected DefaultLockOptions options() {
        return DefaultLockOptions.mode(FileLockManager.LockMode.OnDemand)
    }

    def "a lock has been updated when never written to"() {

    }

    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 << """
dependencyLocking {
    lockAllConfigurations()
    lockMode = LockMode.${lockMode()}
}

repositories {
    maven {

            signal.trigger()
        }

        where:
        lockMode << [Exclusive, Shared]
    }

    def "cannot acquire lock with mode #lockMode while another lock manager in same process is holding shared lock"() {
        given:
        def file = tmpDir.file("lock-file.bin")
        createLock(Shared, file)

        when:
        createLock(lockMode, file, manager2)

        then:
        thrown(LockTimeoutException)

    private FileLockManager.LockMode mode;
    private boolean crossVersion;

    private DefaultLockOptions(FileLockManager.LockMode mode, boolean crossVersion) {
        this.mode = mode;
        this.crossVersion = crossVersion;
    }

    public static DefaultLockOptions mode(FileLockManager.LockMode lockMode) {
        return new DefaultLockOptions(lockMode, false);
    }

    def initAction = Mock(CacheInitializationAction)
    def onOpenAction = Mock(Consumer)
    def onCloseAction = Mock(Consumer)
    def lockOptions = DefaultLockOptions.mode(FileLockManager.LockMode.Shared)
    def cacheAccess = new FixedSharedModeCrossProcessCacheAccess("<cache>", file, lockOptions, lockManager, initAction, onOpenAction, onCloseAction)

         */
        private LockState lock(LockMode lockMode) throws Throwable {
            LOGGER.debug("Waiting to acquire {} lock on {}.", lockMode.toString().toLowerCase(Locale.ROOT), displayName);

            // Lock the state region, with the requested mode
            FileLockOutcome lockOutcome = lockStateRegion(lockMode);
            if (!lockOutcome.isLockWasAcquired()) {

        partialUpdate = !lockedDependenciesToUpdate.isEmpty();
        updateLockEntryFilter = LockEntryFilterFactory.forParameter(lockedDependenciesToUpdate, "Update lock", true);
        lockMode = propertyFactory.property(LockMode.class);
        lockMode.convention(LockMode.DEFAULT);
        lockFile = filePropertyFactory.newFileProperty();
        ignoredDependencies = propertyFactory.listProperty(String.class);