err = os.WriteFile(fileName, []byte{1, 2, 3}, 0555)
	if err != nil {
		t.Fatalf("unable to write test file %#v", err)
	}

	ch := make(chan interface{}, 1)
	lw := newSourceFile(fileName, "localhost", time.Millisecond, ch)
	err = lw.listConfig()
	if err == nil {
		t.Fatalf("expected error, got nil")
	}
	expectEmptyChannel(t, ch)
}

func TestExtractFromEmptyDir(t *testing.T) {
	dirName, err := mkTempDir("file-test")

			println("failed to start goroutine on main thread")
			os.Exit(1)
		}
		// Exit with the thread locked, which should exit the
		// main thread.
		ready <- true
	}()
	<-ready
	time.Sleep(1 * time.Millisecond)
	// Check that this goroutine is still running on a different
	// thread.
	self := C.pthread_self()
	if C.pthread_equal(mainThread, self) != 0 {
		println("goroutine migrated to locked thread")
		os.Exit(1)
	}

		if err != nil {
			t.Errorf("Got %v, expected no error", err)
		}
		c.Step(10 * time.Second)
		err = healthCheck.Check(nil)
		if err != nil {
			t.Errorf("Got %v, expected no error", err)
		}
		c.Step(1 * time.Millisecond)
		err = healthCheck.Check(nil)
		if err == nil || err.Error() != "not finished" {
			t.Errorf("Got '%v', but expected error to be 'not finished'", err)
		}
		close(doneCh)
		err = healthCheck.Check(nil)

				return nil
			}
			// clear the event
			t.events[0] = ptr.Empty[T]()
			t.events = t.events[1:]
			return nil
		}, retry.Timeout(time.Second), retry.BackoffDelay(time.Millisecond))
		if err != nil {
			t.t.Fatal(err)
		}
	}
	t.Empty()
}

func (t *Tracker[T]) Events() []T {
	t.mu.Lock()
	defer t.mu.Unlock()
	return t.events
}

            }
        }
    }

    /**
     * Detects whether the file system has a reliable high precision timestamp.
     *
     * If `isCurrentTimestampHighPrecision` is in `millisecond` precision, then all file timestamps will have `millisecond` precision
     * since we check all Java APIs that can return a high or a low precision, and we choose the one with the lowest precision.
     *

				Resource: "foos",
			},
			watchCount:                29,
			maxSeats:                  10,
			initialSeatsExpected:      1,
			finalSeatsExpected:        3,
			additionalLatencyExpected: 5 * time.Millisecond,
		},
		{
			name:       "request verb is create, watches registered, no additional latency",
			requestURI: "http://server/apis/foo.bar/v1/foos",
			requestInfo: &apirequest.RequestInfo{
				Verb:     "create",

	backoffMgr := NewExponentialBackoffManager(1*time.Millisecond, 10*time.Millisecond, 1*time.Hour, 2.0, 0.0, &clock.RealClock{})

	for i := range durationFactors {
		start := time.Now()
		<-backoffMgr.Backoff().C()
		passed := time.Since(start)
		if passed < durationFactors[i]*time.Millisecond {
			t.Errorf("backoff should be at least %d ms, but got %s", durationFactors[i], passed.String())
		}

	select {
	case ret := <-done:
		return ret
	case <-time.After(time.Millisecond * 500):
		return nil
	}
}

func ExpectTimeout(t *testing.T, p *PushQueue) {
	t.Helper()
	done := make(chan struct{}, 1)
	go func() {
		p.Dequeue()
		done <- struct{}{}
	}()
	select {
	case <-done:
		t.Fatalf("Expected timeout")
	case <-time.After(time.Millisecond * 500):
	}
}

package backoff

import (
	"context"
	"errors"
	"sync"
	"testing"
	"time"

	"istio.io/istio/pkg/test/util/assert"
)

func TestBackOff(t *testing.T) {
	var (
		testInitialInterval = 500 * time.Millisecond
		testMaxInterval     = 5 * time.Second
	)

	o := DefaultOption()
	o.InitialInterval = testInitialInterval
	o.MaxInterval = testMaxInterval
	exp := NewExponentialBackOff(o)

	"time"
)

const arbitraryTimeout = 2000 * time.Millisecond

// retry retries ephemeral errors from f up to an arbitrary timeout
// to work around filesystem flakiness on Windows and Darwin.
func retry(f func() (err error, mayRetry bool)) error {
	var (
		bestErr     error
		lowestErrno syscall.Errno
		start       time.Time
		nextSleep   time.Duration = 1 * time.Millisecond
	)
	for {
		err, mayRetry := f()