}
    }

    @Override
    public long getLastAccessTime(File file) {
        return file.lastModified();
    }

    @Override
    public void deleteLastAccessTime(File file) {
        // nothing to do
    }

import org.codelibs.core.log.Logger;

public class CommonPoolUtil {
    private static final Logger logger = Logger.getLogger(CommonPoolUtil.class);

    private CommonPoolUtil() {
        // nothing
    }

    public static void execute(final Runnable task) {
        ForkJoinPool.commonPool().execute(() -> {
            final Thread currentThread = Thread.currentThread();

public interface OutgoingConnector {
    /**
     * Creates a connection to the given address. Blocks until the connection with the peer has been established.
     *
     * @throws ConnectException when there is nothing listening on the remote address.
     */
    ConnectCompletion connect(Address destinationAddress) throws ConnectException;

/**
 * Writes to a {@link RandomAccessFile}. Each operation writes to and advances the current position of the file.
 *
 * <p>Closing this stream does not close the underlying file. Flushing this stream does nothing.
 */
// TODO Replace with Channels.newOutputStream(SeekableByteChannel)
public class RandomAccessFileOutputStream extends OutputStream {
    private final RandomAccessFile file;

        int numberOfRuns = 50

        int numberOfOverflows = 0

        when:
        succeeds("assemble")
        // Assemble twice, so everything is up-to-date and nothing is invalidated
        succeeds("assemble")
        def daemon = daemons.daemon
        def retainedFilesInLastBuild = vfsLogs.retainedFilesInCurrentBuild
        then:
        daemon.assertIdle()

        expect:

      VALUE_PARAMETER name:str index:0 type:kotlin.String
      BLOCK_BODY
    FUN name:test visibility:public modality:FINAL <> () returnType:kotlin.Int
      BLOCK_BODY
        RETURN type=kotlin.Nothing from='public final fun test (): kotlin.Int declared in <root>'
          CALL 'public final fun setContent (content: @[MyComposable] kotlin.Function0<kotlin.Unit>): kotlin.Int declared in p3' type=kotlin.Int origin=null

		fs.mode |= ModeDevice | ModeCharDevice
	case syscall.S_IFDIR:
		fs.mode |= ModeDir
	case syscall.S_IFIFO:
		fs.mode |= ModeNamedPipe
	case syscall.S_IFLNK:
		fs.mode |= ModeSymlink
	case syscall.S_IFREG:
		// nothing to do
	case syscall.S_IFSOCK:
		fs.mode |= ModeSocket
	}
	if fs.sys.Mode&syscall.S_ISGID != 0 {
		fs.mode |= ModeSetgid
	}
	if fs.sys.Mode&syscall.S_ISUID != 0 {
		fs.mode |= ModeSetuid
	}

	}
	caBundle := configMap.Data[c.configmapKey]
	if len(caBundle) == 0 {
		return fmt.Errorf("missing content for CA bundle %q", c.Name())
	}

	// check to see if we have a change. If the values are the same, do nothing.
	if !c.hasCAChanged([]byte(caBundle)) {
		return nil
	}

	caBundleAndVerifier, err := newCABundleAndVerifier(c.Name(), []byte(caBundle))
	if err != nil {
		return err
	}

    }

    default DisplayName displayName(String type) {
        return Describables.of(displayName(), type);
    }

    /**
     * Rethrows the provided failures. Does nothing if the list of failures is empty.
     */
    default void rethrowFailure(String type, Collection<Throwable> failures) {
        mapFailure(type, failures).ifPresent(e -> {
            throw e;
        });
    }

	var info SysvShmDesc

	_, err := SysvShmCtl(id, IPC_STAT, &info)
	if err != nil {
		// release the shared memory if we can't find the size

		// ignoring error from shmdt as there's nothing sensible to return here
		shmdt(addr)
		return nil, err
	}

	// Use unsafe to convert addr into a []byte.
	b := unsafe.Slice((*byte)(unsafe.Pointer(addr)), int(info.Segsz))
	return b, nil
}