// each entry 94 byte + 2 * name length
                    // = 128 byte per entry
                    try ( SmbResource r = f.resolve(String.format("%04x%s", i, repeat('X', 13))) ) {
                        r.createNewFile();
                    }
                }
                // == 5*128 = 640

                // . and .. entries = 200 byte (includes alignment)

package dep

type Interface interface {
	N([]byte)

public class ContentCache implements Closeable {

    protected static final Logger logger = Logger.getLogger(ContentCache.class.getName());

    private final byte[] data;

    private final File file;

    public ContentCache(final byte[] data) {
        this.data = data;
        this.file = null;
    }

    public ContentCache(final File file) {
        this.data = null;
        this.file = file;
    }

 */

package com.google.common.io;

import com.google.common.collect.ImmutableSet;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;

/**
 * A byte sink for testing that has configurable behavior.
 *
 * @author Colin Decker
 */
public class TestByteSink extends ByteSink implements TestStreamSupplier {

    private static final long serialVersionUID = 2484853610174848092L;

    /**
     * Challenge
     */
    public byte[] challenge;

    /**
     * Server address
     */
    public UniAddress dc;


    /**
     * @param challenge
     * @param dc
     */
    public NtlmChallenge ( byte[] challenge, UniAddress dc ) {
        this.challenge = challenge;
        this.dc = dc;
    }


    @Override

        this.type = SESSION_RETARGET_RESPONSE;
        this.length = 6;
    }


    @Override
    int writeTrailerWireFormat ( byte[] dst, int dstIndex ) {
        return 0;
    }


    @Override
    int readTrailerWireFormat ( InputStream in, byte[] buffer, int bufferIndex ) throws IOException {
        if ( in.read(buffer, bufferIndex, this.length) != this.length ) {

import (
	"bytes"
	"fmt"
	"syscall"
	"unsafe"
)

func direntNamlen(dirent *syscall.Dirent) (uint64, error) {
	const fixedHdr = uint16(unsafe.Offsetof(syscall.Dirent{}.Name))
	nameBuf := (*[unsafe.Sizeof(dirent.Name)]byte)(unsafe.Pointer(&dirent.Name[0]))
	const nameBufLen = uint16(len(nameBuf))
	limit := dirent.Reclen - fixedHdr
	if limit > nameBufLen {
		limit = nameBufLen
	}
	// Avoid bugs in long file names

    super(checkNotNull(out));
    this.hasher = checkNotNull(hashFunction.newHasher());
  }

  @Override
  public void write(int b) throws IOException {
    hasher.putByte((byte) b);
    out.write(b);
  }

  @Override
  public void write(byte[] bytes, int off, int len) throws IOException {
    hasher.putBytes(bytes, off, len);
    out.write(bytes, off, len);
  }

  /**

    SID owner_user, owner_group;
    public int type;
    public ACE[] aces;

    public SecurityDescriptor() {
    }
    public SecurityDescriptor(byte[] buffer, int bufferIndex, int len) throws IOException {
        this.decode(buffer, bufferIndex, len);
    }
    public int decode(byte[] buffer, int bufferIndex, int len) throws IOException {
        int start = bufferIndex;

        bufferIndex++; // revision
        bufferIndex++;

    }


    /**
     * @return the expandedNames
     */
    public final String[] getExpandedNames () {
        return this.expandedNames;
    }


    @Override
    public int decode ( byte[] buffer, int bufferIndex, int len ) {
        int start = bufferIndex;

        this.version = SMBUtil.readInt2(buffer, bufferIndex);
        if ( this.version != 3 && this.version != 1 ) {