envoyStatusPortEnv = env.Register("ENVOY_STATUS_PORT", 15021,
		"Envoy health status port value").Get()
	envoyPrometheusPortEnv = env.Register("ENVOY_PROMETHEUS_PORT", 15090,
		"Envoy prometheus redirection port value").Get()

	// Defined by https://github.com/grpc/proposal/blob/c5722a35e71f83f07535c6c7c890cf0c58ec90c0/A27-xds-global-load-balancing.md#xdsclient-and-bootstrap-file

	}
	sort.Slice(clusters, func(i, j int) bool {
		iDirection, iSubset, iName, iPort := safelyParseSubsetKey(clusters[i].Name)
		jDirection, jSubset, jName, jPort := safelyParseSubsetKey(clusters[j].Name)
		if iName == jName {
			if iSubset == jSubset {
				if iPort == jPort {
					return iDirection < jDirection
				}
				return iPort < jPort
			}
			return iSubset < jSubset
		}

    }

    def "disallows starting redirecting if test owner not provided"() {
        when: redirector.startRedirecting()
        then: thrown(AssertionError)
    }

    def "allows setting output owner"() {
        when:
        redirector.setOutputOwner("1")
        redirector.startRedirecting()

        then:
        redirector.outForwarder.outputOwner == "1"
        redirector.errForwarder.outputOwner == "1"

' Relationship
' ##################################

!define Rel_(e_alias1, e_alias2, e_label, e_direction="") e_alias1 e_direction e_alias2 : "===e_label"
!define Rel_(e_alias1, e_alias2, e_label, e_techn, e_direction="") e_alias1 e_direction e_alias2 : "===e_label\n//<size:TECHN_FONT_SIZE>[e_techn]</size>//"

!define Rel(e_from,e_to, e_label) Rel_(e_from,e_to, e_label, "-->")

import org.gradle.api.internal.tasks.testing.redirector.TestOutputRedirector
import spock.lang.Specification
import spock.lang.Subject

class CaptureTestOutputTestResultProcessorTest extends Specification {

    TestResultProcessor target = Mock()
    TestOutputRedirector redirector = Mock()
    @Subject processor = new CaptureTestOutputTestResultProcessor(target, redirector)

    def "starts capturing output"() {

			continue
		}
		name := fmt.Sprintf("%s.%s", wl.Info.Name, wl.Info.Namespace)
		if filter.Direction != "outbound" {
			for _, c := range wl.Connections.Inbound {
				fmt.Fprintf(w, "%v\tInbound\t%v\t%v\t%v\n", name, lookupIP(c.ActualDst), lookupIP(c.Src), c.OriginalDst)
			}
		}
		if filter.Direction != "inbound" {
			for _, c := range wl.Connections.Outbound {

import org.gradle.api.internal.tasks.testing.TestResultProcessor;
import org.gradle.api.internal.tasks.testing.TestStartEvent;
import org.gradle.api.internal.tasks.testing.redirector.StandardOutputRedirector;
import org.gradle.api.internal.tasks.testing.redirector.TestOutputRedirector;
import org.gradle.api.tasks.testing.TestFailure;
import org.gradle.api.tasks.testing.TestOutputEvent;

import java.util.Map;

		}
	}
	sort.Slice(endpoints, func(i, j int) bool {
		iDirection, iSubset, iName, iPort := safelyParseSubsetKey(endpoints[i].ClusterName)
		jDirection, jSubset, jName, jPort := safelyParseSubsetKey(endpoints[j].ClusterName)
		if iName == jName {
			if iSubset == jSubset {
				if iPort == jPort {
					return iDirection < jDirection
				}
				return iPort < jPort
			}
			return iSubset < jSubset
		}

        redirector.stop()

        then:
        System.out == outputs.stdOutPrintStream
        System.err == outputs.stdErrPrintStream
    }

    def startAndStopRedirectsStdOut() {
        when:
        redirector.redirectStandardOutputTo(stdOutListener)
        redirector.start()
        System.out.println('this is stdout')
        System.err.println('this is stderr')
        redirector.stop()

        then:

import org.codelibs.fess.mylasta.direction.sponsor.FessTimeResourceProvider;
import org.codelibs.fess.mylasta.direction.sponsor.FessUserLocaleProcessProvider;
import org.codelibs.fess.mylasta.direction.sponsor.FessUserTimeZoneProcessProvider;
import org.lastaflute.core.direction.CachedFwAssistantDirector;
import org.lastaflute.core.direction.FwAssistDirection;