item.setDocFreq(0);
                    item.setKinds(Stream.of(item.getKinds())
                            .filter(kind -> kind != SuggestItem.Kind.DOCUMENT)
                            .toArray(count -> new SuggestItem.Kind[count]));
                    updateItems.add(item);
                }
                final SuggestWriterResult result =

	for _, hash := range metaHashes {
		if hash == "" {
			continue
		}
		metaHashCountMap[hash]++
	}

	maxHash := ""
	maxCount := 0
	for hash, count := range metaHashCountMap {
		if count > maxCount {
			maxCount = count
			maxHash = hash
		}
	}

	if maxCount < quorum {
		return FileInfo{}, InsufficientReadQuorum{Err: errErasureReadQuorum, Type: RQInconsistentMeta}
	}

     *
     * @see jcifs.SmbTreeHandle#close()
     */
    @Override
    public synchronized void close() {
        release();
    }

    /**
     * @return tree handle with increased usage count
     */
    public SmbTreeHandleImpl acquire() {
        if (this.usageCount.incrementAndGet() == 1) {
            this.treeConnection.acquire();
        }
        return this;
    }

    @Override

            // depth
            final int depth = webConfig.getDepth() != null ? webConfig.getDepth() : -1;
            crawlerContext.setMaxDepth(depth);

            // max count
            final long maxCount = webConfig.getMaxAccessCount() != null ? webConfig.getMaxAccessCount() : maxAccessCount;
            crawlerContext.setMaxAccessCount(maxCount);

        assertEquals(sampleTimeMillis + serverTimeZoneOffset, response.getLastWriteTime());
        assertEquals(1024, response.getSize());
    }

    /**
     * Test of readParameterWordsWireFormat method with zero word count.
     */
    @Test
    public void testReadParameterWordsWireFormatWithZeroWordCount() {
        byte[] buffer = new byte[20];
        response.wordCount = 0;

     */
    public int getNegotiatedSendBufferSize() {
        return this.snd_buf_size;
    }

    /**
     * Gets the negotiated multiplex count.
     *
     * @return negotiated multiplex count
     */
    public int getNegotiatedMpxCount() {
        return this.maxMpxCount;
    }

    /**
     * Gets the negotiated session key.
     *

	}
	return d.disk.WalkDir(ctx, opts, wr)
}

func (d *naughtyDisk) ListDir(ctx context.Context, origvolume, volume, dirPath string, count int) (entries []string, err error) {
	if err := d.calcError(); err != nil {
		return []string{}, err
	}
	return d.disk.ListDir(ctx, origvolume, volume, dirPath, count)
}

    public static final String INCREMENTAL_CRAWLING_PROPERTY = "crawling.incremental";

    /** Property key for crawling thread count configuration. */
    public static final String CRAWLING_THREAD_COUNT_PROPERTY = "crawling.thread.count";

    /** Property key for crawling user agent configuration. */
    public static final String CRAWLING_USER_AGENT_PROPERTY = "crawling.user.agent";

)

// ErrTooLarge is passed to panic if memory cannot be allocated to store data in a buffer.
var ErrTooLarge = errors.New("bytes.Buffer: too large")
var errNegativeRead = errors.New("bytes.Buffer: reader returned negative count from Read")

const maxInt = int(^uint(0) >> 1)

// Bytes returns a slice of length b.Len() holding the unread portion of the buffer.
// The slice is valid for use only until the next buffer modification (that is,

     *
     * @return the maximum duplicated path count
     */
    public int getMaxDuplicatedPath() {
        return maxDuplicatedPath;
    }

    /**
     * Sets the maximum number of duplicated paths to attempt.
     *
     * @param maxDuplicatedPath the maximum duplicated path count to set
     */
    public void setMaxDuplicatedPath(final int maxDuplicatedPath) {