} 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;

            assertThrows(ArrayIndexOutOfBoundsException.class, () -> {
                Strings.findUNITermination(bufferWithoutTermination, 0, bufferWithoutTermination.length);
            }, "Should throw ArrayIndexOutOfBoundsException when termination not found within bounds");
        }

        @Test

* Fixes spurious 0-length API responses. ([#72856](https://github.com/kubernetes/kubernetes/pull/72856), [@liggitt](https://github.com/liggitt))

        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);

    /**
     * Returns a collection of {@link ChecksumAlgorithm} in same order as algorithm names are ordered, or throws if
     * any of the algorithm name is not supported. The returned collection has equal count of elements as passed in
     * collection of names, and if names contains duplicated elements, the returned list of algorithms will have
     * duplicates as well.
     *