// Check that we wait long enough anyway (presumably as long as MAX_VALUE nanos):
    TimedWaiterThread waiter = new TimedWaiterThread(future, Long.MAX_VALUE, SECONDS);
    waiter.start();
    waiter.awaitWaiting();

    future.set(1);
    waiter.join();
  }

  @J2ktIncompatible // TODO(b/324550390): Enable
  public void testSetNull() throws Exception {
    future.set(null);

			if err != nil {
				t.Fatal(err)
			}

			certDER, err := ca.Sign(csr, test.policy)
			if len(test.wantErr) > 0 {
				if errStr := errString(err); test.wantErr != errStr {
					t.Fatalf("expected error %s but got %s", test.wantErr, errStr)
				}
				return
			}
			if err != nil {
				t.Fatal(err)
			}

			cert, err := x509.ParseCertificate(certDER)

			ips, err := r.LookupIPAddr(context.Background(), name)

			var wantErr error
			if strict {
				wantErr = tt.wantStrictErr
			} else {
				wantErr = tt.wantLaxErr
			}
			if !reflect.DeepEqual(err, wantErr) {
				t.Errorf("#%d (%s) strict=%v: got err %#v; want %#v", i, tt.desc, strict, err, wantErr)
			}

			gotIPs := map[string]struct{}{}
			for _, ip := range ips {

		args    args
		wantOut *v1alpha1.IstioStatus
		wantErr bool
	}{
		{
			name:    "Nondestructive cast",
			args:    args{in: statusStillPropagating},
			wantOut: statusStillPropagating,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			gotOut, err := status.GetTypedStatus(tt.args.in)
			if (err != nil) != tt.wantErr {

)

func TestAuthenticate(t *testing.T) {
	type treq struct {
		resp          *Response
		authenticated bool
		err           error

		wantResp          *Response
		wantAuthenticated bool
		wantErr           bool
	}
	type taudcfg struct {
		auds         Audiences
		implicitAuds Audiences
	}
	cs := []struct {
		name string

		taudcfgs []taudcfg
		treqs    []treq
	}{
		{

	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			a, err := NewAuthorizer(tt.excludedPaths)
			if err != nil && !tt.wantErr {
				t.Fatalf("unexpected error: %v", err)
			}
			if err == nil && tt.wantErr {
				t.Fatalf("expected error, didn't get any")
			}
			if err != nil {
				return
			}

			for _, cases := range []struct {
				paths []string

	GOMAXPROCS(gomaxprocs)
	// Number of active readers + 10000 * number of active writers.
	var activity int32
	var rwm RWMutex
	rwm.Init()
	cdone := make(chan bool)
	go writer(&rwm, num_iterations, &activity, cdone)
	var i int
	for i = 0; i < numReaders/2; i++ {
		go reader(&rwm, num_iterations, &activity, cdone)
	}
	go writer(&rwm, num_iterations, &activity, cdone)
	for ; i < numReaders; i++ {

		f, err := badStateFile()
		if err != nil {
			t.Skip(err)
		}
		defer f.Close()

		// Give scheduler a chance to have two separated
		// goroutines: an event poller and an event waiter.
		time.Sleep(100 * time.Millisecond)

		var b [1]byte
		_, err = f.Read(b[:])
		if perr := parseReadError(err, isBadStateFileError); perr != nil {
			t.Fatal(perr)
		}
	})
}

}

// KubeWaiter is an implementation of Waiter that is backed by a Kubernetes client
type KubeWaiter struct {
	client  clientset.Interface
	timeout time.Duration
	writer  io.Writer
}

// NewKubeWaiter returns a new Waiter object that talks to the given Kubernetes cluster
func NewKubeWaiter(client clientset.Interface, timeout time.Duration, writer io.Writer) Waiter {
	return &KubeWaiter{
		client:  client,

        "/items/",
        headers={"X-Token": "coneofsilence"},
        json={"id": "foobar", "title": "Foo Bar", "description": "The Foo Barters"},
    )
    assert response.status_code == 200
    assert response.json() == {
        "id": "foobar",
        "title": "Foo Bar",
        "description": "The Foo Barters",
    }


def test_create_item_bad_token():
    response = client.post(
        "/items/",