List<String> keys = new ArrayList<>(resultProps.keySet());

            // Verify the original insertion order is maintained
            assertEquals(3, keys.size());
            assertEquals("third", keys.get(0));
            assertEquals("first", keys.get(1));
            assertEquals("second", keys.get(2));
        }

        @Test

        return queryBuilderList != null && !queryBuilderList.isEmpty();
    }

    public QueryBuilder getQuery() {
        if (queryBuilderList == null) {
            return null;
        } else if (queryBuilderList.size() == 1) {
            return queryBuilderList.get(0);
        }
        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
        queryBuilderList.forEach(query -> {
            boolQuery.must(query);

        buffer[6] = 0;
        buffer[7] = 0;

        // First referral (minimal structure)
        // Version (2 bytes)
        SMBUtil.writeInt2(3, buffer, 8);

        // Size (2 bytes) - the size of this referral entry
        SMBUtil.writeInt2(20, buffer, 10);

        // Server type (2 bytes)
        SMBUtil.writeInt2(1, buffer, 12);

        // Referral flags (2 bytes)

        System.out.println("Result: " + depResults);

        assertNotNull(depResults);
        assertEquals(1, depResults.size());
        assertEquals(
                exec.getPlugin().getArtifact().key(),
                depResults.iterator().next().key(),
                "dependency artifact is wrong.");
    }

    @Test

            List<Boolean> newParametersNullability = parametersNullabilityOf(newBehavior)

            for (int idx = 0; idx < oldParametersNullability.size(); idx++) {
                def oldNullability = oldParametersNullability[idx]
                def newNullability = newParametersNullability[idx]
                if (oldNullability && !newNullability) {

            cacheEntry = entry;
            return entry.getKey();
          }
        };
      }

      @Override
      public int size() {
        return backingMap.size();
      }

      @Override
      public boolean contains(@Nullable Object key) {
        return containsKey(key);
      }
    };
  }

 *  - The prioritisation of addresses
 *
 * https://datatracker.ietf.org/doc/html/rfc8305#section-4
 */
internal fun reorderForHappyEyeballs(addresses: List<InetAddress>): List<InetAddress> {
  if (addresses.size < 2) {
    return addresses
  }

  val (ipv6, ipv4) = addresses.partition { it is Inet6Address }

  return if (ipv6.isEmpty() || ipv4.isEmpty()) {
    addresses
  } else {
    interleave(ipv6, ipv4)
  }

                20, 'X', "d", 15, 'X', "d", 20, 'X', "d", 1, 'X', "e", 5, 'X');
    SortedMap<Integer, Character> row = sortedTable.row("c");
    assertEquals(2, row.size());
    assertEquals(1, row.tailMap(15).size());
  }

  public void testSubRowClearAndPut() {
    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');

import org.gradle.api.provider.Provider
import java.io.File

fun Configuration.getSingleFileProvider(): Provider<File> {
    val name = this.name
    return incoming.files.elements.map {
        require(it.size <= 1) {
            "Expected at most one file in configuration '$name' but found: $it"
        }
        it.firstOrNull()?.asFile
    }
}

            final List<SuggestItem> items) {
        this.index = index;
        this.tookMs = tookMs;
        this.words = words;
        num = words.size();
        this.total = total;
        this.items = items;
    }

    /**
     * Returns the index associated with the response.
     *
     * @return the index
     */
    public String getIndex() {