}
		for _, fc := range chains {

			name := fc.GetName()
			matches := newMatcher(fc, l)
			destination := getFilterType(fc.GetFilters())
			for _, match := range matches {
				fmt.Fprintf(w, "%v\t%v\t%v\t%v\n", lname, name, match, destination)
			}
		}
	}
	return w.Flush()
}

func newMatcher(fc *listener.FilterChain, l *listener.Listener) []string {
	if l.FilterChainMatcher == nil {

	ok = true
	if len(fuzzTests) == 0 || *isFuzzWorker {
		return ran, ok
	}
	m := newMatcher(deps.MatchString, *match, "-test.run", *skip)
	var mFuzz *matcher
	if *matchFuzz != "" {
		mFuzz = newMatcher(deps.MatchString, *matchFuzz, "-test.fuzz", *skip)
	}

	for _, procs := range cpuList {
		runtime.GOMAXPROCS(procs)
		for i := uint(0); i < *count; i++ {

	}

	s := settingsFromCommandLine.Clone()
	s.TestID = testID

	f, err := label.ParseSelector(s.SelectorString)
	if err != nil {
		return nil, err
	}
	s.Selector = f

	s.SkipMatcher, err = NewMatcher(s.SkipString)
	if err != nil {
		return nil, err
	}

	// NOTE: not using echo.VM, etc. here to avoid circular dependency.
	if s.SkipVM {
		s.SkipWorkloadClasses = append(s.SkipWorkloadClasses, "vm")
	}

	}
	// Collect matching benchmarks and determine longest name.
	maxprocs := 1
	for _, procs := range cpuList {
		if procs > maxprocs {
			maxprocs = procs
		}
	}
	ctx := &benchContext{
		match:  newMatcher(matchString, *matchBenchmarks, "-test.bench", *skip),
		extLen: len(benchmarkName("", maxprocs)),
	}
	var bs []InternalBenchmark
	for _, Benchmark := range benchmarks {

			}
			if i > 0 && !ran {
				// There were no tests to run on the first
				// iteration. This won't change, so no reason
				// to keep trying.
				break
			}
			ctx := newTestContext(*parallel, newMatcher(matchString, *match, "-test.run", *skip))
			ctx.deadline = deadline
			t := &T{
				common: common{
					signal:  make(chan bool, 1),
					barrier: make(chan bool),
					w:       os.Stdout,
				},

		t.Error("Expecting nil")
	}

	if ch := w.Events(name); ch != nil {
		t.Error("Expecting nil")
	}
}

func TestBadWatcher(t *testing.T) {
	w := NewWatcher()
	w.(*fileWatcher).funcs.newWatcher = func() (*fsnotify.Watcher, error) {
		return nil, errors.New("FOOBAR")
	}

	name := newWatchFile(t)
	if err := w.Add(name); err == nil {
		t.Errorf("Expecting error, got nil")
	}

type patchTable struct {
	newWatcher     func() (*fsnotify.Watcher, error)
	addWatcherPath func(*fsnotify.Watcher, string) error
}

// NewWatcher return with a FileWatcher instance that implemented with fsnotify.
func NewWatcher() FileWatcher {
	return &fileWatcher{
		workers: map[string]*workerState{},

		// replaceable functions for tests
		funcs: &patchTable{
			newWatcher: fsnotify.NewWatcher,

		assert.Equal(t, w.Mesh(), newM)
		break
	case <-time.After(time.Second * 5):
		t.Fatal("timed out waiting for update")
	}
}

func newWatcher(t testing.TB, filename string, multi bool) mesh.Watcher {
	t.Helper()
	w, err := mesh.NewFileWatcher(filewatcher.NewWatcher(), filename, multi)
	if err != nil {
		t.Fatal(err)
	}
	return w
}

func newTempFile(t testing.TB) string {
	t.Helper()

*/

package oom

import (
	v1 "k8s.io/api/core/v1"
	"k8s.io/client-go/tools/record"
)

type oomWatcherUnsupported struct{}

var _ Watcher = new(oomWatcherUnsupported)

// NewWatcher creates a fake one here
func NewWatcher(_ record.EventRecorder) (Watcher, error) {
	return &oomWatcherUnsupported{}, nil
}

func (ow *oomWatcherUnsupported) Start(_ *v1.ObjectReference) error {
	return nil

		return
	case <-time.After(wait.ForeverTestTimeout):
		t.Fatalf("Timeout while waiting for the plugin registration status")
	}
}

func newWatcher(t *testing.T, socketDir string, desiredStateOfWorldCache cache.DesiredStateOfWorld, stopCh <-chan struct{}) *Watcher {
	w := NewWatcher(socketDir, desiredStateOfWorldCache)
	require.NoError(t, w.Start(stopCh))

	return w