ImmutableSortedSet.Builder<String> builder = ImmutableSortedSet.orderedBy(comparator);
      builder.add(BEFORE_FIRST);
      builder.add(BEFORE_FIRST_2);
      builder.add(elements);
      builder.add(AFTER_LAST);
      builder.add(AFTER_LAST_2);
      return builder
          .build()
          .subSet(BEFORE_FIRST_2, AFTER_LAST_2)
          .asList()

	lru := lru.NewLRU[string, int](2, nil, time.Hour)
	lru.Add("key1", 1)
	lru.Add("key2", 2)
	lru.Add("key3", 3)

	if _, ok := lru.Get("key1"); ok {
		t.Errorf("Expected key1 to be removed, but it still exists")
	}
}

func TestLRU_Add_UnlimitedSize_NoEviction(t *testing.T) {
	lru := lru.NewLRU[string, int](0, nil, time.Hour)
	lru.Add("key1", 1)
	lru.Add("key2", 2)
	lru.Add("key3", 3)

	if _, ok := lru.Get("key1"); !ok {

        // pvno [0] INTEGER 5
        v.add(new DERTaggedObject(true, 0, new ASN1Integer(Integer.parseInt(KerberosConstants.KERBEROS_VERSION))));
        // msg-type [1] INTEGER 14 (AP-REQ)
        v.add(new DERTaggedObject(true, 1, new ASN1Integer(Integer.parseInt(KerberosConstants.KERBEROS_AP_REQ))));
        // ap-options [2] BIT STRING

            .add("field27", Optional.absent())
            // Arrays
            .add("field31", new Object[] {"!!!"})
            .add("field32", new boolean[0])
            .add("field33", new byte[0])
            .add("field34", new char[0])
            .add("field35", new short[0])
            .add("field36", new int[0])
            .add("field37", new long[0])
            .add("field38", new float[0])

    queryBuilder.add(Range.<Integer>all());

    for (int i = MIN_BOUND; i <= MAX_BOUND; i++) {
      for (BoundType boundType : BoundType.values()) {
        queryBuilder.add(Range.upTo(i, boundType));
        queryBuilder.add(Range.downTo(i, boundType));
      }
      queryBuilder.add(Range.singleton(i));
      queryBuilder.add(Range.openClosed(i, i));
      queryBuilder.add(Range.closedOpen(i, i));

    ms.add("foo");
    ms.add("a");
    ms.add("bar");
    ms.add("b");
    ms.add("c");

    assertEquals(2, ms.count("bar"));
    assertEquals(3, ms.count("b"));

    Multiset<String> ms2 = TreeMultiset.create(DEGENERATE_COMPARATOR);

    ms2.add("cat", 2);
    ms2.add("x", 3);

    assertEquals(ms, ms2);
    assertEquals(ms2, ms);

        // code below...
        translatedPrefixes.add("build.directory");
        translatedPrefixes.add("build.outputDirectory");
        translatedPrefixes.add("build.testOutputDirectory");
        translatedPrefixes.add("build.sourceDirectory");
        translatedPrefixes.add("build.testSourceDirectory");
        translatedPrefixes.add("build.scriptSourceDirectory");
        translatedPrefixes.add("reporting.outputDirectory");

      Headers
        .Builder()
        .add("WWW-Authenticate: Basic realm=\"protected area\"")
        .build()
    assertThat(headers.parseChallenges("WWW-Authenticate"))
      .isEqualTo(listOf(Challenge("Basic", mapOf("realm" to "protected area"))))
  }

  @Test fun basicChallengeWithCharset() {
    val headers =
      Headers
        .Builder()

        originalPairs.add(new AvFlags(0x12345678));
        originalPairs.add(new AvTimestamp(new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 }));
        originalPairs.add(new AvTargetName("TESTNAME".getBytes()));
        originalPairs.add(new AvSingleHost(new byte[] { 0x11, 0x22, 0x33, 0x44 }));
        originalPairs.add(new AvChannelBindings(new byte[] { 0x55, 0x66 }));

          .add(BigInteger.valueOf(Integer.MAX_VALUE).add(bigI))
          .add(BigInteger.valueOf(Integer.MIN_VALUE).add(bigI))
          .add(BigInteger.ONE.shiftLeft(63).add(bigI))
          .add(BigInteger.ONE.shiftLeft(64).add(bigI));
    }
    TEST_LONGS = testLongsBuilder.build();
    TEST_BIG_INTEGERS = testBigIntegersBuilder.build();
  }

  public void testAsUnsignedAndLongValueAreInverses() {