return notFoundGetter{gr: gr}
}

type notFoundGetter struct {
	gr schema.GroupResource
}

func (g notFoundGetter) Get(ctx context.Context, name string, options *metav1.GetOptions) (runtime.Object, error) {
	return nil, errors.NewNotFound(g.gr, name)

			ambientComponent.NewWaypointProxyOrFail(ctx, meshNS, "namespace")
			for _, k := range ctx.AllClusters() {
				ns, err := k.Kube().CoreV1().Namespaces().Get(ctx.Context(), meshNS.Name(), metav1.GetOptions{})
				if err != nil {
					t.Fatal(err)
				}
				labels := ns.Labels
				if labels == nil {
					labels = make(map[string]string)
				}
				labels[constants.AmbientUseWaypointLabel] = "namespace"

                    public synchronized void init(ProcessingEnvironment processingEnv) {
                        super.init(processingEnv);

                        String fileName = processingEnv.getOptions().getOrDefault("fileName", "generated");

                        try {
                            new File("${escapeString(testDirectory.absolutePath)}/" + fileName + ".txt").createNewFile();

// When more test cases are added, this getter will need extending/replacing to have a real test implementation.
type panicGetter struct{}

func (f panicGetter) Get(ctx context.Context, name string, options *metav1.GetOptions) (runtime.Object, error) {
	panic("not implemented")
}

var _ rest.Getter = panicGetter{}

func validNewServiceAccount(name string) *api.ServiceAccount {
	return &api.ServiceAccount{

	if len(certChainBytes) != 0 {
		t.Errorf("Cert chain should be empty")
	}

	// Check the signing cert stored in K8s secret.
	caSecret, err := client.CoreV1().Secrets("default").Get(context.TODO(), CASecret, metav1.GetOptions{})
	if err != nil {
		t.Errorf("Failed to get secret (error: %s)", err)
	}

	signingCertFromSecret, err := util.ParsePemEncodedCertificate(caSecret.Data[CACertFile])
	if err != nil {

		constants.KubernetesAPICallRetryInterval, w.timeout,
		true, func(_ context.Context) (bool, error) {
			_, err := w.client.CoreV1().Pods(metav1.NamespaceSystem).Get(context.TODO(), podName, metav1.GetOptions{})
			if err != nil && apierrors.IsNotFound(err) {
				fmt.Printf("[apiclient] The old Pod %q is now removed (which is desired)\n", podName)
				return true, nil
			}
			return false, nil
		})
}

			if err != nil {
				t.Fatalf("Expected no error, but got: %v", err)
			}

			fsGot, err := client.Get(context.TODO(), test.bootstrap.Name, metav1.GetOptions{})
			switch {
			case test.expected == nil:
				if !apierrors.IsNotFound(err) {
					t.Fatalf("Expected GET to return an %q error, but got: %v", metav1.StatusReasonNotFound, err)
				}
			case err != nil:

		if err != nil {
			return nil, err
		}
		pod := pods[0]

		svc, err := cls.Kube().CoreV1().Services(cfg.TelemetryNamespace).Get(context.TODO(), serviceName, metav1.GetOptions{})
		if err != nil {
			return nil, err
		}
		port := uint16(svc.Spec.Ports[0].Port)

		forwarder, err := cls.NewPortForwarder(pod.Name, pod.Namespace, "", 0, int(port))
		if err != nil {

		require.NoError(t, err)
		return out
	}
	getPod := func(name, ns string) *example.Pod {
		key := "pods/" + ns + "/" + name
		out := &example.Pod{}
		err := etcdStorage.Get(context.TODO(), key, storage.GetOptions{}, out)
		require.NoError(t, err)
		return out
	}
	makeReplicaSet := func(name string) *example2v1.ReplicaSet {
		return &example2v1.ReplicaSet{
			ObjectMeta: metav1.ObjectMeta{Namespace: "ns", Name: name},

			if err != nil {
				t.Fatalf("Expected no error, but got: %v", err)
			}

			plGot, err := client.Get(context.TODO(), test.bootstrap.Name, metav1.GetOptions{})
			switch {
			case test.expected == nil:
				if !apierrors.IsNotFound(err) {
					t.Fatalf("Expected GET to return an %q error, but got: %v", metav1.StatusReasonNotFound, err)
				}
			case err != nil: