* See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.cache.internal.filelock;

import org.gradle.cache.FileLock;

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

public class DefaultLockStateSerializer implements LockStateSerializer {

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

import static org.gradle.cache.internal.filelock.DefaultLockOptions.mode

              {{if not .Synthetic -}}
                {{/* disassembled instruction */ -}}
                {{printf " %8s %10s %10s %8x: %s " "" .Flat .Cumulative .Address .Disasm -}}
                <span class=unimportant>{{.FileLine}}</span>{{"\n" -}}
              {{end -}}
            {{end -}}
            </span>{{"" -}}
          {{end -}}
          {{/* end of line */ -}}
        {{end}}{{"\n" -}}
      </pre>{{"\n" -}}

    @Override
    public void afterLockAcquire(FileLock.State currentCacheState) {
    }

    @Override
    public void finishWork() {
        if (cache != null) {
            try {
                fileAccess.writeFile(() -> cache.close());
            } finally {
                cache = null;
            }
        }
    }

    @Override
    public void beforeLockRelease(FileLock.State currentCacheState) {
    }

import org.gradle.cache.LockOptions;
import org.gradle.cache.PersistentCache;
import org.gradle.cache.internal.filelock.DefaultLockOptions;

import java.io.File;
import java.util.Collections;
import java.util.Map;
import java.util.function.Consumer;

import static org.gradle.cache.internal.filelock.DefaultLockOptions.mode;

public class DefaultCacheBuilder implements CacheBuilder {
    private final CacheFactory factory;

	"path/filepath"
	"runtime"
	"testing"
	"time"

	"cmd/go/internal/lockedfile/internal/filelock"
)

func lock(t *testing.T, f *os.File) {
	t.Helper()
	err := filelock.Lock(f)
	t.Logf("Lock(fd %d) = %v", f.Fd(), err)
	if err != nil {
		t.Fail()
	}
}

func rLock(t *testing.T, f *os.File) {
	t.Helper()
	err := filelock.RLock(f)
	t.Logf("RLock(fd %d) = %v", f.Fd(), err)
	if err != nil {
		t.Fail()
	}
}

    private static class CacheDetails {
        private final int maxEntries;
        private final Cache<Object, Object> entries;
        private final AtomicReference<FileLock.State> lockState;

        CacheDetails(int maxEntries, Cache<Object, Object> entries, AtomicReference<FileLock.State> lockState) {
            this.maxEntries = maxEntries;
            this.entries = entries;
            this.lockState = lockState;
        }
    }

                File archiveFile = new File(downloadFolder, getFileName(uri, resource));
                final FileLock fileLock = cacheDirProvider.acquireWriteLock(archiveFile, "Downloading toolchain");
                try {
                    if (!archiveFile.exists()) {

func badSrcFunc(*inlineUnwinder, inlineFrame) srcFunc

// fileLine returns the file name and line number of the call within the given
// frame. As a convenience, for the innermost frame, it returns the file and
// line of the PC this unwinder was started at (often this is a call to another
// physical function).
//
// It returns "?", 0 if something goes wrong.
func (u *inlineUnwinder) fileLine(uf inlineFrame) (file string, line int) {

     *
     * @param currentCacheState the current cache state.
     */
    void afterLockAcquire(FileLock.State currentCacheState);

    /**
     * Called when the cache is due to be unlocked. Call after other threads have completed work. This method may access the cache files.
     */
    void finishWork();

    /**