candidate.NumVersions = props.numVersions
		}
		return candidate, nil
	}
	return FileInfo{}, InsufficientReadQuorum{Err: errErasureReadQuorum, Type: RQInconsistentMeta}
}

// pickValidFileInfo - picks one valid FileInfo content and returns from a
// slice of FileInfo.
func pickValidFileInfo(ctx context.Context, metaArr []FileInfo, modTime time.Time, etag string, quorum int) (FileInfo, error) {

	return nil
}

// Now, we read one chunk from the underlying reader.
// A chunk has the following format:
//
//	<chunk-size-as-hex> + ";chunk-signature=" + <signature-as-hex> + "\r\n" + <payload> + "\r\n"
//
// First, we read the chunk size but fail if it is larger
// than 16 MiB. We must not accept arbitrary large chunks.
// One 16 MiB is a reasonable max limit.
//

        // Create a simple context entry
        byte[] ctx = new byte[0x40];
        int ci = 0;
        SMBUtil.writeInt4(0, ctx, ci); // Next = 0 (only one)
        ci += 4;
        SMBUtil.writeInt2(0x10, ctx, ci); // NameOffset
        SMBUtil.writeInt2(4, ctx, ci + 2); // NameLength
        ci += 4;
        // Reserved (2) + DataOffset (2)

    @Test
    @DisplayName("Test readParametersWireFormat with empty buffer")
    void testReadParametersWireFormatEmptyBuffer() throws Exception {
        byte[] buffer = new byte[0];

        // Empty buffer adds one empty FileNotifyInformation
        int result = response.readParametersWireFormat(buffer, 0, 0);
        assertEquals(0, result);
        assertEquals(1, response.getNotifyInformation().size());

import okio.Buffer
import okio.BufferedSource
import okio.ByteString
import okio.ForwardingSource
import okio.Source
import okio.buffer

/**
 * Streaming decoder of data encoded following Abstract Syntax Notation One (ASN.1). There are
 * multiple variants of ASN.1, including:
 *
 *  * DER: Distinguished Encoding Rules. This further constrains ASN.1 for deterministic encoding.
 *  * BER: Basic Encoding Rules.
 *

      }
    }

    // If we have a routes left, use 'em.
    if (routeSelection?.hasNext() == true) return true

    // If we haven't initialized the route selector yet, assume it'll have at least one route.
    val localRouteSelector = routeSelector ?: return true

    // If we do have a route selector, use its routes.
    return localRouteSelector.hasNext()
  }

  /**

            println("$name: $value")
          }

          println(response.body!!.string())
        }
      }

      /**
       * Returns an input stream containing one or more certificate PEM files. This implementation just
       * embeds the PEM files in Java strings; most applications will instead read this from a resource
       * file that gets bundled with the application.
       */

        // Next release goes below zero and throws
        RuntimeException ex = assertThrows(RuntimeCIFSException.class, session::release);
        assertTrue(ex.getMessage().contains("below zero"));

        // Only one transport release should have occurred
        verify(transport, times(1)).release();
    }

    @Test
    @DisplayName("acquire after release reacquires transport")
    void testAcquireReacquiresTransport() {

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *