// Test failover mechanism
        ChannelFailover failover = new ChannelFailover(channelManager);

        // Create a channel
        InetAddress addr = InetAddress.getByName("192.168.1.100");
        NetworkInterfaceInfo nic = new NetworkInterfaceInfo(addr, 445);

        // Mock transport doesn't have isConnected, but we can work around it
        ChannelInfo channel = new ChannelInfo("failover-test", mockTransport, nic, nic);

	}
	return strings.Fields(v)
}

func configCommonToSrvCtx(cf config.ServerConfigCommon, ctxt *serverCtxt) {
	ctxt.RootUser = cf.RootUser
	ctxt.RootPwd = cf.RootPwd

	if cf.Addr != "" {
		ctxt.Addr = cf.Addr
	}
	if cf.ConsoleAddr != "" {
		ctxt.ConsoleAddr = cf.ConsoleAddr
	}
	if cf.CertsDir != "" {
		ctxt.CertsDir = cf.CertsDir
		ctxt.certsDirSet = true
	}

     */
    public int encode(byte[] dst, int dstIndex) {
        return transform.encode(dst, dstIndex);
    }

    @Override
    public String toString() {
        return String.format("RdmaChannelInfo[key=0x%x, addr=0x%x, len=%d]", getRemoteKey(), getAddress(), getLength());
    }

     * host with the same IP address.
     *
     * @param addr
     *            the address to query
     * @return resolved addresses
     * @throws UnknownHostException
     *             if address cannot be resolved
     */
    NetbiosAddress[] getNbtAllByAddress(NetbiosAddress addr) throws UnknownHostException;

    /**

				t.Errorf("error: expected = %v, got = %v", testCase.expectedErr, err)
			}
		})
	}
}

func TestExtractHostPort(t *testing.T) {
	testCases := []struct {
		addr        string
		host        string
		port        string
		expectedErr error
	}{
		{"", "", "", errors.New("unable to process empty address")},
		{"localhost:9000", "localhost", "9000", nil},

    }

    private static NtlmChallenge interrogate(final CIFSContext tf, final Address addr) throws SmbException {
        final UniAddress dc = new UniAddress(addr);
        try (SmbTransportInternal trans = tf.getTransportPool()
                .getSmbTransport(tf, dc, 0, false, tf.hasDefaultCredentials() && tf.getConfig().isIpcSigningEnforced())

func (m *MockConnMeta) ClientVersion() []byte {
	return []byte{}
}

func (m *MockConnMeta) ServerVersion() []byte {
	return []byte{}
}

func (m *MockConnMeta) RemoteAddr() net.Addr {
	return nil
}

func (m *MockConnMeta) LocalAddr() net.Addr {
	return nil
}

func newSSHConnMock(username string) ssh.ConnMetadata {
	return &MockConnMeta{username: username}
}

func TestSFTPAuthentication(t *testing.T) {

            }
        } while (dr != start);
        throw last;
    }

    /**
     * @param loc
     * @param addr
     * @param trans
     * @param t
     * @throws CIFSException
     */
    private SmbTreeImpl connectTree(final SmbResourceLocatorImpl loc, final String addr, final String share,
            final SmbTransportInternal trans, final SmbTreeImpl t, final DfsReferralData referral) throws CIFSException {

	anonAddr := func(addr string) string {
		if anonParam != anonymizeStrict {
			return addr
		}
		newAddr, found := hostAnonymizer[addr]
		if found {
			return newAddr
		}

		// If we reach here, it means that the given addr doesn't contain any of the hosts.
		// Return it as is. Can happen for drive paths in non-distributed mode
		return addr
	}

            long linkSpeed = readInt8(data, offset + 16);
            
            // Parse socket address
            InetAddress addr = parseSockaddr(data, offset + 24);
            
            NetworkInterfaceInfo info = new NetworkInterfaceInfo(
                addr, (int)(linkSpeed / 1000000));
            info.setInterfaceIndex(ifIndex);
            info.setCapability(capability);