import (
	"fmt"
	"net"
	"os"
	"time"

	"golang.org/x/sys/unix"
	utilerrors "k8s.io/apimachinery/pkg/util/errors"
	"k8s.io/apimachinery/pkg/util/wait"
)

type locker struct {
	lock16 *os.File
	lock14 *net.UnixListener
}

func (l *locker) Close() error {
	errList := []error{}
	if l.lock16 != nil {
		if err := l.lock16.Close(); err != nil {
			errList = append(errList, err)
		}
	}
	if l.lock14 != nil {

    def packer = Mock(BuildCacheEntryPacker)
    def originFactory = Mock(OriginMetadataFactory)
    def stringInterner = new StringInterner()
    def buildOperationContext = Mock(BuildOperationContext)
    def buildOperationRunner = Mock(BuildOperationRunner)
    PackOperationExecutor packOperationExecutor = new PackOperationExecutor(buildOperationRunner, packer, originFactory, stringInterner)

        private final BuildOperationRunner buildOperationRunner;
        private final BuildCacheEntryPacker packer;
        private final OriginMetadataFactory originMetadataFactory;
        private final Interner<String> stringInterner;

        PackOperationExecutor(BuildOperationRunner buildOperationRunner, BuildCacheEntryPacker packer, OriginMetadataFactory originMetadataFactory, Interner<String> stringInterner) {

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.List;

public class SnappyDainPacker implements Packer {
    private final Packer delegate;

    public SnappyDainPacker(Packer delegate) {
        this.delegate = delegate;
    }

    @Override
    public void pack(List<DataSource> inputs, DataTarget output) throws IOException {

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.List;

public class SnappyCommonsPacker implements Packer {
    private final Packer delegate;

    public SnappyCommonsPacker(Packer delegate) {
        this.delegate = delegate;
    }

    @Override
    public void pack(List<DataSource> inputs, DataTarget output) throws IOException {

  private OverflowAvoidingLockSupport() {}

  static void parkNanos(@CheckForNull Object blocker, long nanos) {
    // Even in the extremely unlikely event that a thread unblocks itself early after only 68 years,
    // this is indistinguishable from a spurious wakeup, which LockSupport allows.
    LockSupport.parkNanos(blocker, min(nanos, MAX_NANOSECONDS_THRESHOLD));
  }

  private OverflowAvoidingLockSupport() {}

  static void parkNanos(@CheckForNull Object blocker, long nanos) {
    // Even in the extremely unlikely event that a thread unblocks itself early after only 68 years,
    // this is indistinguishable from a spurious wakeup, which LockSupport allows.
    LockSupport.parkNanos(blocker, min(nanos, MAX_NANOSECONDS_THRESHOLD));
  }

    @Param({"tar.snappy", "tar.snappy.commons", "tar.snappy.dain"})
    String packer;

    @Param({"direct", "buffered"})
    String accessor;

    @Override
    protected String getPackerName() {
        return packer;
    }

    @Override
    protected String getAccessorName() {
        return accessor;
    }

type Cond struct {
	noCopy noCopy

	// L is held while observing or changing the condition
	L Locker

	notify  notifyList
	checker copyChecker
}

// NewCond returns a new Cond with Locker l.
func NewCond(l Locker) *Cond {
	return &Cond{L: l}
}

// Wait atomically unlocks c.L and suspends execution
// of the calling goroutine. After later resuming execution,

    @Param({"tar.snappy.small", "tar.snappy.large"})
    String packer;

    @Param({"direct", "buffered.small", "buffered.large"})
    String accessor;

    @Override
    protected String getPackerName() {
        return packer;
    }

    @Override
    protected String getAccessorName() {
        return accessor;
    }