*/
        if (pathNamesPossiblyEqual(this.url.getPath(), o.url.getPath()) && getURLPath().equalsIgnoreCase(o.getURLPath())) {
            try {
                return getAddress().equals(o.getAddress());
            } catch (final CIFSException uhe) {
                log.debug("Unknown host", uhe);
                return getServer().equalsIgnoreCase(o.getServer());
            }
        }

     * @param linkSpeed link speed in Mbps
     */
    public NetworkInterfaceInfo(InetAddress address, int linkSpeed) {
        this.address = address;
        this.linkSpeed = linkSpeed;
        this.ipv6 = address.getAddress().length == 16;
        this.capability = 0;

        // Check for RSS capability
        this.rssCapable = checkRSSCapability();
        if (rssCapable) {

            assertEquals(inetAddress, uniAddress.getAddress());
        }

        @Test
        void shouldConstructWithNbtAddress() {
            NbtAddress nbtAddress = mock(NbtAddress.class);
            UniAddress uniAddress = new UniAddress(nbtAddress);
            assertNotNull(uniAddress);
            assertEquals(nbtAddress, uniAddress.getAddress());
        }

        @Test

        SmbResourceLocatorImpl l1 = locator("smb://host/share?server=srv-from-query");
        assertSame(a1, l1.getAddress());

        // Query parameter 'address' builds UniAddress from IP
        SmbResourceLocatorImpl l2 = locator("smb://host/share?address=127.0.0.1");
        Address first = l2.getAddress();
        assertTrue(first instanceof UniAddress);

        // Host with root path -> possibleNTDomainOrWorkgroup=true

        return buffer;
    }
    
    public int getLocalKey() { return localKey; }
    public int getRemoteKey() { return remoteKey; }
    public long getAddress() { return address; }
    public int getSize() { return buffer.remaining(); }
    
    public boolean hasAccess(RdmaAccess access) {
        return accessFlags.contains(access);
    }
    
    /**

        assertEquals(ipv4, newIPv4.getAddress());
        assertTrue(newIPv4.isIPv4());
        assertFalse(newIPv4.isIPv6());
        assertEquals(WitnessNotification.WitnessIPAddress.IPV4, newIPv4.getFlags());

        // Check IPv6 address
        WitnessNotification.WitnessIPAddress newIPv6 = newAddresses.get(1);
        assertEquals(ipv6, newIPv6.getAddress());
        assertFalse(newIPv6.isIPv4());

            when(locator.getURL()).thenReturn(anyUrlWithEmptyHost);
            // Simulate failure to find master browser (UnknownHost wrapped in CIFSException)
            when(locator.getAddress()).thenThrow(new CIFSException("no master", new UnknownHostException("MB")));

            // Act + Assert: the code maps this case to SmbUnsupportedOperationException

     */
    public int getRemoteKey() {
        return transform.getToken();
    }

    /**
     * Get remote memory address
     *
     * @return remote memory address (offset)
     */
    public long getAddress() {
        return transform.getOffset();
    }

    /**
     * Get length of memory region
     *
     * @return length in bytes
     */
    public int getLength() {

    }

    @Test
    void testGetAddress() {
        // Test getAddress for correct byte array conversion
        mockName = new Name(mockConfig, "TEST", 0x20, null);
        NbtAddress nbtAddress = new NbtAddress(mockName, testAddressInt, false, NbtAddress.H_NODE);
        assertArrayEquals(new byte[] { (byte) 192, (byte) 168, (byte) 1, (byte) 1 }, nbtAddress.getAddress());
    }

    @Test

    }

    /**
     * Get the address the service is listening on
     *
     * @return the service address
     * @throws IOException if address cannot be determined
     */
    public InetAddress getAddress() throws IOException {
        if (serverSocket == null) {
            throw new IOException("Service not started");
        }
        return InetAddress.getLocalHost();
    }

    /**