// have different lengths and still not have any inexact overlap.
//
// InexactOverlap can be used to implement the requirements of the crypto/cipher
// AEAD, Block, BlockMode and Stream interfaces.
func InexactOverlap(x, y []byte) bool {
	if len(x) == 0 || len(y) == 0 || &x[0] == &y[0] {
		return false
	}
	return AnyOverlap(x, y)

    private Consumer<? super PersistentCache> initializer;
    private CacheCleanupStrategy cacheCleanupStrategy = CacheCleanupStrategy.NO_CLEANUP;
    private LockOptions lockOptions = mode(FileLockManager.LockMode.Shared);
    private String displayName;

    public DefaultCacheBuilder(CacheFactory factory, File baseDir) {
        this.factory = factory;
        this.baseDir = baseDir;
    }

    @Override

 */
package org.gradle.cache.internal

import org.gradle.cache.FileAccess
import org.gradle.cache.FileLock
import org.gradle.cache.FileLockManager
import org.gradle.cache.FileLockManager.LockMode
import org.gradle.test.fixtures.file.TestNameTestDirectoryProvider
import org.junit.Rule
import spock.lang.Specification

import java.util.function.Supplier

     *
     * @return the lock state corresponding to the lock with the given ID.
     *
     * @throws org.gradle.internal.locking.MissingLockStateException If the {@code LockMode} is {@link LockMode#STRICT} but no lock state can be found.
     */
    DependencyLockingState loadLockState(String lockId, DisplayName lockOwner);

    /**
     * Records the resolution result to the lock with the given ID.

        then:
        1 * cacheBuilderFactory.createCacheBuilder(CACHE_KEY) >> cacheBuilder
        1 * cacheBuilder.withDisplayName(CACHE_DISPLAY_NAME) >> cacheBuilder
        1 * cacheBuilder.withInitialLockMode(FileLockManager.LockMode.OnDemand) >> cacheBuilder
        1 * cacheBuilder.open() >> { cache }
        1 * cache.close()
    }

    def "creates JAR file on demand for identifier '#identifier'"(String identifier) {

    /**
     * These modes can be used either with {@link FileLockManager} or when creating {@link PersistentCache} via {@link CacheBuilder#withInitialLockMode(LockMode)}
     */
    enum LockMode {

        /**
         * On demand, single writer, no readers (on demand exclusive mode).
         * <br><br>
         *

type aesCipher struct {
	key []byte
	enc C.GO_AES_KEY
	dec C.GO_AES_KEY
}

type extraModes interface {
	// Copied out of crypto/aes/modes.go.
	NewCBCEncrypter(iv []byte) cipher.BlockMode
	NewCBCDecrypter(iv []byte) cipher.BlockMode
	NewCTR(iv []byte) cipher.Stream
	NewGCM(nonceSize, tagSize int) (cipher.AEAD, error)
}

var _ extraModes = (*aesCipher)(nil)

func NewAESCipher(key []byte) (cipher.Block, error) {

    configurations.classpath {
        resolutionStrategy.activateDependencyLocking()
    }
    dependencies {
        classpath 'org.foo:foo-plugin:[1.0,2.0)'
    }
    dependencyLocking {
        lockMode = LockMode.STRICT
    }
}

repositories {
    maven {
        url = '$mavenRepo.uri'
    }
}

configurations {
    foo {
        resolutionStrategy.activateDependencyLocking()
    }

package org.gradle.cache;

public interface LockOptions {

    FileLockManager.LockMode getMode();

    boolean isUseCrossVersionImplementation();

    /**
     * Creates a copy of this options instance using the given mode.
     *
     * @param mode the mode to overwrite the current mode with
     */
    LockOptions copyWithMode(FileLockManager.LockMode mode);

 * limitations under the License.
 */

package org.gradle.cache.internal.filelock

import spock.lang.Specification

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

class DefaultLockOptionsTest extends Specification {
    def "can make copy of options"() {
        def builder = DefaultLockOptions.mode(Exclusive).useCrossVersionImplementation()