}
	if patches := cfilter.Patches[networking.EnvoyFilter_INVALID]; len(patches) != 1 {
		t.Fatalf("unexpected patches of %v: %v", networking.EnvoyFilter_INVALID, cfilter.Patches)
	}
	if patches := cfilter.Patches[networking.EnvoyFilter_HTTP_ROUTE]; len(patches) != 1 { // check num of invalid http route patches
		t.Fatalf("unexpected patches of %v: %v", networking.EnvoyFilter_HTTP_ROUTE, cfilter.Patches)
	}

        when:
        def watched = resolveWatchedFiles(watchable, buildHierarchy([]))
        then:
        rootsOf(watched) == []
        1 * watchable.stream() >> Stream.of()
    }

    def "watches empty directory"() {
        def watchable = Mock(WatchableHierarchies)
        def dir = new File("empty").absoluteFile

        when:
        def watched = resolveWatchedFiles(watchable, buildHierarchy([

		t.Error("incorrect batch result")
	}
}

func TestBatchedError(t *testing.T) {
	b := batched(func(p []byte) error { return errors.New("failure") }, 5)
	if b(make([]byte, 13)) == nil {
		t.Fatal("batched function should have returned an error")
	}
}

func TestBatchedEmpty(t *testing.T) {
	b := batched(func(p []byte) error { return errors.New("failure") }, 5)
	if b(make([]byte, 0)) != nil {

Michael Hudgins <******@****.***> 1695048765 +0000

// Implements XdsCacheEntry interface.
type clusterCache struct {
	clusterName string

	// proxy related cache fields
	proxyVersion    string         // will be matched by envoyfilter patches
	locality        *core.Locality // identifies the locality the cluster is generated for
	proxyClusterID  string         // identifies the kubernetes cluster a proxy is in

    // filter flags

    /**
     * Any file name change in the watched directory or subtree causes a change notification wait operation to return.
     * Changes include renaming, creating, or deleting a file.
     */
    public static final int FILE_NOTIFY_CHANGE_FILE_NAME = 0x00000001;

    /**
     * Any directory-name change in the watched directory or subtree causes a change notification wait operation to

}

func TestBuildParser(t *testing.T) {
	for _, tt := range buildParserTests {
		matched, err := matchexpr(tt.x)
		if matched != tt.matched || !reflect.DeepEqual(err, tt.err) {
			t.Errorf("matchexpr(%q) = %v, %v; want %v, %v", tt.x, matched, err, tt.matched, tt.err)
		}
	}

 * - When updating the watches, we watch watchable hierarchies registered for this build or old watched directories from previous builds instead of
 *   directories inside them.
 * - At the end of the build
 *   - stop watching the watchable directories with nothing to watch inside
 *   - remember the currently watched directories as old watched directories for the next build

	}
	return count
}

// Match returns a subset of Responses that match the given predicate.
func (r Responses) Match(f func(r Response) bool) Responses {
	var matched []Response
	for _, rr := range r {
		if f(rr) {
			matched = append(matched, rr)
		}
	}
	return matched
}

func (r Responses) String() string {
	out := ""
	for i, resp := range r {
		out += fmt.Sprintf("Response[%d]:\n%s", i, resp.String())
	}

        boolean matched = false;
        for (Iterator<String> i = patterns.iterator(); i.hasNext() & !matched; ) {
            // TODO what about wildcards? Just specifying groups? versions?
            if (id.equals(i.next())) {
                matched = true;
            }
        }
        return matched;
    }

    public List<String> getPatterns() {