final UniAddress[] addrs = new UniAddress[iaddrs.length];
        for (int ii = 0; ii < iaddrs.length; ii++) {
            addrs[ii] = new UniAddress(iaddrs[ii]);
        }
        return addrs;
    }

    private static UniAddress[] wrapNetbiosAddresses(final NetbiosAddress[] addr) {
        final UniAddress[] addrs = new UniAddress[addr.length];

        Address addr1 = mock(Address.class);
        when(addr1.getHostAddress()).thenReturn("10.0.0.1");

        Address addr2 = mock(Address.class);
        when(addr2.getHostAddress()).thenReturn("10.0.0.2");

        when(nameSvc.getAllByName(eq("test.server"), eq(true))).thenReturn(new Address[] { addr1, addr2 });

        // Set fail counts (addr1 has more failures, addr2 has fewer)

  public val settings: Settings

  public constructor(
    code: Int = 200,
    headers: Headers = headersOf(),
    body: String = "",
  ) : this(
    Builder()
      .code(code)
      .headers(headers)
      .body(body),
  )

  private constructor(builder: Builder) {
    this.status = builder.status
    this.headers = builder.headers
    this.trailers = builder.trailers
    this.body = builder.body

        WitnessNotification.WitnessIPAddress addr4 = new WitnessNotification.WitnessIPAddress(ipv4);
        WitnessNotification.WitnessIPAddress addr6 = new WitnessNotification.WitnessIPAddress(ipv6);

        // IPv4 tests
        assertTrue(addr4.isIPv4());
        assertFalse(addr4.isIPv6());
        assertEquals(WitnessNotification.WitnessIPAddress.IPV4, addr4.getFlags());

        // IPv6 tests

      value: String,
    ) = apply {
      headers.add(name, value)
    }

    /** Removes all headers named [name] on this builder. */
    open fun removeHeader(name: String) =
      apply {
        headers.removeAll(name)
      }

    /** Removes all headers on this builder and adds [headers]. */
    open fun headers(headers: Headers) =
      apply {
        this.headers = headers.newBuilder()
      }

			}

			for i, hdr := range hdrs {
				if i >= len(v.headers) {
					t.Fatalf("entry %d: unexpected header:\ngot %+v", i, *hdr)
				}
				if !reflect.DeepEqual(*hdr, *v.headers[i]) {
					t.Fatalf("entry %d: incorrect header:\ngot  %+v\nwant %+v", i, *hdr, *v.headers[i])
				}
			}
			if len(hdrs) != len(v.headers) {
				t.Fatalf("got %d headers, want %d headers", len(hdrs), len(v.headers))
			}

        InetAddress addr1 = InetAddress.getByName("192.168.1.100");
        InetAddress addr2 = InetAddress.getByName("192.168.1.101");
        NetworkInterfaceInfo local = new NetworkInterfaceInfo(addr1, 1000);
        NetworkInterfaceInfo remote1 = new NetworkInterfaceInfo(addr1, 1000);
        NetworkInterfaceInfo remote2 = new NetworkInterfaceInfo(addr2, 10000); // Faster interface

	HADDPS (BX), X2                         // f20f7c13
	HADDPS (R11), X2                        // f2410f7c13
	HADDPS X2, X2                           // f20f7cd2
	HADDPS X11, X2                          // f2410f7cd3
	HADDPS (BX), X11                        // f2440f7c1b
	HADDPS (R11), X11                       // f2450f7c1b
	HADDPS X2, X11                          // f2440f7cda

			}
		}
	}
}

func TestSameLocalAddrs(t *testing.T) {
	testCases := []struct {
		addr1       string
		addr2       string
		sameAddr    bool
		expectedErr error
	}{
		{"", "", false, errors.New("unable to process empty address")},
		{":9000", ":9000", true, nil},
		{"localhost:9000", ":9000", true, nil},

        final String addr = prp.getProperty("jcifs.smb1.smb.client.laddr");

        if (addr != null) {
            try {
                return InetAddress.getByName(addr);
            } catch (final UnknownHostException uhe) {
                if (LogStream.level > 0) {
                    log.println("Ignoring jcifs.smb1.smb.client.laddr address: " + addr);
                    uhe.printStackTrace(log);