*
     * @return list of network interface information
     */
    public List<NetworkInterfaceInfo> getInterfaces() {
        return interfaces;
    }

    /**
     * Set the list of network interfaces
     *
     * @param interfaces list of network interface information
     */
    public void setInterfaces(List<NetworkInterfaceInfo> interfaces) {
        this.interfaces = interfaces;
    }

    /**

        // is efficient.
        || (Proxy.isProxyClass(arg.getClass())
            && Arrays.equals(arg.getClass().getInterfaces(), proxyClass.getInterfaces()));
  }

     *            the target interface
     */
    protected void setupFieldDescsByInterface(final Class<?> interfaceClass) {
        addFieldDescs(interfaceClass);
        final Class<?>[] interfaces = interfaceClass.getInterfaces();
        for (final Class<?> intf : interfaces) {
            setupFieldDescsByInterface(intf);
        }
    }

    /**
     * Prepares the fields defined in the class.
     *

        // Assert it's an interface and extends the right superinterface
        assertTrue(clazz.isInterface(), "Should be an interface");
        assertTrue(Arrays.asList(clazz.getInterfaces()).contains(SmbResourceLocator.class), "Should extend SmbResourceLocator");

        // shouldForceSigning(): boolean, no params, no checked exceptions
        Method m1 = clazz.getMethod("shouldForceSigning");

    }

    @Test
    @DisplayName("Test interface extends Decodable")
    void testExtendsDecodable() {
        Class<?>[] interfaces = SecurityInfo.class.getInterfaces();
        assertTrue(Arrays.asList(interfaces).contains(jcifs.Decodable.class), "SecurityInfo should extend Decodable interface");
    }

    @Test
    @DisplayName("Test all constant fields count")

        if (superClass != null) {
            gatherTypeVariables(superClass, superClassType, map);
        }

        final Class<?>[] interfaces = clazz.getInterfaces();
        final Type[] interfaceTypes = clazz.getGenericInterfaces();
        for (int i = 0; i < interfaces.length; ++i) {
            gatherTypeVariables(interfaces[i], interfaceTypes[i], map);
        }

        }

        QueryNetworkInterfaceInfoResponse response = new QueryNetworkInterfaceInfoResponse();
        response.decode(data, 0, data.length);

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

        // Sort by score (best interfaces first)

  public <T, T1 extends T> void testAssignableGenericArrayToClass() {
    assertTrue(TypeToken.of(Object[].class.getSuperclass()).isSupertypeOf(new TypeToken<T[]>() {}));
    for (Class<?> interfaceType : Object[].class.getInterfaces()) {
      assertTrue(TypeToken.of(interfaceType).isSupertypeOf(new TypeToken<T[]>() {}));
    }
    assertTrue(TypeToken.of(Object.class).isSupertypeOf(new TypeToken<T[]>() {}));

  public <T, T1 extends T> void testAssignableGenericArrayToClass() {
    assertTrue(TypeToken.of(Object[].class.getSuperclass()).isSupertypeOf(new TypeToken<T[]>() {}));
    for (Class<?> interfaceType : Object[].class.getInterfaces()) {
      assertTrue(TypeToken.of(interfaceType).isSupertypeOf(new TypeToken<T[]>() {}));
    }
    assertTrue(TypeToken.of(Object.class).isSupertypeOf(new TypeToken<T[]>() {}));