//	LFMOV freg ',' addr
	//	{
	//		outcode(int($1), &$2, 0, &$4);
	//	}
	MOVF	F2, foo<>+3(SB)
	MOVF	F2, 16(R1)
	MOVF	F2, (R1)

	//
	// store ints and bytes
	//
	//	LMOVW rreg ',' addr
	//	{
	//		outcode(int($1), &$2, 0, &$4);
	//	}
	MOVW	R1, foo<>+3(SB)
	MOVW	R1, 16(R2)
	MOVW	R1, (R2)
	MOVW	R1, foo<>+3(SB)
	MOVW	R1, 16(R2)
	MOVW	R1, (R2)
	SC	R1, (R2)

	//	LMOVB rreg ',' addr
	//	{

        transport.server = serverData;

        smbtStatic = mockStatic(SmbTransport.class);
        smbtStatic.when(() -> SmbTransport.getSmbTransport(addr, 445, inet, 0, null)).thenReturn(transport);
        smbtStatic.when(() -> SmbTransport.getSmbTransport(addr, 445)).thenReturn(transport);
    }

    @AfterEach
    void tearDown() {
        if (smbtStatic != null) {
            smbtStatic.close();
        }
    }

	u, err := url.Parse(hostAddr)
	if err != nil {
		return "", "", err
	}

	addr = u.Host
	scheme = u.Scheme

	// Use the given parameter again if url.Parse()
	// didn't return any useful result.
	if addr == "" {
		addr = hostAddr
		scheme = "http"
	}

	// At this point, addr can be one of the following form:
	//	":9000"
	//	"localhost:9000"

func TestCopyUnixpacket(t *testing.T) {
	tmpDir := t.TempDir()
	socket := filepath.Join(tmpDir, "unixsock")

	// Start a unixpacket server.
	addr := &net.UnixAddr{
		Name: socket,
		Net:  "unixpacket",
	}
	server, err := net.ListenUnix("unixpacket", addr)
	if err != nil {
		t.Skipf("skipping test because opening a unixpacket socket failed: %v", err)
	}

	// Start a goroutine for the server to accept one connection

     * }
     */

    Object addr;
    String calledName;

    /**
     * Create a <code>UniAddress</code> by wrapping an {@code InetAddress} or
     * <code>NbtAddress</code>.
     *
     * @param addr
     *            wrapped address
     */
    public UniAddress(final Object addr) {
        if (addr == null) {
            throw new IllegalArgumentException();
        }

        // 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);
        ChannelInfo healthyChannel = new ChannelInfo("test-channel", mockTransport, localInterface, remoteInterface);

// local endpoints from given list of endpoints
func getLocalServerProperty(endpointServerPools EndpointServerPools, r *http.Request, metrics bool) madmin.ServerProperties {
	addr := globalLocalNodeName
	if r != nil {
		addr = r.Host
	}
	if globalIsDistErasure {
		addr = globalLocalNodeName
	}
	poolNumbers := make(map[int]struct{})
	network := make(map[string]string)
	for _, ep := range endpointServerPools {

        final String addr = props.getProperty(key);
        if (addr != null) {
            try {
                def = InetAddress.getByName(addr);
            } catch (final UnknownHostException uhe) {
                log.error("Unknown host " + addr, uhe);
            }
        }
        return def;
    }

    /**

    void firstCalledNameForInetAddressConformsToUpperCase(String hostname, String hostWithoutDot, String expectedPrefix) {
        // Arrange
        InetAddress addr = mock(InetAddress.class);
        when(addr.getHostName()).thenReturn(hostname);
        UniAddress ua = new UniAddress(addr);
        // Act
        String called = ua.firstCalledName();
        // Assert

                addr = new NbtAddress(name, ip, false, NbtAddress.B_NODE, false, false, true, true, NbtAddress.UNKNOWN_MAC_ADDRESS);
                if (log.isDebugEnabled()) {
                    log.debug("Adding " + name + " with addr " + addr);
                }
                this.table.put(name, addr);
            }
        }
    }