1 * target.onOutput({ StyledTextOutputEvent event ->
            event.spans.size() == 1 && event.spans[0].text == toNative('task2\n')
        })
        1 * target.onOutput({ StyledTextOutputEvent event ->
            event.spans.size() == 3 &&
                event.spans[0].text == toNative('task1 ') &&
                event.spans[1].text == toNative('task1-done') &&
                event.spans[2].text == toNative('\n')
        })

			}
		} else {
			// event namespace must match
			if event.Namespace != event.InvolvedObject.Namespace {
				allErrs = append(allErrs, field.Invalid(field.NewPath("involvedObject", "namespace"), event.InvolvedObject.Namespace, "does not match event.namespace"))
			}
		}

	} else {

	defer f.Unlock()
	f.stopped = false
	f.result = make(chan Event)
}

func (f *FakeWatcher) ResultChan() <-chan Event {
	return f.result
}

// Add sends an add event.
func (f *FakeWatcher) Add(obj runtime.Object) {
	f.result <- Event{Added, obj}
}

// Modify sends a modify event.
func (f *FakeWatcher) Modify(obj runtime.Object) {
	f.result <- Event{Modified, obj}
}

// Delete sends a delete event.

func TestPodRunning(t *testing.T) {
	tests := []struct {
		name    string
		event   watch.Event
		want    bool
		wantErr bool
	}{
		{
			name: "Watch type is deleted",
			event: watch.Event{
				Type: watch.Deleted,
			},
			want:    false,
			wantErr: true,
		},
		{
			name: "Pod Status type is PodRunning",
			event: watch.Event{
				Type: watch.Added,
				Object: &corev1.Pod{
					Status: corev1.PodStatus{

    void projectDiscoveryStarted(ExecutionEvent event);

    void sessionStarted(ExecutionEvent event);

    void sessionEnded(ExecutionEvent event);

    void projectSkipped(ExecutionEvent event);

    void projectStarted(ExecutionEvent event);

    void projectSucceeded(ExecutionEvent event);

    void projectFailed(ExecutionEvent event);

    void mojoSkipped(ExecutionEvent event);

    override fun closes(event: CallEvent): Boolean = event is CallStart && call == event.call
  }

  data class CallFailed(
    override val timestampNs: Long,
    override val call: Call,
    val ioe: IOException,
  ) : CallEvent() {
    override fun closes(event: CallEvent): Boolean = event is CallStart && call == event.call
  }

  data class Canceled(
    override val timestampNs: Long,

		klog.V(4).InfoS("Received Container Created Event", "event", event.String())
	case runtimeapi.ContainerEventType_CONTAINER_STARTED_EVENT:
		e.sendPodLifecycleEvent(&PodLifecycleEvent{ID: types.UID(event.PodSandboxStatus.Metadata.Uid), Type: ContainerStarted, Data: event.ContainerId})
		klog.V(4).InfoS("Received Container Started Event", "event", event.String())
	case runtimeapi.ContainerEventType_CONTAINER_DELETED_EVENT:

        then:
        output.count("EVENT:") == 3
        outputContains("EVENT: finish :thing")
        outputContains("EVENT: finish :a:thing")
        outputContains("EVENT: finish :b:thing")

        when:
        run("thing")

        then:
        output.count("EVENT:") == 3
        outputContains("EVENT: finish :thing")
        outputContains("EVENT: finish :a:thing")

            assert event.eventTime == 999
            assert event.displayName == "test skipped"
            assert event.descriptor.name == 'some test'
            assert event.descriptor.jvmTestKind == JvmTestKind.ATOMIC
            assert event.descriptor.className == 'Foo'
            assert event.descriptor.parent == null
            assert event.result instanceof TestSkippedResult

    public void onOutput(OutputEvent event) {
        if (event instanceof ProgressStartEvent) {
            onStart((ProgressStartEvent) event);
        } else if (event instanceof RenderableOutputEvent) {
            handleOutput((RenderableOutputEvent) event);
        } else if (event instanceof ProgressCompleteEvent) {
            onComplete((ProgressCompleteEvent) event);
        } else if (event instanceof EndOutputEvent) {