func TestManifestGenerateAllOff(t *testing.T) {
	g := NewWithT(t)
	m, _, err := generateManifest("all_off", "", liveCharts, nil)
	if err != nil {
		t.Fatal(err)
	}
	objs, err := parseObjectSetFromManifest(m)
	if err != nil {
		t.Fatal(err)
	}
	g.Expect(objs.size()).Should(Equal(0))
}

func TestManifestGenerateFlagsMinimalProfile(t *testing.T) {
	g := NewWithT(t)
	// Change profile from empty to minimal using flag.

	cms := client.Kube().CoreV1().ConfigMaps(configMapNamespace)
	for i, step := range steps {
		resetCalled()

		t.Run(fmt.Sprintf("[%v]", i), func(t *testing.T) {
			g := NewWithT(t)

			switch {
			case step.added != nil:
				_, err := cms.Create(context.TODO(), step.added, metav1.CreateOptions{})
				g.Expect(err).Should(BeNil())
			case step.updated != nil:

func (ctx *context) SetAnalyzer(_ string)                                               {}

func TestCombinedAnalyzer(t *testing.T) {
	g := NewWithT(t)

	col1 := newSchema("col1")
	col2 := newSchema("col2")
	col3 := newSchema("col3")
	col4 := newSchema("col4")

	a1 := &analyzer{name: "a1", inputs: []config.GroupVersionKind{col1.GroupVersionKind()}}

		{updated: badCM3},
		{updated: cm},

		// Handle deletion.
		{deleted: cm},
		{added: cm},
	}

	for i, step := range steps {
		t.Run(fmt.Sprintf("[%v]", i), func(t *testing.T) {
			g := NewWithT(t)

			switch {
			case step.added != nil:
				_, err := cms.Create(context.TODO(), step.added, metav1.CreateOptions{})
				g.Expect(err).Should(BeNil())
			case step.updated != nil:

	// For each test case, verify we get the expected messages as output
	for _, tc := range mcTestGrid {
		tc := tc // Capture range variable so subtests work correctly
		t.Run(tc.name, func(t *testing.T) {
			g := NewWithT(t)

			// Set up a hook to record which collections are accessed by each analyzer
			analyzerName := tc.analyzer.Metadata().Name
			cr := func(col config.GroupVersionKind) {

						},
					},
				},
			},
			host:     "s.ns3.svc.cluster.local",
			expected: false,
		},
	}

	for _, c := range cases {
		t.Run(c.name, func(t *testing.T) {
			g := NewWithT(t)

			env := &model.Environment{Watcher: mesh.NewFixedWatcher(c.m)}
			env.Init()

			clusterLocal := env.ClusterLocal().GetClusterLocalHosts().IsClusterLocal(host.Name(c.host))

	"istio.io/istio/pkg/config/mesh"
	"istio.io/istio/pkg/filewatcher"
	"istio.io/istio/pkg/test/util/assert"
	"istio.io/istio/pkg/util/protomarshal"
)

func TestNewWatcherWithBadInputShouldFail(t *testing.T) {
	g := NewWithT(t)
	_, err := mesh.NewFileWatcher(filewatcher.NewWatcher(), "", false)
	g.Expect(err).ToNot(BeNil())
}

func TestWatcherShouldNotifyHandlers(t *testing.T) {
	watcherShouldNotifyHandlers(t, false)
}

func TestAnalyzersInAll(t *testing.T) {
	g := NewWithT(t)

	var allNames []string
	for _, a := range All() {
		allNames = append(allNames, a.Metadata().Name)
	}

	for _, tc := range testGrid {
		if !tc.skipAll {
			g.Expect(allNames).To(ContainElement(tc.analyzer.Metadata().Name))
		}
	}
}

func TestAnalyzersHaveUniqueNames(t *testing.T) {
	g := NewWithT(t)

				}
				if !reflect.DeepEqual(weights, tt.expected) {
					t.Errorf("Got weights %v expected %v", weights, tt.expected)
				}
			})
		}
	})

	t.Run("Failover: all priorities", func(t *testing.T) {
		g := NewWithT(t)
		env := buildEnvForClustersWithFailover()
		cluster := buildFakeCluster()
		ApplyLocalityLoadBalancer(cluster.LoadAssignment, nil, locality, nil, env.Mesh().LocalityLbSetting, true)

					t.Fatalf("Expected %v, actual %v", expected, policy.RetryPriority)
				}
			},
		},
	}
	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			g := NewWithT(t)
			policy := retry.ConvertPolicy(tc.route.Retries, false)
			if tc.assertFunc != nil {
				tc.assertFunc(g, policy)
			}
		})
	}