import spock.lang.Specification

class IgnoringResourceHasherTest extends Specification {
    def delegate = Mock(ResourceHasher)
    def resourceFilter = Mock(ResourceFilter)
    def hasher = new IgnoringResourceHasher(delegate, resourceFilter)
    def snapshot = new RegularFileSnapshot("path", "path", TestHashCodes.hashCodeFrom(456), DefaultFileMetadata.file(3456, 456, FileMetadata.AccessType.DIRECT))

        buildScript """
apply plugin: 'java'
apply plugin: 'eclipse'

eclipse {
  project {
    resourceFilter {
      appliesTo = 'FILES_AND_FOLDERS'
      type = 'EXCLUDE_ALL'
      matcher {
        id = 'org.eclipse.some.custom.matcher'
        arguments = 'foobar'
      }
    }
    resourceFilter {
      appliesTo = 'FILES_AND_FOLDERS'
      type = 'EXCLUDE_ALL'
      matcher {

        StringInterner stringInterner,
        FileCollectionSnapshotter fileCollectionSnapshotter,
        ResourceSnapshotterCacheService resourceSnapshotterCacheService,
        ResourceFilter resourceFilter,
        ResourceEntryFilter metaInfFilter,
        Map<String, ResourceEntryFilter> propertiesFileFilters
        ) {

        return ignoringResourceHasher(resourceHasher, classpathResourceFilter);
    }

    private static ResourceHasher ignoringResourceHasher(ResourceHasher delegate, ResourceFilter resourceFilter) {
        return new IgnoringResourceHasher(delegate, resourceFilter);
    }

    private static ResourceHasher propertiesFileHasher(ResourceHasher delegate, Map<String, ResourceEntryFilter> propertiesFileFilters) {

import org.gradle.api.internal.changedetection.state.ResourceFilter;
import org.gradle.normalization.RuntimeClasspathNormalization;

import javax.annotation.Nullable;
import java.util.Map;

public interface RuntimeClasspathNormalizationInternal extends RuntimeClasspathNormalization {
    ResourceFilter getClasspathResourceFilter();

    ResourceEntryFilter getManifestAttributeResourceEntryFilter();

import org.gradle.api.internal.cache.StringInterner;
import org.gradle.api.internal.changedetection.state.ResourceEntryFilter;
import org.gradle.api.internal.changedetection.state.ResourceFilter;
import org.gradle.api.internal.changedetection.state.ResourceSnapshotterCacheService;
import org.gradle.api.internal.changedetection.state.RuntimeClasspathResourceHasher;

import jcifs.CIFSException;
import jcifs.CloseableIterator;
import jcifs.ResourceFilter;
import jcifs.SmbResource;


abstract class FileEntryAdapterIterator implements CloseableIterator<SmbResource> {

    private static final Logger log = LoggerFactory.getLogger(FileEntryAdapterIterator.class);

    private final CloseableIterator<FileEntry> delegate;
    private final ResourceFilter filter;
    private final SmbResource parent;

)

func testResourceClassParameters(name, namespace string, filters []resource.ResourceFilter) *resource.ResourceClassParameters {
	return &resource.ResourceClassParameters{
		ObjectMeta: metav1.ObjectMeta{
			Name:      name,
			Namespace: namespace,
		},
		Filters: filters,
	}
}

var goodFilters []resource.ResourceFilter

func TestValidateResourceClassParameters(t *testing.T) {
	goodName := "foo"

import jcifs.CloseableIterator;
import jcifs.ResourceFilter;
import jcifs.SmbConstants;
import jcifs.SmbResource;


class DirFileEntryAdapterIterator extends FileEntryAdapterIterator {

    /**
     * @param parent
     * @param delegate
     * @param filter
     */
    public DirFileEntryAdapterIterator ( SmbResource parent, CloseableIterator<FileEntry> delegate, ResourceFilter filter ) {
        super(parent, delegate, filter);

import java.util.Set;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import jcifs.Address;
import jcifs.CIFSContext;
import jcifs.CIFSException;
import jcifs.CloseableIterator;
import jcifs.ResourceFilter;
import jcifs.ResourceNameFilter;
import jcifs.SmbConstants;
import jcifs.SmbResource;
import jcifs.SmbResourceLocator;
import jcifs.dcerpc.DcerpcException;
import jcifs.dcerpc.DcerpcHandle;