exitCode = process(options);
        } catch (final ContainerNotAvailableException e) {
            if (logger.isDebugEnabled()) {
                logger.debug("SuggestCreator is stopped.", e);
            } else if (logger.isInfoEnabled()) {
                logger.info("SuggestCreator is stopped.");
            }
            exitCode = Constants.EXIT_FAIL;

							State: v1.ContainerState{
								Terminated: &v1.ContainerStateTerminated{
									ExitCode: 0,
								},
							},
						},
					},
					ContainerStatuses: []v1.ContainerStatus{
						{
							Name: "main-container",
							State: v1.ContainerState{
								Terminated: &v1.ContainerStateTerminated{
									ExitCode: 111,
								},
							},
						},
						{
							Name: "suppport-container",

            "reason": "reasonValue",
            "message": "messageValue"
          },
          "running": {
            "startedAt": "2001-01-01T01:01:01Z"
          },
          "terminated": {
            "exitCode": 1,
            "signal": 2,
            "reason": "reasonValue",
            "message": "messageValue",
            "startedAt": "2005-01-01T01:01:01Z",
            "finishedAt": "2006-01-01T01:01:01Z",

    }

    ExecOutput build() {
        def result = run()
        if (result.exitCode != 0) {
            throw new AssertionError("Swift PM exited with non-zero exit code. Output:\n${result.out}")
        }
        return result
    }

    ExecOutput buildAndFails() {
        def result = run()
        if (result.exitCode == 0) {
            throw new AssertionError("Swift PM unexpectedly succeeded. Output:\n${result.out}")

        addAll(listOf("-output", testKlib.absolutePathString()))
    }

    val compileResult = callCompilerWithoutOutputInterceptor(arguments.toTypedArray())

    check(compileResult.exitCode == ExitCode.OK) {
        "Compilation error: $compileResult"
    }

    return testKlib

package main

type Node struct {
	Circular bool
}

type ExtNode[V any] struct {
	v V
	Node
}

type List[V any] struct {
	root *ExtNode[V]
	len  int
}

func (list *List[V]) PushBack(arg V) {
	if list.len == 0 {
		list.root = &ExtNode[V]{v: arg}
		list.root.Circular = true
		list.len++
		return
	}
	list.len++
}

func main() {
	var v List[int]
	v.PushBack(1)

					Terminated: &corev1.ContainerStateTerminated{
						Message:  terminationMessage,
						ExitCode: int32(exitCode),
					},
				},
			},
		})
	}

	cases := []struct {
		name   string
		config config.RepairConfig
		pod    *corev1.Pod
		want   bool
	}{
		{
			"Testing OK pod with only ExitCode check",
			config.RepairConfig{
				SidecarAnnotation: "sidecar.istio.io/status",

			if containerStatus.State.Terminated.ExitCode != 0 {
				if isOnExitCodesOperatorMatching(containerStatus.State.Terminated.ExitCode, requirement) {
					return &containerStatus
				}
			}
		}
	}
	return nil
}

func isOnExitCodesOperatorMatching(exitCode int32, requirement *batch.PodFailurePolicyOnExitCodesRequirement) bool {
	switch requirement.Operator {

)

// ContainerStateTerminatedApplyConfiguration represents an declarative configuration of the ContainerStateTerminated type for use
// with apply.
type ContainerStateTerminatedApplyConfiguration struct {
	ExitCode    *int32   `json:"exitCode,omitempty"`
	Signal      *int32   `json:"signal,omitempty"`
	Reason      *string  `json:"reason,omitempty"`
	Message     *string  `json:"message,omitempty"`
	StartedAt   *v1.Time `json:"startedAt,omitempty"`

cd fail
! go test .
! stderr .
stdout '^exitcode=1\n'
stdout '^FAIL\s+example/fail'

# In local directory mode output is streamed, so we don't know
# whether the test printed anything at all, so we print the exit code
# (just in case it failed without emitting any output at all),
# and that happens to add the needed newline as well.
! go test
! stderr .
stdout '^exitcode=1exit status 1\n'
stdout '^FAIL\s+example/fail'