if err != nil {
			return nil, storage.NewInternalError(err.Error())
		}
		state.rev = getResp.Kvs[0].ModRevision
		state.meta.ResourceVersion = uint64(state.rev)
		state.data = data
		state.stale = stale
		if err := decode(s.codec, s.versioner, state.data, state.obj, state.rev); err != nil {
			recordDecodeError(s.groupResourceString, key)
			return nil, err
		}
	}
	return state, nil
}

	errChan           chan error
}

// Watch watches on a key and returns a watch.Interface that transfers relevant notifications.
// If rev is zero, it will return the existing object(s) and then start watching from
// the maximum revision+1 from returned objects.
// If rev is non-zero, it will watch events happened after given revision.
// If opts.Recursive is false, it watches on given key.

		return revWithOrigin(nil), err
	}

	lookup := func(v string) (*modfetch.RevInfo, error) {
		rev, err := repo.Stat(ctx, v)
		if rev != nil {
			// Note that Stat can return a non-nil rev and a non-nil err,
			// in order to provide origin information to make the error cacheable.
			origin = mergeOrigin(origin, rev.Origin)
		}
		if err != nil {
			return revWithOrigin(nil), err
		}

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: istio-ingressgateway
    install.operator.istio.io/owning-resource: unknown
    istio: ingressgateway
    istio.io/rev: default
    operator.istio.io/component: IngressGateways
    release: istio
  name: istio-ingressgateway
  namespace: istio-system
spec:
  selector:
    matchLabels:
      app: istio-ingressgateway
      istio: ingressgateway
  strategy:

		t.Fatalf("file %s issue: %v", dat, err)
	}
	return string(dat)
}

func TestADSC_handleMCP(t *testing.T) {
	rev := "test-rev"
	adsc := &ADSC{
		VersionInfo: map[string]string{},
		Store:       memory.Make(collections.Pilot),
		cfg: &ADSConfig{
			Config: Config{
				Revision: rev,
			},
		},
	}

	patchLabel := func(lbls map[string]string, name, value string) map[string]string {

	}
	if info.Version != rev && rev == module.CanonicalVersion(rev) && module.Check(p.path, rev) == nil {
		// If we request a correct, appropriate version for the module path, the
		// proxy must return either exactly that version or an error — not some
		// arbitrary other version.

referring to control plane revisions for sidecar injection.

With revision tags, rather than relabeling a namespace from "istio.io/rev=revision-a" to "istio.io/rev=revision-b" to
change which control plane revision handles injection, it's possible to create a revision tag "prod" and label our
namespace "istio.io/rev=prod". The "prod" revision tag could point to "1-7-6" initially and then be changed to point to "1-8-1"
at some later point.

		ic.values = myic
		ic.mu.Unlock()
	}

	return myic, nil
}

func (ic *injectConfig) configMapName() string {
	cmName := "istio-sidecar-injector"
	if rev := ic.revisions.Default(); rev != "default" && rev != "" {
		cmName += "-" + rev
	}
	return cmName
}

func (mc *meshConfig) MeshConfig() (*meshconfig.MeshConfig, error) {
	mc.mu.Lock()
	mymc := mc.meshConfig
	mc.mu.Unlock()

				" and will not function correctly.\n"
		} else if rev != "" && err != nil {
			needConfirmation = true
			message += fmt.Sprintf("Unable to find any proxies pointing to the %s control plane. "+
				"This may be because the control plane cannot be connected or there is no %s control plane.\n", rev, rev)
		}
		if gwList != "" {
			needConfirmation = true

				"--internalIP", testCases[dir.Name()]["internalIP"],
				"--ingressIP", testCases[dir.Name()]["ingressIP"],
				"--clusterID", constants.DefaultClusterName,
				"--revision", "rev-1",
				"-o", testdir,
			}
			if _, err := runTestCmd(t, createClientFunc, "rev-1", cmdWithClusterID); err != nil {
				t.Fatal(err)
			}

			cmdNoClusterID := []string{
				"entry", "configure",