return unmodifiableCollectionSubclass(createCollection());
  }

  /**
   * Creates the collection of values for a single key.
   *
   * <p>Collections with weak, soft, or phantom references are not supported. Each call to {@code
   * createCollection} should create a new instance.
   *
   * <p>The returned collection class determines whether duplicate key-value pairs are allowed.
   *

    return new CacheBuilderFactory()
        .withKeyStrengths(ImmutableSet.of(STRONG, Strength.WEAK))
        .withValueStrengths(ImmutableSet.of(STRONG, Strength.WEAK, Strength.SOFT));
  }

  private Iterable<LoadingCache<Key, String>> caches() {
    CacheBuilderFactory factory = factoryWithAllKeyStrengths();
    return Iterables.transform(

    return unmodifiableCollectionSubclass(createCollection());
  }

  /**
   * Creates the collection of values for a single key.
   *
   * <p>Collections with weak, soft, or phantom references are not supported. Each call to {@code
   * createCollection} should create a new instance.
   *
   * <p>The returned collection class determines whether duplicate key-value pairs are allowed.
   *

        Request
          .Builder()
          .url(server.url("/"))
          .build(),
      )
    val response = call.execute()
    if (expectedProtocol == Protocol.HTTP_2) {
      // soft failure since client may not support depending on Platform
      assumeThat(response, matchesProtocol(Protocol.HTTP_2))
    }
    assertThat(response.protocol).isEqualTo(expectedProtocol)
    assertFailsWith<IOException> {

    return new CacheBuilderFactory()
        .withKeyStrengths(ImmutableSet.of(STRONG, Strength.WEAK))
        .withValueStrengths(ImmutableSet.of(STRONG, Strength.WEAK, Strength.SOFT));
  }

  private Iterable<LoadingCache<Key, String>> caches() {
    CacheBuilderFactory factory = factoryWithAllKeyStrengths();
    return Iterables.transform(

A663          ; valid                                  # 5.1  CYRILLIC SMALL LETTER SOFT DE
A664          ; mapped                 ; A665          # 5.1  CYRILLIC CAPITAL LETTER SOFT EL
A665          ; valid                                  # 5.1  CYRILLIC SMALL LETTER SOFT EL
A666          ; mapped                 ; A667          # 5.1  CYRILLIC CAPITAL LETTER SOFT EM

    assertThat(spec.maximumWeight).isNull();
    assertThat(spec.concurrencyLevel).isNull();
    assertThat(spec.keyStrength).isNull();
    assertThat(spec.valueStrength).isEqualTo(Strength.SOFT);
    assertThat(spec.writeExpirationTimeUnit).isNull();
    assertThat(spec.accessExpirationTimeUnit).isNull();
    assertCacheBuilderEquivalence(CacheBuilder.newBuilder().softValues(), CacheBuilder.from(spec));
  }

  }

  @CanIgnoreReturnValue
  CacheBuilderFactory withKeyStrengths(Set<Strength> keyStrengths) {
    this.keyStrengths = new LinkedHashSet<>(keyStrengths);
    Preconditions.checkArgument(!this.keyStrengths.contains(Strength.SOFT));
    return this;
  }

  @CanIgnoreReturnValue
  CacheBuilderFactory withValueStrengths(Set<Strength> valueStrengths) {
    this.valueStrengths = new LinkedHashSet<>(valueStrengths);
    return this;
  }

    assertThat(parse("http://ABCD").host).isEqualTo("abcd")
    assertThat(parse("http://Σ").host).isEqualTo("xn--4xa")
  }

  @Test
  fun hostnameIgnoredCharacters() {
    // The soft hyphen (­) should be ignored.
    assertThat(parse("http://AB\u00adCD").host).isEqualTo("abcd")
  }

  @Test
  fun hostnameMultipleCharacterMapping() {

pkg go/types, type Error struct
pkg go/types, type Error struct, Fset *token.FileSet
pkg go/types, type Error struct, Msg string
pkg go/types, type Error struct, Pos token.Pos
pkg go/types, type Error struct, Soft bool
pkg go/types, type Func struct
pkg go/types, type Importer interface { Import }
pkg go/types, type Importer interface, Import(string) (*Package, error)
pkg go/types, type Info struct