public InetAddress getAddress() { return address; }
        public int getFlags() { return flags; }
        public boolean isIPv4() { return (flags & IPV4) != 0; }
        public boolean isIPv6() { return (flags & IPV6) != 0; }
    }
    
    public void addNewIPAddress(InetAddress address) {
        newIPAddresses.add(new WitnessIPAddress(address));
    }
    
    public void addOldIPAddress(InetAddress address) {

            return ((NbtAddress) this.addr).getHostAddress();
        }
        return ((InetAddress) this.addr).getHostAddress();
    }

    /**
     * {@inheritDoc}
     *
     * @throws UnknownHostException if the host cannot be resolved
     *
     * @see jcifs.Address#toInetAddress()
     */
    @Override
    public InetAddress toInetAddress() throws UnknownHostException {
        if (this.addr instanceof Address) {

   * either a connection is made, the set of IP addresses is exhausted, or a limit is exceeded.
   */
  @Throws(UnknownHostException::class)
  fun lookup(hostname: String): List<InetAddress>

  companion object {
    /**
     * A DNS that uses [InetAddress.getAllByName] to ask the underlying operating system to
     * lookup IP addresses. Most custom [Dns] implementations should delegate to this instance.
     */
    @JvmField

    void testNetworkAddressDelegation() throws UnknownHostException {
        // Given
        InetAddress localAddr = InetAddress.getByName("127.0.0.1");
        InetAddress broadcastAddr = InetAddress.getByName("192.168.1.255");
        InetAddress[] winsServers = { InetAddress.getByName("192.168.1.1") };

        when(mockDelegate.getLocalAddr()).thenReturn(localAddr);

    private NetworkInterfaceInfo remoteInterface;
    private ChannelInfo channelInfo;

    @BeforeEach
    void setUp() throws UnknownHostException {
        InetAddress localAddr = InetAddress.getByName("192.168.1.100");
        InetAddress remoteAddr = InetAddress.getByName("192.168.1.200");

        localInterface = new NetworkInterfaceInfo(localAddr, 1000);
        remoteInterface = new NetworkInterfaceInfo(remoteAddr, 1000);

  override fun createSocket(
    host: String,
    port: Int,
    localAddress: InetAddress,
    localPort: Int,
  ): SSLSocket {
    val sslSocket = delegate.createSocket(host, port, localAddress, localPort) as SSLSocket
    return configureSocket(sslSocket)
  }

  @Throws(IOException::class)
  override fun createSocket(
    host: InetAddress,
    port: Int,
  ): SSLSocket {

            return Collections.emptyList();
        }
    }

    private InetAddress getLocalAddressForInterface(NetworkInterface netInterface) {
        return netInterface.getInetAddresses().nextElement();
    }

    private SmbTransportImpl createChannelTransport(InetAddress localAddress, InetAddress serverAddress) throws CIFSException {
        try {
            // Create Address wrapper for server address

        /*
         * Determine the InetAddress of the local interface
         * if one was not specified.
         */
        InetAddress localInetAddress = tc.getConfig().getNetbiosLocalAddress();
        if (localInetAddress == null) {
            try {
                localInetAddress = InetAddress.getLocalHost();
            } catch (final UnknownHostException uhe) {
                /*

    @Test
    void testGetNbtAllByName() throws UnknownHostException {
        // Arrange
        String host = "testHost";
        int type = 0x20;
        String scope = "testScope";
        InetAddress svr = mock(InetAddress.class);
        NetbiosAddress[] expectedAddresses = { mock(NetbiosAddress.class) };
        when(nameServiceClient.getNbtAllByName(host, type, scope, svr)).thenReturn(expectedAddresses);

        // Act

  override fun createSocket(
    host: String,
    port: Int,
    localAddress: InetAddress,
    localPort: Int,
  ): Socket {
    val socket = delegate.createSocket(host, port, localAddress, localPort)
    return configureSocket(socket)
  }

  @Throws(IOException::class)
  override fun createSocket(
    host: InetAddress,
    port: Int,
  ): Socket {
    val socket = delegate.createSocket(host, port)