import org.apache.commons.lang.RandomStringUtils
import org.gradle.cache.FileIntegrityViolationException
import org.gradle.cache.FileLock
import org.gradle.cache.FileLockManager
import org.gradle.cache.InsufficientLockModeException
import org.gradle.cache.internal.filelock.DefaultLockOptions
import org.gradle.cache.internal.filelock.LockInfoSerializer
import org.gradle.cache.internal.locklistener.FileLockContentionHandler

            }
        });

        List<Path> fileList = systemHelper.refreshDesignJspFiles();
        assertEquals(0, fileList.size());

        virtualHostList.add(new Tuple3<>("abc.example.com", "8080", "host1"));
        fileList = systemHelper.refreshDesignJspFiles();
        assertEquals(0, fileList.size());

        systemHelper.addDesignJspFileName("xxx", "yyy.jsp");

 */
package org.gradle.cache.internal

import org.gradle.cache.CacheCleanupStrategy
import org.gradle.cache.CleanupAction
import org.gradle.cache.CleanupFrequency
import org.gradle.cache.FileLock
import org.gradle.cache.FileLockManager
import org.gradle.internal.concurrent.ExecutorFactory
import org.gradle.internal.operations.BuildOperationContext
import org.gradle.internal.operations.BuildOperationRunner

 */

package org.gradle.internal.file.locking;

import java.io.Closeable;
import java.io.File;
import java.io.RandomAccessFile;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;
import java.util.concurrent.Callable;

public class ExclusiveFileAccessManager {

    public static final String LOCK_FILE_SUFFIX = ".lck";

    private final int timeoutMs;
    private final int pollIntervalMs;

        then:
        1 * cleanupExecutor.cleanup()
        0 * _
    }

    def "initializes cache on open when lock mode is shared by upgrading lock"() {
        def exclusiveLock = Mock(FileLock)
        def sharedLock = Mock(FileLock)
        def access = newAccess(Shared)

        when:
        access.open()

        then:
        1 * lockManager.lock(lockFile, mode(Shared), "<display-name>") >> lock

        }
    }

    private FileType readFileType(Decoder decoder) throws IOException {
        byte fileKind = decoder.readByte();
        switch (fileKind) {
            case DIR_FINGERPRINT:
                return FileType.Directory;
            case MISSING_FILE_FINGERPRINT:
                return FileType.Missing;

            final Map<String, Object> contentMap = response.getContent(OpenSearchCurl.jsonParser());
            @SuppressWarnings("unchecked")
            final List<Map<String, Object>> fileList = (List<Map<String, Object>>) contentMap.get("file");
            return fileList.stream().map(fileMap -> {
                try {
                    final String path = fileMap.get("path").toString();
                    final Date timestamp =

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.cache.internal.filelock;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;

public interface LockStateSerializer {

    /**
     * size (bytes) of the data of this protocol.
     */

// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build !unix && !windows

package filelock

import (
	"errors"
	"io/fs"
)

type lockType int8

const (
	readLock = iota + 1
	writeLock
)

func lock(f File, lt lockType) error {
	return &fs.PathError{
		Op:   lt.String(),
		Path: f.Name(),

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build darwin || dragonfly || freebsd || illumos || linux || netbsd || openbsd

package filelock

import (
	"io/fs"
	"syscall"
)

type lockType int16

const (
	readLock  lockType = syscall.LOCK_SH
	writeLock lockType = syscall.LOCK_EX
)

func lock(f File, lt lockType) (err error) {