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;

kind: Service
metadata:
  name: registry-redirector
  labels:
    app: registry-redirector
spec:
  type: LoadBalancer
  ports:
  - name: http
    port: 1338
  selector:
    app: registry-redirector
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: registry-redirector
spec:
  replicas: 1
  selector:
    matchLabels:
      app: registry-redirector
  template:
    metadata:
      labels:

      ENUM_ENTRY name:WEST
        init: EXPRESSION_BODY
          ENUM_CONSTRUCTOR_CALL 'private constructor <init> () [primary] declared in <root>.Direction'
      ENUM_ENTRY name:EAST
        init: EXPRESSION_BODY
          ENUM_CONSTRUCTOR_CALL 'private constructor <init> () [primary] declared in <root>.Direction'
      CONSTRUCTOR visibility:private <> () returnType:<root>.Direction [primary]

	testKube "istio.io/istio/pkg/test/kube"
	"istio.io/istio/pkg/test/scopes"
	"istio.io/istio/pkg/test/util/retry"
)

const (
	service     = "registry-redirector"
	ns          = "registry-redirector"
	podSelector = "app=registry-redirector"
)

var (
	_ Instance  = &kubeComponent{}
	_ io.Closer = &kubeComponent{}
)

type kubeComponent struct {
	id        resource.ID
	ns        namespace.Instance

type Chan struct {
	dir  ChanDir
	elem Type
}

// A ChanDir value indicates a channel direction.
type ChanDir int

// The direction of a channel is indicated by one of these constants.
const (
	SendRecv ChanDir = iota
	SendOnly
	RecvOnly
)

// NewChan returns a new channel type for the given direction and element type.
func NewChan(dir ChanDir, elem Type) *Chan {
	return &Chan{dir: dir, elem: elem}
}

     *
     * The missing cases of the when-expression in the following example are Direction.WEST and Direction.EAST:
     *
     * enum class Direction {
     *   NORTH, SOUTH, WEST, EAST
     * }
     * foo = when(direction) {
     *   Direction.NORTH -> 1
     *   Direction.SOUTH -> 2
     *   else -> 3
     * }
     *