Namespace:  apps.Namespace,
					Ports:      ports.All(),
					DeployAsVM: true,
					VMDistro:   image,
					Subsets:    []echo.SubsetConfig{{}},
				})
			}
			instances := b.BuildOrFail(t)

			for idx, image := range images {
				idx, image := idx, image
				t.NewSubTest(image).RunParallel(func(t framework.TestContext) {
					tc := common.TrafficContext{
						TestContext: t,
						Istio:       i,

				builder = builder.WithConfig(echo.Config{
					Service:   ns.revision,
					Namespace: ns.namespace,
					Ports:     ports.All(),
					Subsets:   []echo.SubsetConfig{{}},
				})
			}
			instances := builder.BuildOrFail(t)
			// Add our existing revision to the instances list
			instances = append(instances, apps.A...)
			testAllEchoCalls(t, instances)
		})

    disabled: true
  envoyDebugHeaders:
    disabled: true
  metadataExchangeHeaders:
    mode: IN_MESH`},
					},
				},
			}
			instances := deployment.New(t).
				WithConfig(cfg).
				BuildOrFail(t)
			instance := instances[0]
			proxyHeaders := sets.New(
				"server",
				"x-forwarded-client-cert",
				"x-request-id",
			)

			allowedClientHeaders := sets.New(

							tc.nsLabel, revTagNs.Name(), err)
					}

					deployment.New(t).WithConfig(echo.Config{
						Service:   "revision-tag",
						Namespace: revTagNs,
					}).BuildOrFail(t)

					fetch := kubetest.NewSinglePodFetch(t.Clusters().Default(),
						revTagNs.Name(),
						fmt.Sprintf("app=%s", "revision-tag"))
					pods, err := fetch()
					if err != nil {

	// Build and initialize all Echo Instances. Upon returning, the Instance pointers
	// are assigned and all Instances are ready to communicate with each other.
	Build() (echo.Instances, error)
	BuildOrFail(t test.Failer) echo.Instances
}

var _ Builder = &builder{}

// New builder for echo deployments.
func New(ctx resource.Context, clusters ...cluster.Cluster) Builder {

		Namespace: revisionedNamespace,
		Ports: []echo.Port{
			{
				Name:         "http",
				Protocol:     protocol.HTTP,
				WorkloadPort: 8080,
			},
		},
	})
	builder.BuildOrFail(t)

	// Create a traffic generator between A and B.
	g := traffic.NewGenerator(t, traffic.Config{
		Source: apps.A[0],
		Options: echo.CallOptions{
			To:    apps.B,
			Count: 1,
			Port: echo.Port{

							WorkloadPort: 9000,
						},
						{
							Name:         "grpc",
							Protocol:     protocol.GRPC,
							WorkloadPort: 9090,
						},
					},
				})
			}
			instances := builder.BuildOrFail(t)
			// add an existing pod from apps to the rotation to avoid an extra deployment
			instances = append(instances, apps.A[0])

			testAllEchoCalls(t, instances)
		})
}

									annotation.ProxyConfig.Name: tc.pcAnnotation,
								},
							},
						}
					}

					instances := deployment.New(ctx, t.Clusters().Configs()...).WithConfig(echoConfig).BuildOrFail(t)
					checkInjectedValues(t, instances, tc.expected)
				})
			}
		})
}

func checkInjectedValues(t framework.TestContext, instances echo.Instances, values map[string]string) {
	t.Helper()

							Version:     migrationVersionNonIstio,
							Annotations: map[string]string{annotation.SidecarInject.Name: "false"},
						},
					},
				}).BuildOrFail(t)
			} else {
				// TODO: remove the MinIstioVersion setting for dual stack integration test for next line
				// integIstioVersion = cMinIstioVersionDS

			deployment.
				New(t, c).
				WithConfig(echo.Config{
					Namespace: ns,
					Ports:     ports.All(),
					Subsets:   []echo.SubsetConfig{{}},
				}).BuildOrFail(t)

			// To begin with, delete CNI Daemonset to simulate a CNI race condition.
			// Temporarily store CNI DaemonSet, which will be deployed again later.
			t.Log("Delete CNI Daemonset temporarily to simulate race condition")