for _, test := range tests {
		parser.start(lex.Tokenize(test.input))
		addr := obj.Addr{}
		parser.operand(&addr)
		var result string
		if parser.allowABI {
			result = obj.DconvWithABIDetail(&emptyProg, &addr)
		} else {
			result = obj.Dconv(&emptyProg, &addr)
		}
		if result != test.output {
			t.Errorf("fail at %s: got %s; expected %s\n", test.input, result, test.output)
		}

     */
    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;

    /**

        final SmbResourceLocator locator = parent.getLocator();
        if (locator.getURL().getHost().isEmpty()) {
            // smb:// -> enumerate servers through browsing
            Address addr;
            try {
                addr = locator.getAddress();
            } catch (final CIFSException e) {
                if (e.getCause() instanceof UnknownHostException) {
                    log.debug("Failed to find master browser", e);

					if elem.Kind() == reflect.Map {
						processMap(elem)
						continue
					}
					appendToFieldValues(elem.Addr())
				}
			case reflect.Struct:
				if !rv.CanAddr() {
					association.Error = ErrInvalidValue
					return
				}
				appendToFieldValues(rv.Addr())
			}

			if association.Error == nil {

            InetAddress addr = parseSockaddr(data, offset + 24);
            
            NetworkInterfaceInfo info = new NetworkInterfaceInfo(
                addr, (int)(linkSpeed / 1000000));
            info.setInterfaceIndex(ifIndex);
            info.setCapability(capability);
            
            if (info.isUsableForChannel()) {
                remoteInterfaces.add(info);
            }
            

    }

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

type ReconnectRESTClient struct {
	u    *url.URL
	rest *rest.Client
}

// newClient constructs a ReconnectRESTClient object with addr and endpoint initialized.
// It _doesn't_ connect to the remote endpoint. See Call method to see when the
// connect happens.
func newClient(endpoint string) NetLocker {
	u, err := url.Parse(endpoint)
	if err != nil {

		{"DATA", "·B(SB)/4,$0", ""},
		{"DATA", "·C(SB)/5,$0", "bad int size for DATA argument: 5"},
		{"DATA", "·D(SB)/5,$0.0", "bad float size for DATA argument: 5"},
		{"DATA", "·E(SB)/4,$·A(SB)", "bad addr size for DATA argument: 4"},
		{"DATA", "·F(SB)/8,$·A(SB)", ""},
		{"DATA", "·G(SB)/5,$\"abcde\"", ""},
		{"GLOBL", "", "expect two or three operands for GLOBL"},

            }
        } 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 {