// limitations under the License.

package test

import (
	"context"
	"os"

	"go.uber.org/atomic"
)

// SetForTest sets a variable for the duration of a test, then resets it once the test is complete.
func SetForTest[T any](t Failer, vv *T, v T) {
	old := *vv
	*vv = v
	t.Cleanup(func() {
		*vv = old
	})
}

		ConfigKey{Kind: kind.DestinationRule, Name: "name", Namespace: "namespace"}.HashCode(): sets.New(secondEntry.Key()),
	})
}

func TestCleanIndexesOnEvict(t *testing.T) {
	test.SetForTest(t, &features.XDSCacheMaxSize, 1)
	test.SetForTest(t, &features.XDSCacheIndexClearInterval, 5*time.Millisecond)
	zeroTime := time.Time{}
	res := &discovery.Resource{Name: "test"}
	req := &PushRequest{Start: zeroTime.Add(time.Duration(1))}

					}},
				},
			},
			IsMtlsDisabled: false,
			SubsetName:     "enable-tls",
		},
	},
}

func TestEndpointsByNetworkFilter(t *testing.T) {
	test.SetForTest(t, &features.MultiNetworkGatewayAPI, true)
	test.SetForTest(t, &features.PreferHBONESend, true)
	env := environment(t)
	env.Env().InitNetworksManager(env.Discovery)
	// The tests below are calling the endpoints filter from each one of the

// limitations under the License.

package test

import (
	"testing"
)

func TestSetForTest(t *testing.T) {
	v := 1
	t.Run("subtest", func(t *testing.T) {
		SetForTest(t, &v, 2)
		if v != 2 {
			t.Fatalf("unexpected v: %v", v)
		}
	})
	if v != 1 {
		t.Fatalf("unexpected v: %v", v)
	}

	return &nodeTainterTestServer{
		client: client,
		t:      t,
		pc:     pc,
		nc:     nc,
	}
}

func TestNodeUntainter(t *testing.T) {
	setupLogging()
	test.SetForTest(t, &features.EnableNodeUntaintControllers, true)
	s := newNodeUntainterTestServer(t)
	s.addTaintedNodes(t, "node1", "node2", "node3")
	s.addPod(t, "node3", true, map[string]string{"k8s-app": "other-app"}, "")

		}
		assert.Equal(t, sets.SortedList(have), sets.SortedList(wantAdded))
		assert.Equal(t, sets.SortedList(haveRemoved), sets.SortedList(wantRemoved))
	}
}

func TestWorkloadReconnect(t *testing.T) {
	test.SetForTest(t, &features.EnableAmbient, true)
	t.Run("ondemand", func(t *testing.T) {
		expect := buildExpect(t)
		s := xds.NewFakeDiscoveryServer(t, xds.FakeOptions{

// TestRegistration is an e2e test for registration. Most tests are in autoregister package, but this
// exercises the full XDS flow.
func TestRegistration(t *testing.T) {
	// TODO: allow fake XDS to be "authenticated"
	test.SetForTest(t, &features.ValidateWorkloadEntryIdentity, false)
	ds := xds.NewFakeDiscoveryServer(t, xds.FakeOptions{})
	ds.Store().Create(config.Config{
		Meta: config.Meta{
			GroupVersionKind: gvk.WorkloadGroup,

	verifyControllers(t, mc, 1, "delete remote controller")
}

func Test_KubeSecretController_ExternalIstiod_MultipleClusters(t *testing.T) {
	test.SetForTest(t, &features.ExternalIstiod, true)
	test.SetForTest(t, &features.InjectionWebhookConfigName, "")
	mockserviceController := newMockserviceController()
	clientset := kube.NewFakeClient()
	stop := test.NewStop(t)
	s := server.New()

}

func newTestServiceExportCache(t *testing.T, clusterLocalMode ClusterLocalMode) (*serviceExportCacheImpl, *model.EndpointIndex) {
	t.Helper()

	istiotest.SetForTest(t, &features.EnableMCSServiceDiscovery, true)
	istiotest.SetForTest(t, &features.EnableMCSClusterLocal, clusterLocalMode == alwaysClusterLocal)

	c, _ := NewFakeControllerWithOptions(t, FakeControllerOptions{
		ClusterID: testCluster,

				})).
				BuildAll(nil, apps.A.Append(apps.B).Services()).
				Apply()

			t.NewSubTest("gateway-authn-policy-attachment-only").Run(func(t framework.TestContext) {
				test.SetForTest(t, &features.EnableSelectorBasedK8sGatewayPolicy, false)
				cases := []struct {
					name          string
					customizeCall func(opts *echo.CallOptions, to echo.Target)
				}{
					{
						name: "deny without token",