@Test
    void testGetHealthyChannels() throws UnknownHostException {
        assertTrue(channelManager.getHealthyChannels().isEmpty());

        // Add a healthy channel manually for testing
        InetAddress addr = InetAddress.getByName("192.168.1.100");
        NetworkInterfaceInfo localInterface = new NetworkInterfaceInfo(addr, 1000);
        NetworkInterfaceInfo remoteInterface = new NetworkInterfaceInfo(addr, 1000);

        InetAddress localhost = InetAddress.getLocalHost();
        InetAddress loopback = InetAddress.getLoopbackAddress();

        // Use reflection to access private method for testing
        java.lang.reflect.Method method =
                MultiChannelManager.class.getDeclaredMethod("createChannelTransport", InetAddress.class, InetAddress.class);
        method.setAccessible(true);

            final String ipv6Address = host.substring(1, host.length() - 1);
            return InetAddress.getAllByName(ipv6Address);
        }
        return InetAddress.getAllByName(toAscii(host));
    }

    /**
     * Returns the canonical host name for the given host.
     * This method returns the host name obtained from the address.
     *
     * @param host the host name to resolve

   * 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

     *
     * @return the ip address
     */
    String getHostAddress();

    /**
     * Converts this address to an InetAddress.
     *
     * @return this address as an InetAddress
     * @throws UnknownHostException if the host cannot be resolved
     */
    InetAddress toInetAddress() throws UnknownHostException;

    /**
     * Guess called name to try for session establishment. These

    val nsType: Int,
    val flags: Int,
    val callback: DnsResolver.Callback<List<InetAddress>>,
  )

  @Implementation
  fun query(
    network: Network?,
    domain: String,
    nsType: Int,
    flags: Int,
    executor: Executor,
    cancellationSignal: CancellationSignal?,
    callback: DnsResolver.Callback<List<InetAddress>>,
  ) {
    responder(Request(network, domain, nsType, flags, callback))
  }

  @Override public ServerSocket createServerSocket(int port, int backlog) throws IOException {
    return createServerSocket();
  }

  @Override public ServerSocket createServerSocket(
      int port, int backlog, InetAddress inetAddress) throws IOException {
    return createServerSocket();
  }

  final class UnixDomainServerSocket extends ServerSocket {
    private UnixServerSocketChannel serverSocketChannel;

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

package jcifs.smb1.netbios;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;

import jcifs.smb1.Config;
import jcifs.smb1.util.LogStream;

/**
Do not use this class. Writing to the OutputStream of this type of socket

    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);

 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package jcifs.internal.witness;

import java.net.InetAddress;
import java.util.concurrent.atomic.AtomicLong;

/**
 * Represents a witness service registration for SMB resource monitoring.
 * This class maintains registration state, heartbeat information, and