switch {
		case testCase.expectedErr == nil:
			if err != nil {
				t.Fatalf("error: expected = <nil>, got = %v", err)
			}
		case err == nil:
			t.Fatalf("error: expected = %v, got = <nil>", testCase.expectedErr)
		case testCase.expectedErr.Error() != err.Error():
			t.Fatalf("error: expected = %v, got = %v", testCase.expectedErr, err)
		}

		if testCase.expectedIPList != nil {
			var found bool

	wrapped.ServeHTTP(w, testRequest)

	if callCount != 1 {
		t.Errorf("expected the given handler to be invoked once, but was actually invoked %d times", callCount)
	}
	if filterRecord == nil {
		t.Fatal("expected a filter record in the request context, but got nil")
	}
	if filterName != filterRecord.name {
		t.Errorf("expected filter name=%s but got=%s", filterName, filterRecord.name)
	}

	}
	if len(names) == 0 {
		t.Errorf("no results")
	}
	expected, err := lookupPTR(addr.String())
	if err != nil {
		t.Skipf("skipping failed lookup %s test: %s", addr.String(), err)
	}
	slices.Sort(expected)
	slices.Sort(names)
	if !reflect.DeepEqual(expected, names) {
		t.Errorf("different results %s:\texp:%v\tgot:%v", addr, toJson(expected), toJson(names))
	}
}

func TestLookupPTR(t *testing.T) {

	}()
	select {
	case <-done:
		t.Fatalf("Expected timeout")
	case <-time.After(time.Millisecond * 500):
	}
}

func ExpectDequeue(t *testing.T, p *PushQueue, expected *Connection) {
	t.Helper()
	result := make(chan *Connection, 1)
	go func() {
		con, _, _ := p.Dequeue()
		result <- con
	}()
	select {
	case got := <-result:
		if got != expected {
			t.Fatalf("Expected proxy %v, got %v", expected, got)
		}

			"istio-injection":            "enabled",
		}),
	}

	client := kube.NewFakeClient(nss...)
	expected := sets.New[string]("default", "no-ambient")
	actual, err := getNamespaces(context.TODO(), client, "istio-system")
	assert.NoError(t, err)
	for _, ns := range actual {
		assert.Equal(t, true, expected.Contains(ns.Name))
	}
}

func Test_injectionDisabled(t *testing.T) {
	cases := []struct {

  std::string module_dump;
  llvm::raw_string_ostream raw_stream(module_dump);
  mlir_module_->print(raw_stream);

  EXPECT_EQ(compilation_status.Delta(kExportSuccess), 1);
  EXPECT_EQ(compilation_status.Delta(kExportFailed), 0);
  EXPECT_EQ(
      CountSubstring(module_dump, "tf_executor.island wraps \"tf.Concat\""), 2);
}

}  // namespace
}  // namespace v2
}  // namespace tf2xla

		template *api.PersistentVolume
		expected []string
	}{
		{
			name:     "null",
			template: nil,
			expected: nil,
		},
		{
			name: "no warning",
			template: &api.PersistentVolume{
				ObjectMeta: metav1.ObjectMeta{
					Name: "foo",
				},
				Status: api.PersistentVolumeStatus{
					Phase: api.VolumeBound,
				},
			},
			expected: nil,
		},
		{
			name: "warning",

     * @param failure the assertion failure
     * @param expected the expected value for the failure; can be {@code null}
     * @param actual the actual value for the failure; can be {@code null}
     * @return the new instance
     */
    public static TestFailure fromTestAssertionFailure(Throwable failure, String expected, String actual) {
        return fromTestAssertionFailure(failure, expected, actual, null);
    }

    /**

	outAttach := output.Spec.AttachRequired
	if outAttach == nil {
		t.Errorf("Expected AttachRequired to be defaulted to: %+v, got: nil", defaultAttach)
	} else if *outAttach != defaultAttach {
		t.Errorf("Expected AttachRequired to be defaulted to: %+v, got: %+v", defaultAttach, outAttach)
	}
	outPodInfo := output.Spec.PodInfoOnMount
	if outPodInfo == nil {
		t.Errorf("Expected PodInfoOnMount to be defaulted to: %+v, got: nil", defaultPodInfo)

			expected: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			LocalIPAddrs = tt.lipas
			_, isV6, err := getLocalIP(tt.isDS)
			if err != nil {
				t.Errorf("getLocalIP err: %s", err)
			}
			if isV6 != tt.expected {
				t.Errorf("unexpected EnableIPv6 result, expected: %t got: %t", tt.expected, isV6)
			}
		})
	}