later := time.Now()
	bval := &later
	func() {
		lock.Lock()
		defer lock.Unlock()
		if wr.Set(bval) {
			t.Error("second Set() returned true")
		}
	}()
	goGetAndExpect(t, clock, counter, wr, gots, aval)
	counter.Add(1) // account for unblocking the receive on doneCh
	close(doneCh)
	time.Sleep(time.Second) // give it a chance to misbehave
	goGetAndExpect(t, clock, counter, wr, gots, aval)
}

	ctx, cancel := context.WithCancel(context.Background())
	wr := NewWriteOnce(nil, ctx, cval)
	gots := make(chan interface{})
	goGetExpectNotYet(t, wr, gots, "Set")
	now := time.Now()
	aval := &now
	if !wr.Set(aval) {
		t.Error("Set() returned false")
	}
	expectGotValue(t, gots, aval)
	goGetAndExpect(t, wr, gots, aval)
	later := time.Now()
	bval := &later
	if wr.Set(bval) {
		t.Error("second Set() returned true")
	}

	n := *np
	w := len(n.s)
	if n == nil {
		return 0
	}
	wl := walk(&n.left)
	wr := walk(&n.right)
	if wl < wr {
		n.left, n.right = n.right, n.left // ERROR "ignoring self-assignment"
		wl, wr = wr, wl
	}
	*np = n
	return w + wl + wr
}

// Test for bug where func var f used prototype's escape analysis results.
func prototype(xyz []string) {} // ERROR "xyz does not escape"

	InnerCloseNotifierFlusher CloseNotifierFlusher
}

func (wr outerWithCloseNotifyAndFlush) CloseNotify() <-chan bool {
	if notifier, ok := wr.UserProvidedDecorator.(http.CloseNotifier); ok {
		return notifier.CloseNotify()
	}

	return wr.InnerCloseNotifierFlusher.CloseNotify()
}

func (wr outerWithCloseNotifyAndFlush) Flush() {
	if flusher, ok := wr.UserProvidedDecorator.(http.Flusher); ok {
		flusher.Flush()
		return

	var previousResources []string
	var alwaysRespond bool
	w.UpdateWatchedResource(request.TypeUrl, func(wr *WatchedResource) *WatchedResource {
		previousResources = wr.ResourceNames
		wr.NonceAcked = request.ResponseNonce
		wr.ResourceNames = request.ResourceNames
		alwaysRespond = wr.AlwaysRespond
		wr.AlwaysRespond = false
		return wr
	})

	// Envoy can send two DiscoveryRequests with same version and nonce.

// internal buffer to maintain state across Write calls.
// Calling its Close method writes any buffered data to w.
func (f Form) Writer(w io.Writer) io.WriteCloser {
	wr := &normWriter{rb: reorderBuffer{}, w: w}
	wr.rb.init(f, nil)
	return wr
}

type normReader struct {
	rb           reorderBuffer
	r            io.Reader
	inbuf        []byte
	outbuf       []byte
	bufStart     int
	lastBoundary int

	con.proxy.UpdateWatchedResource(request.TypeUrl, func(wr *model.WatchedResource) *model.WatchedResource {
		previousResources = wr.ResourceNames
		currentResources, _ = deltaWatchedResources(previousResources, request)
		wr.NonceAcked = request.ResponseNonce
		wr.ResourceNames = currentResources
		alwaysRespond = wr.AlwaysRespond
		wr.AlwaysRespond = false
		return wr
	})

		if err != nil {
			t.Fatal(err)
		}
		wr, err := os.OpenFile(name, os.O_WRONLY|syscall.O_NONBLOCK, 0o600)
		if err != nil {
			t.Fatal(err)
		}
		const msg = "message"
		if _, err := wr.Write([]byte(msg)); err != nil {
			if errors.Is(err, syscall.EAGAIN) || errors.Is(err, syscall.ENOBUFS) {
				t.Logf("ignoring write error %v", err)
				rd.Close()
				wr.Close()
				continue
			}

	"internal/buildcfg"
	"internal/testenv"
	"os"
	"testing"

	"cmd/internal/bio"
	"cmd/internal/objabi"
)

func dummyWriter(buf *bytes.Buffer) *Writer {
	wr := &bio.Writer{Writer: bufio.NewWriter(buf)} // hacky: no file, so cannot seek
	return NewWriter(wr)
}

func TestReadWrite(t *testing.T) {
	// Test that we get the same data in a write-read roundtrip.

	// Write a symbol, a relocation, and an aux info.

				Resource: protoconv.MessageToAny(clientConfig),
			})
		}
		con.proxy.RUnlock()
	}

	return res
}

func debugSyncStatus(wr *model.WatchedResource) status.ConfigStatus {
	if wr.NonceSent == "" {
		return status.ConfigStatus_NOT_SENT
	}
	if wr.NonceAcked == wr.NonceSent {
		return status.ConfigStatus_SYNCED
	}
	return status.ConfigStatus_STALE
}