a,
            b1,
            c,
            b2);
  }

  private static class CountingIterable implements Iterable<String> {
    int count = 0;

    @Override
    public Iterator<String> iterator() {
      count++;
      return asList("a", "b", "a").iterator();
    }
  }

  public void testCopyOf_plainIterable() {
    CountingIterable iterable = new CountingIterable();

	res := c.g.apply(ctx).Updates(t)
	return int(res.RowsAffected), res.Error
}

func (c chainG[T]) Count(ctx context.Context, column string) (result int64, err error) {
	var r T
	err = c.g.apply(ctx).Model(r).Select(column).Count(&result).Error
	return
}

func (c chainG[T]) Build(builder clause.Builder) {
	subdb := c.getInstance()
	subdb.Logger = logger.Discard

    } finally {
      closer.close();
    }
  }

  private long countBySkipping(Reader reader) throws IOException {
    long count = 0;
    long read;
    while ((read = reader.skip(Long.MAX_VALUE)) != 0) {
      count += read;
    }
    return count;
  }

  /**
   * Appends the contents of this source to the given {@link Appendable} (such as a {@link Writer}).

    } finally {
      closer.close();
    }
  }

  private long countBySkipping(Reader reader) throws IOException {
    long count = 0;
    long read;
    while ((read = reader.skip(Long.MAX_VALUE)) != 0) {
      count += read;
    }
    return count;
  }

  /**
   * Appends the contents of this source to the given {@link Appendable} (such as a {@link Writer}).

        return "Mem:{used " + byteCountToDisplaySize(usedBytes) + ", heap " + byteCountToDisplaySize(totalBytes) + ", max "
                + byteCountToDisplaySize(maxBytes) + "}";
    }

    /**
     * Converts byte count to human-readable size format.
     *
     * @param size the size in bytes
     * @return formatted size string
     */
    public static String byteCountToDisplaySize(final long size) {

      return Multisets.linearTimeSizeImpl(this);
    }

    @Override
    public void clear() {
      throw new UnsupportedOperationException();
    }

    @Override
    public int count(@Nullable Object element) {
      for (Entry<E> entry : entrySet()) {
        if (Objects.equals(entry.getElement(), element)) {
          return entry.getCount();
        }
      }
      return 0;
    }

 * NodeList nodes = xPathAPI.selectNodeList(contextNode, "//example");
 * Node singleNode = xPathAPI.selectSingleNode(contextNode, "//example[1]");
 * XPathEvaluationResult<?> result = xPathAPI.eval(contextNode, "count(//example)");
 * }
 * </pre>
 *
 * <p>Note: This class is not thread-safe. Each thread should create its own instance of XPathAPI.</p>
 *
 * @see javax.xml.xpath.XPath
 * @see javax.xml.xpath.XPathFactory

	count := len(testCases)
	for i := 4; i < len(testCases); i++ {
		tc := testCases[i]
		dataDir, err := xl.DeleteVersion(fileInfos[i])
		failOnErr(count+1, err)
		if dataDir != tc.expectedDataDir {
			t.Fatalf("Expected %s but got %s", tc.expectedDataDir, dataDir)
		}
		count++
	}
}

func Benchmark_mergeXLV2Versions(b *testing.B) {

        final int negotiateContextCount = SMBUtil.readInt2(buffer, bufferIndex + 2);

        // Validate negotiate context count - prevent excessive memory allocation
        if (negotiateContextCount < 0 || negotiateContextCount > 100) {
            throw new SMBProtocolDecodingException("Invalid negotiate context count: " + negotiateContextCount + " (must be 0-100)");
        }

        bufferIndex += 4;

        assertEquals(testString.length() + 1, Encdec.dec_uint32le(buffer, 0)); // Actual count
        assertEquals(0, Encdec.dec_uint32le(buffer, 4)); // Offset
        assertEquals(testString.length() + 1, Encdec.dec_uint32le(buffer, 8)); // Max count

        ndrBuffer.setIndex(0);
        String decodedString = ndrBuffer.dec_ndr_string();
        assertEquals(testString, decodedString);