if pollInterval <= 0 {
		panic(fmt.Errorf("pollInterval must be > 0"))
	}
	if eventHandler == nil {
		panic(fmt.Errorf("eventHandler must be non-nil"))
	}
	if errorHandler == nil {
		errorHandler = func(err error) {}
	}

	// Initialize watcher, fall back to no-op
	var (
		eventsCh chan fsnotify.Event
		errorCh  chan error
		watcher  watchAddRemover
	)

	t.Run("gRPC-resolve", func(t *testing.T) {
		rb := xdsresolver
		stateCh := make(chan resolver.State, 1)
		errorCh := make(chan error, 1)
		_, err := rb.Build(resolver.Target{URL: url.URL{
			Scheme: "xds",
			Path:   "/" + net.JoinHostPort(testSvcHost, xdsPorts),
		}},
			&testClientConn{stateCh: stateCh, errorCh: errorCh}, resolver.BuildOptions{
				Authority: testSvcHost,
			})
		if err != nil {

	if err = s.globalPushContext().InitContext(s.Env, nil, nil); err != nil {
		// Error accessing the data - log and close, maybe a different pilot replica
		// has more luck
		deltaLog.Warnf("Error reading config %v", err)
		return status.Error(codes.Unavailable, "error reading config")
	}
	con := newDeltaConnection(peerAddr, stream)

	Watcher() Watcher
	// Initialize checks the first request.
	Initialize(node *core.Node) error
	// Close discards the connection.
	Close()
	// Process responds to a discovery request.
	Process(req *discovery.DiscoveryRequest) error
	// Push responds to a push event queue
	Push(ev any) error
}

func Stream(ctx ConnectionContext) error {
	con := ctx.XdsConnection()

			eType:   -1,
			err:     fmt.Errorf("test error5"),
			message: "UNKNOWN",
			code:    codes.Internal,
		},
	}

	for k, tc := range testCases {
		caErr := NewError(tc.eType, tc.err)
		if caErr.Error() != tc.err.Error() {
			t.Errorf("[%s] unexpected error: '%s' VS (expected)'%s'", k, caErr.Error(), tc.err.Error())
		}
		if caErr.ErrorType() != tc.message {

						Detail: "error1",
					},
				},
				{
					Error: &apiservercel.Error{
						Detail: "error2",
					},
				},
				{
					Error: &apiservercel.Error{
						Detail: "error3",
					},
				},
			},
			expected: []error{
				errors.New("error1"),
				errors.New("error2"),
				errors.New("error3"),
			},
		},
		{

// 
PACKAGE error2

IMPORTPATH
	testdata/error2

FILENAMES
	testdata/error2.go

TYPES
	// 
	type I0 interface {
		// contains filtered or unexported methods
	}

	// 
	type S0 struct {
		// contains filtered or unexported fields
	}

	// 
	type T0 struct {
		ExportedField interface {
			// contains filtered or unexported methods
		}

// 
PACKAGE error1

IMPORTPATH
	testdata/error1

FILENAMES
	testdata/error1.go

TYPES
	// 
	type I0 interface {
		// When embedded, the predeclared error interface
		// must remain visible in interface types.
		error
	}

	// 
	type S0 struct {
		// contains filtered or unexported fields
	}

	// 
	type T0 struct {
		ExportedField interface {
			// error should be visible
			error
		}

// 
PACKAGE error1

IMPORTPATH
	testdata/error1

FILENAMES
	testdata/error1.go

TYPES
	// 
	type I0 interface {
		// When embedded, the predeclared error interface
		// must remain visible in interface types.
		error
	}

	// 
	type S0 struct {
		// contains filtered or unexported fields
	}

	// 
	type T0 struct {
		ExportedField interface {
			// error should be visible
			error
		}

	errors1 = w.Errors(watchFile1)
	g.Expect(errors1).To(BeNil())
	events2 = w.Events(watchFile2)
	g.Expect(events2).To(BeNil())
	errors2 = w.Errors(watchFile2)
	g.Expect(errors2).To(BeNil())
}

func TestErrors(t *testing.T) {
	w := NewWatcher()

	if ch := w.Errors("XYZ"); ch != nil {
		t.Error("Expected no channel")
	}

	if ch := w.Events("XYZ"); ch != nil {
		t.Error("Expected no channel")