*
   * <p><b>{@code Stream} equivalent:</b> {@link Stream#limit} (same).
   *
   * @param maxSize the maximum number of elements in the returned fluent iterable
   * @throws IllegalArgumentException if {@code size} is negative
   */
  public final FluentIterable<E> limit(int maxSize) {
    return from(Iterables.limit(getDelegate(), maxSize));
  }

  /**
   * Determines whether this fluent iterable is empty.
   *

                    totalSize += size;
                    last = chain;
                    chain = next;
                } else if (last == null && totalSize + size > maxSize) {
                    throw new SmbException(String.format("Request size %d exceeds allowable size %d: %s", size, maxSize, chain));
                } else if (last == null) {

            result.setCreatedBy(DfTypeUtil.toString(source.get("createdBy")));
            result.setCreatedTime(DfTypeUtil.toLong(source.get("createdTime")));
            result.setMaxSize(DfTypeUtil.toInteger(source.get("maxSize")));
            result.setQuery(DfTypeUtil.toString(source.get("query")));
            result.setTerm(DfTypeUtil.toString(source.get("term")));
            result.setUpdatedBy(DfTypeUtil.toString(source.get("updatedBy")));

        void negativeMaxBuffersThrows() {
            assertThrows(NegativeArraySizeException.class, () -> new BufferCacheImpl(-1, 10));
        }

        @Test
        @DisplayName("Negative maxSize throws when allocating a new buffer")
        void negativeMaxSizeThrowsOnAllocation() {
            BufferCacheImpl impl = new BufferCacheImpl(0, -7);
            assertThrows(NegativeArraySizeException.class, impl::getBuffer);

	NowFunc func() time.Time
	// DryRun generate sql without execute
	DryRun bool
	// PrepareStmt executes the given query in cached statement
	PrepareStmt bool
	// PrepareStmt cache support LRU expired,
	// default maxsize=int64 Max value and ttl=1h
	PrepareStmtMaxSize int
	PrepareStmtTTL     time.Duration

	// DisableAutomaticPing
	DisableAutomaticPing bool
	// DisableForeignKeyConstraintWhenMigrating

    val urls: MutableIterator<String> = cache.urls()
    val writeAbortCount: Int = cache.writeAbortCount()
    val writeSuccessCount: Int = cache.writeSuccessCount()
    val size: Long = cache.size()
    val maxSize: Long = cache.maxSize()
    cache.flush()
    cache.close()
    val directory: File = cache.directory
    val networkCount: Int = cache.networkCount()
    val hitCount: Int = cache.hitCount()

		if ok1 || ok2 {
			return ok1 && ok2
		}
		return x == y
	}
	for _, v := range vectors {
		t.Run(path.Base(v.file), func(t *testing.T) {
			const maxSize = 10 << 10 // 10KiB
			buf := new(bytes.Buffer)
			tw := NewWriter(iotest.TruncateWriter(buf, maxSize))

			for i, tf := range v.tests {
				switch tf := tf.(type) {
				case testHeader:
					err := tw.WriteHeader(&tf.hdr)
					if !equalError(err, tf.wantErr) {

	Prefix       string   `msg:"pr,omitempty"` // Shared prefix of all files. Can be empty. Will be joined to filename without modification.
	Files        []string `msg:"fl"`           // Individual files to read.
	MaxSize      int64    `msg:"ms"`           // Return error if size is exceed.
	MetadataOnly bool     `msg:"mo"`           // Read as XL meta and truncate data.

    }

    /**
     * Get current pool statistics
     * @return pool statistics string
     */
    public String getPoolStatistics() {
        return String.format("Pool statistics: Active=%d, NonPooled=%d, MaxSize=%d, Failures=%d, HealthChecks=%d, Removed=%d",
                connections.size(), nonPooledConnections.size(), maxPoolSize, failCounts.size(), totalHealthChecks.get(),
                connectionsRemoved.get());
    }

}

func BenchmarkEqualBothUnaligned(b *testing.B) {
	sizes := []int{64, 4 << 10}
	if !isRaceBuilder {
		sizes = append(sizes, []int{4 << 20, 64 << 20}...)
	}
	maxSize := 2 * (sizes[len(sizes)-1] + 8)
	if len(bmbuf) < maxSize {
		bmbuf = make([]byte, maxSize)
	}

	for _, n := range sizes {
		for _, off := range []int{0, 1, 4, 7} {
			buf1 := bmbuf[off : off+n]
			buf2Start := (len(bmbuf) / 2) + off