g.Expect(node.RawMetadata["WORKLOAD_NAME"]).To(Equal(expectWorkloadName))
	g.Expect(node.Metadata.Labels[model.LocalityLabel]).To(Equal("region/zone/subzone"))
}

func TestSetIstioVersion(t *testing.T) {
	test.SetForTest(t, &version.Info.Version, "binary")

	testCases := []struct {
		name            string
		meta            *model.BootstrapNodeMetadata
		binaryVersion   string
		expectedVersion string
	}{
		{

	},
}

func configureBenchmark(t test.Failer) {
	for _, s := range istiolog.Scopes() {
		if s.Name() == benchmarkScope.Name() {
			continue
		}
		s.SetOutputLevel(istiolog.NoneLevel)
	}
	test.SetForTest(t, &features.EnableXDSCaching, false)
}

func BenchmarkInitPushContext(b *testing.B) {
	configureBenchmark(b)
	for _, tt := range testCases {
		b.Run(tt.Name, func(b *testing.B) {

			},
			enableQUICListeners: true,
			expected:            true,
		},
	}
	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			test.SetForTest(t, &features.EnableQUICListeners, tc.enableQUICListeners)
			actual := IsEligibleForHTTP3Upgrade(tc.server)
			if actual != tc.expected {
				t.Errorf("IsEligibleForHTTP3Upgrade(%s) => %t, want %t",

	})
	// When the test is done, terminate the client. This ensures all informers are closed.
	// This usually doesn't matter, but can be useful when mutating global state with test.SetForTest, etc.
	defer c.Shutdown() // Normally: t.Cleanup(c.Shutdown)

	// Build our controller
	controller := NewController(c)
	// Ensure our queue finished processing events
	defer func() {

			expNewCert:   false,
			expCert:      []byte{},
			expKey:       []byte{},
		},
	}

	for _, c := range cases {
		t.Run(c.name, func(t *testing.T) {
			test.SetForTest(t, &features.PilotCertProvider, c.certProvider)
			test.SetForTest(t, &features.EnableCAServer, c.enableCA)

			// check if we have some tls assets to write for test
			if c.FSCertsPaths != (TLSFSLoadPaths{}) {

					ClusterId:         testC,
				},
			},
		},
	}})
}

func TestAmbientIndex_ServiceEntry_DisableK8SServiceSelectWorkloadEntries(t *testing.T) {
	test.SetForTest(t, &features.EnableK8SServiceSelectWorkloadEntries, false)
	s := newAmbientTestServer(t, testC, testNW)

	s.addPods(t, "140.140.0.10", "pod1", "sa1", map[string]string{"app": "a"}, nil, true, corev1.PodRunning)

			remoteClusterPods:   []pod{ztunnelPodRemote, podSameNodeRemote},
			code:                codes.OK,
		},
	}

	for _, c := range testCases {
		t.Run(c.name, func(t *testing.T) {
			test.SetForTest(t, &features.CATrustedNodeAccounts, c.trustedNodeAccounts)

			multiClusterController := multicluster.NewFakeController()
			server, _ := New(c.ca, time.Duration(1), c.authenticators, multiClusterController)

		test.SetForTest(t, &features.EnableSidecarServiceInboundListenerMerge, true)
		testInboundListenerConfigWithSidecarIngressPortMergeServicePort(t, getProxy(),
			buildServiceWithPort("test1.com", 80, protocol.HTTP, tnow.Add(1*time.Second)))
	})
	t.Run("merge sidecar ingress and service ports, same port in both sidecar and service", func(t *testing.T) {

	updatedVIPs := []string{"1.1.1.1", "1.1.1.2"}
	ic.setServiceImportVIPs(t, updatedVIPs)
}

func newTestServiceImportCache(t test.Failer) (*FakeController, *serviceImportCacheImpl) {
	test.SetForTest(t, &features.EnableMCSHost, true)

	c, _ := NewFakeControllerWithOptions(t, FakeControllerOptions{
		ClusterID: serviceImportCluster,
		CRDs:      []schema.GroupVersionResource{mcs.ServiceImportGVR},
	})

			Address: workloadEntry.Spec.(*networking.WorkloadEntry).Address,
			Port:    80,
		}}
		expectServiceEndpoints(t, fx, expectedSvc, 80, instances)
	})

	istiotest.SetForTest(t, &features.EnableSidecarHBONEListening, true)
	istiotest.SetForTest(t, &features.EnableAmbient, true)
	for _, ambient := range []bool{false, true} {
		name := "disabled"
		if ambient {
			name = "enabled"
		}
		m := mesh.DefaultMeshConfig()