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
		}

platforms (e.g. OpenShift) privileged: false # Custom configuration happens based on the CNI provider. # Possible values: "default", "multus" provider: "default" # Configure ambient settings ambient: # If enabled, ambient redirection will be enabled enabled: false # Set ambient redirection mode: "iptables" or "ebpf" redirectMode: "iptables" # Set ambient config dir path: defaults to /etc/ambient-config configDir: "" repair: enabled: true hub: "" tag: "" labelPods: true deletePods: true initContainerName:...

        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;

                  (strdict "istio.io/rev" (.Revision | default "default"))
                  (strdict
                    "ambient.istio.io/redirection" "disabled"
                    "prometheus.io/path" "/stats/prometheus"
                    "prometheus.io/port" "15020"
                    "prometheus.io/scrape" "true"
                  ) | nindent 8 }}

    // source: 'classKinds.kt'
}

public final enum class Direction {
    // source: 'classKinds.kt'
    private synthetic final static field $ENTRIES: kotlin.enums.EnumEntries
    private synthetic final static field $VALUES: Direction[]
    public final enum static field EAST: Direction
    public final enum static field NORTH: Direction
    public final enum static field SOUTH: Direction
    public final enum static field WEST: Direction

        this.redirector = redirector;
        this.outForwarder = new Forwarder(processor, TestOutputEvent.Destination.StdOut);
        this.errForwarder = new Forwarder(processor, TestOutputEvent.Destination.StdErr);
    }

    public void startRedirecting() {
        assert outForwarder.outputOwner != null;
        assert errForwarder.outputOwner != null;