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
}

						IP:       "1.1.1.1",
						Port:     80,
						Protocol: "tcp",
					}: {
						Address:  netutils.ParseIPSloppy("1.1.1.1"),
						Protocol: "tcp",
						Port:     uint16(80),
					},
				},
				Destinations: map[utilipvstest.ServiceKey][]*utilipvs.RealServer{
					{
						IP:       "1.1.1.1",
						Port:     80,
						Protocol: "tcp",
					}: {
						{
							Address:      netutils.ParseIPSloppy("10.0.0.1"),

apiVersion: release-notes/v2
kind: feature
area: traffic-management
issues:
- 33226
releaseNotes:
- |

	t.rootCtx.Logf("Running tests with: sources %v -> destinations %v",
		t.sources.Services().NamespacedNames().NamesWithNamespacePrefix(),
		t.destinations.Services().NamespacedNames().NamesWithNamespacePrefix())

	if t.sources.Len() == 0 {
		t.rootCtx.Error("Sources are empty")
	}
	if t.destinations.Len() == 0 {
		t.rootCtx.Error("Destinations are empty")
	}

}

// 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.
     *

	rootCtx framework.TestContext

	sources      echo.Instances
	destinations echo.Instances

	destinationFilters []CombinationFilter

	sourceDeploymentSetup      []srcSetupFn
	deploymentPairSetup        []svcPairSetupFn
	destinationDeploymentSetup []dstSetupFn

	cfg *config.Builder
}

// New creates a *T using the given applications as sources and destinations for each subtest.

	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.")