return rdmaCapable;
    }

    /**
     * Check if this interface is usable for multi-channel
     *
     * @return true if usable
     */
    public boolean isUsableForChannel() {
        return address != null && !address.isLoopbackAddress() && !address.isLinkLocalAddress();
    }

    /**
     * Get a score for interface selection (higher is better)
     *

        this.rssCapable = checkRSSCapability();
        if (rssCapable) {
            this.capability |= NETWORK_INTERFACE_CAP_RSS;
        }
    }
    
    public boolean isUsableForChannel() {
        return address != null && !address.isLoopbackAddress() 
            && !address.isLinkLocalAddress();
    }
    
    public int getScore() {
        // Score interface for selection (higher is better)

    void testIsUsableForChannel() {
        NetworkInterfaceInfo usable = new NetworkInterfaceInfo(testAddress, 1000);
        assertTrue(usable.isUsableForChannel());

        NetworkInterfaceInfo loopback = new NetworkInterfaceInfo(loopbackAddress, 1000);
        assertFalse(loopback.isUsableForChannel());
    }

    @Test
    void testGetScore() {
        NetworkInterfaceInfo basic = new NetworkInterfaceInfo(testAddress, 1000);

        response.decode(data, 0, data.length);

        for (NetworkInterfaceInfo info : response.getInterfaces()) {
            if (info.isUsableForChannel()) {
                remoteInterfaces.add(info);
            }
        }

        // Sort by score (best interfaces first)
        remoteInterfaces.sort((a, b) -> Integer.compare(b.getScore(), a.getScore()));