// Connections are created as soon as a policy is set
    setPolicy(pool, address, ConnectionPool.AddressPolicy(2))
    assertThat(pool.connectionCount()).isEqualTo(2)

    // Connections are replaced if they idle out or are evicted from the pool
    evictAllConnections(pool)
    assertThat(pool.connectionCount()).isEqualTo(2)
    forceConnectionsToExpire(pool, expireTime)

    }

    private ModelVersionParser newModelVersionParser() {
        // This is a limited parser that does not support ranges and compares versions as strings
        // in real-life this parser should not be used, but replaced with a proper one
        return new ModelVersionParser() {
            @Override
            public Version parseVersion(String version) {
                requireNonNull(version, "version");

In this example, to be able to have both `HTTPException`s in the same code, Starlette's exceptions is renamed to `StarletteHTTPException`:

```Python
from starlette.exceptions import HTTPException as StarletteHTTPException
```

### Reuse **FastAPI**'s exception handlers

   */
  public String retainFrom(CharSequence sequence) {
    return negate().removeFrom(sequence);
  }

  /**
   * Returns a string copy of the input character sequence, with each matching BMP character
   * replaced by a given replacement character. For example:
   *
   * <pre>{@code
   * CharMatcher.is('a').replaceFrom("radar", 'o')
   * }</pre>
   *
   * ... returns {@code "rodor"}.
   *

func ToTitleSpecial(c unicode.SpecialCase, s []byte) []byte {
	return Map(c.ToTitle, s)
}

// ToValidUTF8 treats s as UTF-8-encoded bytes and returns a copy with each run of bytes
// representing invalid UTF-8 replaced with the bytes in replacement, which may be empty.
func ToValidUTF8(s, replacement []byte) []byte {
	b := make([]byte, 0, len(s)+len(replacement))
	invalid := false // previous byte was from an invalid UTF-8 sequence

  /**
   * End of Transmission Block: A communication control character used to indicate the end of a
   * block of data for communication purposes. ETB is used for blocking data where the block
   * structure is not necessarily related to the processing format.
   *
   * @since 8.0
   */
  public static final byte ETB = 23;

  /**
   * Cancel: A control character used to indicate that the data with which it is sent is in error or

// TODO remove the update check manager
// TODO separate into retriever and publisher
// TODO remove hardcoding of checksum logic

/**
 * Manages <a href="https://maven.apache.org/wagon">Wagon</a> related operations in Maven.
 */
@Named
@Singleton
@Deprecated
public class DefaultWagonManager implements WagonManager {

    private static final String[] CHECKSUM_IDS = {"md5", "sha1"};

    /**

        // ensure file is open
        if ( this.handle == null || !this.handle.isValid() ) {
            // one extra acquire to keep this open till the stream is released
            this.handle = this.file.openUnshared(this.openFlags, this.access, this.sharing, SmbConstants.ATTR_NORMAL, this.options).acquire();
            return this.handle;
        }
        return this.handle.acquire();

    )

    /**
     * The peer tells us to stop creating streams. It is safe to replay streams with
     * `ID > lastGoodStreamId` on a new connection.  In- flight streams with
     * `ID <= lastGoodStreamId` can only be replayed on a new connection if they are idempotent.
     *
     * @param lastGoodStreamId the last stream ID the peer processed before sending this message. If
     *     [lastGoodStreamId] is zero, the peer processed no frames.

        altNames += altName
      }

    /**
     * Set this certificate's common name (CN). Historically this held the hostname of TLS
     * certificate, but that practice was deprecated by [RFC 2818][rfc_2818] and replaced with
     * [addSubjectAlternativeName]. If unset a random string will be used.
     *
     * [rfc_2818]: https://tools.ietf.org/html/rfc2818
     */
    fun commonName(cn: String) =
      apply {