/**
 * Standard output or standard error message logged during the execution of the test
 */
public interface TestOutputEvent {

    /**
     * Destination of the message
     */
    Destination getDestination();

    /**
     * Message content
     */
    String getMessage();

    /**
     * Destination of the message
     */
    enum Destination {
        StdOut, StdErr
    }

    public DefaultTestOutputEvent(Destination destination, String message) {
        this.destination = destination;
        this.message = message;
    }

    @Override
    public Destination getDestination() {
        return destination;
    }

    @Override
    public String getMessage() {
        return message;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {

		return rules[i].Priority > rules[j].Priority && rules[i].Destination.String() == rules[j].Destination.String()
	})

	return rules
}

// GetDestination returns destination bucket and storage class.
func (c Config) GetDestination() Destination {
	if len(c.Rules) > 0 {
		return c.Rules[0].Destination
	}
	return Destination{}
}

// Replicate returns true if the object should be replicated.

		}

		for _, mirror := range httpRoute.GetMirrors() {
			if mirror.GetDestination() != nil {
				addService(host.Name(mirror.GetDestination().GetHost()))
			}
		}

		for _, route := range httpRoute.GetRoute() {
			if route.GetDestination() != nil {
				addService(host.Name(route.GetDestination().GetHost()))
			}
		}
	}

	return nameToServiceMap
}

            onOutput(classId, 0, outputEvent);
        }

        public void onOutput(long classId, long testId, TestOutputEvent outputEvent) {
            boolean stdout = outputEvent.getDestination() == TestOutputEvent.Destination.StdOut;
            mark(classId, testId, stdout);

            output.writeBoolean(stdout);
            output.writeSmallLong(classId);
            output.writeSmallLong(testId);

        }

        @Override
        public void write(Encoder encoder, DefaultTestOutputEvent value) throws Exception {
            destinationSerializer.write(encoder, value.getDestination());
            encoder.writeString(value.getMessage());
        }
    }

    private static class DefaultTestFailureSerializer implements Serializer<DefaultTestFailure> {

	listenerPort int,
	hashByDestination DestinationHashMap,
	out *route.Route,
	action *route.RouteAction,
) host.Name {
	hostname := host.Name(dst.GetDestination().GetHost())
	action.ClusterSpecifier = &route.RouteAction_Cluster{
		Cluster: GetDestinationCluster(dst.Destination, serviceRegistry[hostname], listenerPort),
	}
	if dst.Headers != nil {

	return file_workloadapi_workload_proto_rawDescGZIP(), []int{8}
}

func (m *GatewayAddress) GetDestination() isGatewayAddress_Destination {
	if m != nil {
		return m.Destination
	}
	return nil
}

func (x *GatewayAddress) GetHostname() *NamespacedHostname {
	if x, ok := x.GetDestination().(*GatewayAddress_Hostname); ok {
		return x.Hostname
	}
	return nil
}

			if len(in.Route) == 1 {
				weight.Value = uint32(100)
			} else {
				continue
			}
		}
		hostname := host.Name(dst.GetDestination().GetHost())
		n := lb.GetDestinationCluster(dst.Destination, lb.serviceForHostname(hostname), listenerPort)
		clusterWeight := &route.WeightedCluster_ClusterWeight{
			Name:   n,
			Weight: weight,
		}

Method <org.gradle.api.publish.ivy.tasks.GenerateIvyDescriptor.getDestination()> does not have raw return type assignable to org.gradle.api.provider.Property in (GenerateIvyDescriptor.java:0)