utilfs "k8s.io/kubernetes/pkg/util/filesystem"
)

// Mock filesystem watcher
type fakeWatcher struct {
	watches      []string // List of watches added by the prober, ordered from least recent to most recent.
	eventHandler utilfs.FSEventHandler
}

var _ utilfs.FSWatcher = &fakeWatcher{}

func newFakeWatcher() *fakeWatcher {
	return &fakeWatcher{
		watches: nil,
	}
}

	// test add nested subdir inside testDriverName
	basePath := testDriverPath
	for i := 0; i < 10; i++ {
		subdirName := "subdirName"
		subdirPath := filepath.Join(basePath, subdirName)
		fs.MkdirAll(subdirPath, 0777)
		watcher.TriggerEvent(fsnotify.Create, subdirPath)
		// Assert
		assert.Equal(t, 4+i, len(watcher.watches)) // 3 + newly added

	if requestInfo == nil || readOnlyVerbs.Has(requestInfo.Verb) {
		return 0
	}

	result := 0
	// The watches that we're interested in include:
	// - watches for all objects of a resource type (no namespace and name specified)
	// - watches for all objects of a resource type in the same namespace (no name specified)
	// - watched interested in this particular object
	identifier := &watchIdentifier{
		apiGroup: requestInfo.APIGroup,

	wg := sync.WaitGroup{}
	wg.Add(len(watches))
	for i := range watches {
		// Verify that each watcher only gets the first event because its watch
		// queue of length one was full from the first one.
		go func(watcher int, w Interface) {
			defer wg.Done()
			e1, ok := <-w.ResultChan()
			if !ok {
				t.Errorf("Watcher %v failed to retrieve first event.", watcher)
			}

				APIGroup: "foo.bar",
				Resource: "events",
			},
			counts: map[string]int64{
				"events.foo.bar": 799,
			},
			initialSeatsExpected: 8,
		},
		{
			name:       "request verb is create, no watches",
			requestURI: "http://server/apis/foo.bar/v1/foos",
			requestInfo: &apirequest.RequestInfo{
				Verb:     "create",
				APIGroup: "foo.bar",
				Resource: "foos",
			},
			maxSeats:                  10,

        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([

)

// WaitForAPIServerSyncPeriod is the period between checks for the node list/watch initial sync
const WaitForAPIServerSyncPeriod = 1 * time.Second

// NewSourceApiserver creates a config source that watches and pulls from the apiserver.
func NewSourceApiserver(c clientset.Interface, nodeName types.NodeName, nodeHasSynced func() bool, updates chan<- interface{}) {

apiVersion: release-notes/v2
kind: feature
area: istioctl
issue:
  - 35485

releaseNotes:
- |

	}
	r.watchers[gvr][ns] = append(r.watchers[gvr][ns], fakewatcher)
	return fakewatcher, nil
}

func (r *VolumeReactor) getWatches(gvr schema.GroupVersionResource, ns string) []*watch.RaceFreeFakeWatcher {
	watches := []*watch.RaceFreeFakeWatcher{}
	if r.watchers[gvr] != nil {
		if w := r.watchers[gvr][ns]; w != nil {
			watches = append(watches, w...)
		}
		if ns != metav1.NamespaceAll {

apiVersion: release-notes/v2
kind: bug-fix
area: security
issue:
- 35231

releaseNotes:
- |