if m := r.GetMirror(); m != nil {
			destinations = append(destinations, &AnnotatedDestination{
				RouteRule:    "http.mirror",
				ServiceIndex: i,
				Destination:  m,
			})
		}

		for j, m := range r.GetMirrors() {
			destinations = append(destinations, &AnnotatedDestination{
				RouteRule:        "http.mirrors",
				ServiceIndex:     i,
				DestinationIndex: j,
				Destination:      m.GetDestination(),
			})
		}
	}

		return fmt.Errorf("failed to add destination for service %v, service not found", key.String())
	}
	dests := f.Destinations[key]
	if dests == nil {
		dests = make([]*utilipvs.RealServer, 0)
		f.Destinations[key] = dests
	}
	f.Destinations[key] = append(f.Destinations[key], dest)
	// The tests assumes that the slice is sorted
	sort.Sort(byAddress(f.Destinations[key]))
	return nil
}

}

// To applies each of the filter functions in order to allow removing workloads from the set of destinations.
// Example:
//
//	echotest.New(t, apps).
//	  To(echotest.SimplePodServiceAndAllSpecial).
//	  Run()
func (t *T) To(filters ...Filter) *T {
	for _, filter := range filters {
		t.destinations = filter(t.destinations)
	}
	return t
}

func (t *T) ToMatch(m match.Matcher) *T {
	return t.To(FilterMatch(m))
}

				if destinations.Destination.Subset != "" {
					for _, host := range virtualservice.Hosts {
						if destinations.Destination.Host == host {
							virtualservices[r.Metadata.FullName] = append(virtualservices[r.Metadata.FullName], destinations.Destination)
						}
					}
				}
			}
		}

		return true
	})

	return virtualservices
}

public interface LoggingOutputInternal extends LoggingOutput {
    /**
     * Adds System.out and System.err as logging destinations. The output will include plain text only, with no color or dynamic text.
     */
    void attachSystemOutAndErr();

    /**
     * Adds the current processes' stdout and stderr as logging destinations. The output will also include color and dynamic text when one of these
     * is connected to a console.
     *

	EnableHBONESend = registerAmbient(
		"PILOT_ENABLE_SENDING_HBONE",
		true, false,
		"If enabled, HBONE will be allowed when sending to destinations.")

	EnableSidecarHBONEListening = registerAmbient(
		"PILOT_ENABLE_SIDECAR_LISTENING_HBONE",
		true, false,
		"If enabled, HBONE support can be configured for proxies.")

apiVersion: release-notes/v2
kind: feature
area: traffic-management
issue:
- 13330
releaseNotes:
- |

  http:
  # (This 'match' clause started as a work-around, because WaitUntilCallable() times out if
  # all destinations have a subset.  We are now using it for testing.)
  - match:
    - headers:
        end-user:
          exact: jason
    route:
    - destination:
        host: a
  # Fallthrough
  - route:
    - destination:
        host: a
        subset: v1
---
apiVersion: networking.istio.io/v1alpha3

By default, Istio-enabled services are unable to access services and URLs outside the cluster. Pods use <i>iptables</i> to transparently redirect all outbound traffic to the sidecar proxy, which only handles intra-cluster destinations.

See [the Egress Task](https://istio.io/docs/tasks/traffic-management/egress/) for
information on configuring Istio to contact external services.

type TestCase struct {
	// ConfigFile is the name of the yaml contains the authentication policy and destination rule CRs
	// that are needed for the test setup.
	// The file is expected in the tests/integration/security/reachability/testdata folder.
	ConfigFile string
	Namespace  namespace.Instance

	// CallOpts specified the call options for destination service. If not specified, use the default
	// framework provided ones.
	CallOpts []echo.CallOptions