"Dialect " + String.format("0x%04X", dialect) + " should be >= SMB 2.0.2");
        }

        @Test
        @DisplayName("Dialects should be in ascending order")
        void testDialectOrdering() {
            assertTrue(Smb2Constants.SMB2_DIALECT_0202 < Smb2Constants.SMB2_DIALECT_0210, "SMB 2.0.2 should be less than SMB 2.1");

                when(conn.getHeaderField(entry.getKey())).thenReturn(entry.getValue().get(0));
            }

            // Mock by index - getHeaderField(int)
            // Index 0 is status line, then headers in order
            int index = 1;
            for (Map.Entry<String, List<String>> entry : headers.entrySet()) {
                when(conn.getHeaderField(index++)).thenReturn(entry.getValue().get(0));
            }
        }

 *
 * @return the index of the match. If no match is found this is `(-1 - insertionPoint)`, where the
 *     inserting the element at `insertionPoint` will retain sorted order.
 */
inline fun binarySearch(
  position: Int,
  limit: Int,
  compare: (Int) -> Int,
): Int {
  // Do the binary searching bit.
  var low = position
  var high = limit - 1
  while (low <= high) {

   * is sent unencrypted to the proxy server, so tunnels include only the minimum set of headers.
   * This avoids sending potentially sensitive data like HTTP cookies to the proxy unencrypted.
   *
   * In order to support preemptive authentication we pass a fake "Auth Failed" response to the
   * authenticator. This gives the authenticator the option to customize the CONNECT request. It can

	recordsRead  int                    // number of records read in current slice
	input        chan *queueItem        // input for workers
	queue        chan *queueItem        // output from workers in order
	err          error                  // global error state, only touched by Reader.Read
	bufferPool   bpool.Pool[[]byte]     // pool of []byte objects for input

internal
fun Project.configureIde(testType: TestType) {
    val prefix = testType.prefix
    val sourceSet = the<SourceSetContainer>().getByName("${prefix}Test")

    // We apply lazy as we don't want to depend on the order
    plugins.withType<IdeaPlugin> {
        with(model) {
            module {
                testSources.from(sourceSet.java.srcDirs, sourceSet.the<GroovySourceDirectorySet>().srcDirs)

        // For GCM, last 4 bytes should contain incrementing counter
        ByteBuffer buffer1 = ByteBuffer.wrap(nonce1, 12, 4).order(java.nio.ByteOrder.LITTLE_ENDIAN);
        ByteBuffer buffer2 = ByteBuffer.wrap(nonce2, 12, 4).order(java.nio.ByteOrder.LITTLE_ENDIAN);
        int counter1 = buffer1.getInt();
        int counter2 = buffer2.getInt();

   * alternatives we've used in the past.
   *
   * <p>FarmHash fingerprints are encoded by {@link HashCode#asBytes} in little-endian order. This
   * means {@link HashCode#asLong} is guaranteed to return the same value that
   * farmhash::Fingerprint64() would for the same input (when compared using {@link

      return new SampleElements<>(1, 4, 3, 2, 5);
    }

    @Override
    public Integer[] createArray(int length) {
      return new Integer[length];
    }

    @Override
    public Iterable<Integer> order(List<Integer> insertionOrder) {
      return Ordering.natural().sortedCopy(insertionOrder);
    }

    @Override
    public Set<Integer> create(Object... elements) {

        }
        assertEquals(num, count);

        reader = new ESSourceReader(client, settings, indexName);
        reader.setScrollSize(1000);
        reader.addSort(SortBuilders.fieldSort("field2").order(SortOrder.DESC));
        count = 0;
        prev = Integer.MAX_VALUE;
        while ((source = reader.read()) != null) {
            int current = Integer.parseInt(source.get("field2").toString());