* Creates a new witness IP address.
         *
         * @param address the IP address
         */
        public WitnessIPAddress(InetAddress address) {
            this.address = address;
            this.flags = address.getAddress().length == 4 ? IPV4 : IPV6;
        }

        /**
         * Gets the IP address.
         *
         * @return the IP address
         */
        public InetAddress getAddress() {

    val InetSocketAddress.socketHost: String get() {
      // The InetSocketAddress was specified with a string (either a numeric IP or a host name). If
      // it is a name, all IPs for that name should be tried. If it is an IP address, only that IP
      // address should be tried.
      val address = address ?: return hostName

        NetworkInterfaceInfo that = (NetworkInterfaceInfo) obj;
        return interfaceIndex == that.interfaceIndex && address != null ? address.equals(that.address) : that.address == null;
    }

    @Override
    public int hashCode() {
        int result = interfaceIndex;
        result = 31 * result + (address != null ? address.hashCode() : 0);
        return result;
    }

     */
    public NbtSocket(final NbtAddress address, final int port) throws IOException {
        this(address, port, null, 0);
    }

    /**
     * Constructs an NbtSocket with specified local and remote addresses.
     *
     * @param address the NetBIOS address to connect to
     * @param port the remote port number, or 0 for the default NetBIOS session service port

    stream limits. This update also fixes `Call.cancel()` to not do I/O on the
    calling thread.
 *  Fix: Don't log gzipped data in the logging interceptor.
 *  Fix: Don't resolve DNS addresses when connecting through a SOCKS proxy.
 *  Fix: Drop the synthetic `OkHttp-Selected-Protocol` response header.
 *  Fix: Support 204 and 205 'No Content' replies in the logging interceptor.
 *  New: Add `Call.isExecuted()`.

        Address address = mockAddress;

        // When & Then - verify interface methods exist and can be called
        assertDoesNotThrow(() -> {
            address.getHostName();
            address.getHostAddress();
            address.firstCalledName();
            address.nextCalledName(mockContext);
            address.toInetAddress();
            address.unwrap(Address.class);

    from pydantic import BaseModel

    class Address(BaseModel):
        """
        This is a public description of an Address
        \f
        You can't see this part of the docstring, it's private!
        """

        line_1: str
        city: str
        state_province: str

    class Facility(BaseModel):
        id: str
        address: Address

    app = FastAPI()

     *
     * @param tc
     *            context to use
     * @param address the server address
     * @param port the port number
     * @param exclusive
     *            whether to acquire an unshared connection
     * @return a transport connection to the target
     */
    SmbTransport getSmbTransport(CIFSContext tc, Address address, int port, boolean exclusive);

    /**
     * Get transport connection
     *

    // If the non-host fields of the address don't overlap, we're done.
    if (!this.route.address.equalsNonHost(address)) return false

    // If the host exactly matches, we're done: this connection can carry the address.
    if (address.url.host ==
      this
        .route()
        .address.url.host
    ) {
      return true // This connection is a perfect match.
    }

      connectionSpecs = connectionSpecs,
      proxySelector = proxySelector,
    )

  fun newRoute(
    address: Address = newAddress(),
    proxy: Proxy = this.proxy,
    socketAddress: InetSocketAddress = InetSocketAddress.createUnresolved(uriHost, uriPort),
  ): Route =
    Route(
      address = address,
      proxy = proxy,
      socketAddress = socketAddress,
    )