}

    /** If [e] is non-null, this will return a non-null value. */
    fun complete(e: IOException?): IOException? {
      if (completed) return e
      completed = true
      // If the body is closed without reading any bytes send a responseBodyStart() now.
      if (e == null && invokeStartEvent) {
        invokeStartEvent = false
        eventListener.responseBodyStart(call)
      }
      return bodyComplete(

 */
package jcifs.internal.smb2.lease;

import jcifs.internal.smb2.create.CreateContextRequest;
import jcifs.internal.util.SMBUtil;

/**
 * Directory Lease Context for SMB3 directory leasing
 *
 * This context extends standard lease context with directory-specific metadata
 * for enhanced directory caching capabilities.
 */
public class DirectoryLeaseContext implements CreateContextRequest {

    /**

        }

        try {
            // In real implementation, this would perform RDMA read into the buffer
            // For skeleton implementation, simulate reading the requested amount
            int bytesToRead = Math.min(length, buffer.remaining());

            // Simulate RDMA read operation

    double fpp = 0.03;
    for (int i = 1; i < 10000; i++) {
      long numBits = BloomFilter.optimalNumOfBits(i, fpp);
      int arraySize = Ints.checkedCast(LongMath.divide(numBits, 64, RoundingMode.CEILING));
      assertEquals(
          arraySize * Long.SIZE,
          BloomFilter.create(Funnels.unencodedCharsFunnel(), i, fpp).bitSize());
    }
  }

  public void testApproximateElementCount() {

import java.io.IOException;
import java.io.InputStream;
import java.math.BigInteger;
import java.util.Date;

import jcifs.SmbConstants;
import jcifs.smb.SID;

/**
 * Input stream for reading PAC data structures with proper alignment and byte ordering.
 * Handles little-endian byte order and data alignment requirements of PAC structures.
 */
public class PacDataInputStream {

    private final DataInputStream dis;

	lastShardSize := ceilFrac(lastBlockSize, int64(e.dataBlocks))
	return numShards*e.ShardSize() + lastShardSize
}

// ShardFileOffset - returns the effective offset where erasure reading begins.
func (e *Erasure) ShardFileOffset(startOffset, length, totalLength int64) int64 {
	shardSize := e.ShardSize()
	shardFileSize := e.ShardFileSize(totalLength)
	endShard := (startOffset + length) / e.blockSize

     *
     * @param outputFile the converted output file
     * @param outExt the output file extension
     * @return the extracted text content
     * @throws ExtractException if an error occurs while reading the file
     */
    protected String getOutputContent(final File outputFile, final String outExt) {
        final Extractor extractor = getExtractor(outExt);
        if (extractor != null) {

    private static final Logger logger = LogManager.getLogger(ESSourceReader.class);

    /** Queue of documents. */
    protected final Queue<Map<String, Object>> queue = new ConcurrentLinkedQueue<>();
    /** Flag indicating if reading is finished. */
    protected final AtomicBoolean isFinished = new AtomicBoolean(false);
    /** Random number generator. */
    protected final Random random = new Random();

    /** OpenSearch client. */

        assertEquals("\"", result[1]);
        assertEquals("\"\"", result[2]);
    }

    public void test_parse_whitespace() {
        String value;
        String[] result;

        // Leading and trailing spaces
        value = " value1 , value2 , value3 ";
        result = KuromojiCSVUtil.parse(value);
        assertEquals(3, result.length);
        assertEquals(" value1 ", result[0]);

   * {@link Collections#frequency} (which would presumably perform more poorly).
   *
   * <p><b>Note:</b> the utility method {@link Iterables#frequency} generalizes this operation; it
   * correctly delegates to this method when dealing with a multiset, but it can also accept any
   * other iterable type.
   *
   * @param element the element to count occurrences of