Revision: "",
			},
			wantRevision: "istio.io/rev=canary",
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			tc.cfg.overwriteRevisionIfEmpty(tc.revision)
			g := NewWithT(t)
			g.Expect(tc.cfg.Revision).Should(Equal(tc.wantRevision))
		})
	}

			expectFound: true,
		},
	}

	for _, c := range cases {
		t.Run(c.name, func(t *testing.T) {
			tpl := param.Parse(tmpl.ParseOrFail(t, c.template))
			actual := tpl.ContainsWellKnown(param.To)

			g := NewWithT(t)
			g.Expect(actual).To(Equal(c.expectFound))
		})
	}

import (
	"fmt"
	"testing"

	. "github.com/onsi/gomega"

	"istio.io/istio/pkg/config/schema/collections"
	"istio.io/istio/pkg/config/schema/gvk"
)

func TestUpdateExistingContents(t *testing.T) {
	g := NewWithT(t)
	src := NewKubeSource(collections.Istio)

	applyAndValidate := func(version string) {
		configTemplate := `apiVersion: networking.istio.io/v1beta1
kind: DestinationRule
metadata:
  name: productpage
  labels:

					TLSOptions:     *c.tlsOptions,
				}
				p.RegistryOptions = RegistryOptions{
					FileDir: configDir,
				}

				p.ShutdownDuration = 1 * time.Millisecond
			})
			g := NewWithT(t)
			s, err := NewServer(args, func(s *Server) {
				s.kubeClient = kube.NewFakeClient()
			})
			g.Expect(err).To(Succeed())
			stop := make(chan struct{})
			g.Expect(s.Start(stop)).To(Succeed())

						Validate:     "validation.ValidateVirtualService",
					},
				},
			},
		},
	}

	for _, c := range cases {
		t.Run("", func(t *testing.T) {
			g := NewWithT(t)
			actual, err := Parse(c.input)
			g.Expect(err).To(BeNil())
			g.Expect(actual).To(Equal(c.expected))
		})
	}

		"_foo":          "XFoo",
		"-foo":          "XFoo",
		"_Foo":          "XFoo",
		"-Foo":          "XFoo",
	}

	for k, v := range cases {
		t.Run(k, func(t *testing.T) {
			g := NewWithT(t)

			a := CamelCase(k)
			g.Expect(a).To(Equal(v))
		})
	}
}

func TestCamelCaseToKebabCase(t *testing.T) {
	cases := map[string]string{
		"":                   "",
		"Foo":                "foo",

	"path/filepath"
	"testing"

	. "github.com/onsi/gomega"

	"istio.io/istio/istioctl/pkg/cli"
	"istio.io/istio/pkg/kube"
	"istio.io/istio/pkg/test/env"
)

func TestProfileList(t *testing.T) {
	g := NewWithT(t)
	args := []string{"profile", "list", "--dry-run", "--manifests", filepath.Join(env.IstioSrc, "manifests")}

	kubeClientFunc = func() (kube.CLIClient, error) {
		return nil, nil
	}

	"istio.io/istio/pkg/test"
	"istio.io/istio/pkg/test/env"
	"istio.io/istio/security/pkg/pki/ca"
)

const testNamespace = "istio-system"

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

	dir := t.TempDir()

	s := Server{
		kubeClient: kube.NewFakeClient(),
	}
	s.kubeClient.RunAndWait(test.NewStop(t))
	caOpts := &caOptions{
		Namespace: testNamespace,
	}

			name:        "no network label",
			networkView: []string{"network1"},
			network:     "",
			visible:     true,
		},
	}

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

			view := (&model.Proxy{
				Metadata: &model.NodeMetadata{
					RequestedNetworkView: c.networkView,
				},
			}).GetView()

			actual := view.IsVisible(&model.IstioEndpoint{

			},
		},
	}
)

var AlwaysReady = func(class schema.GroupVersionResource, stop <-chan struct{}) bool {
	return true
}

func TestListInvalidGroupVersionKind(t *testing.T) {
	g := NewWithT(t)
	clientSet := kube.NewFakeClient()
	clientSet.RunAndWait(test.NewStop(t))
	store := memory.NewController(memory.Make(collections.All))
	controller := NewController(clientSet, store, AlwaysReady, nil, controller.Options{})