fun assertExhausted() {
    assertThat(events).isEmpty()
  }

  fun assertEvent(
    id: String?,
    type: String?,
    data: String,
  ) {
    assertThat(nextEvent()).isEqualTo(Event(id, type, data))
  }

  fun assertOpen(): EventSource {
    val event = nextEvent() as Open
    return event.eventSource
  }

  fun assertClose() {
    nextEvent() as Closed
  }

  fun assertFailure(

				event = Event{}
			}

			if e.IsPendingReplication(obj) {
				event = Event{}
			}
		}
		if !obj.IsLatest {
			switch event.Action {
			case DeleteVersionAction:
				// this noncurrent version will be expired, nothing to add
			default:
				// this noncurrent version will be spared
				newerNoncurrentVersions++
			}
		}
		events[i] = event
	}
	return events
}

						// This is a MinIO only extension.
						event.Action = DeleteAllVersionsAction
					}
					events = append(events, event)
				}
			}

			if obj.TransitionStatus != TransitionComplete {
				if due, ok := rule.Transition.NextDue(obj); ok && (now.IsZero() || now.After(due)) {
					events = append(events, Event{
						Action:       TransitionAction,
						RuleID:       rule.ID,

Sebastián Ramírez <******@****.***> 1731896744 +0100

  }

  /**
   * Enqueues an event to be run on currently known listeners.
   *
   * <p>The {@code toString} method of the Event itself will be used to describe the event in the
   * case of an error.
   *
   * @param event the callback to execute on {@link #dispatch}
   */
  public void enqueue(Event<L> event) {
    enqueueHelper(event, event);
  }

  /**

  }

  /**
   * Removes recorded events up to (and including) an event is found whose class equals [eventClass]
   * and returns it.
   */
  fun <T : CallEvent> removeUpToEvent(eventClass: Class<T>): T {
    val fullEventSequence = eventSequence.toList()
    try {
      while (true) {
        val event = takeEvent()
        if (eventClass.isInstance(event)) {
          return eventClass.cast(event)
        }
      }

        assertEquals(Long.valueOf(1), stats.get(EventType.AUTHENTICATION_SUCCESS), "Should have 1 authentication success event");
        assertEquals(Long.valueOf(1), stats.get(EventType.AUTHENTICATION_FAILURE), "Should have 1 authentication failure event");
        assertEquals(Long.valueOf(1), stats.get(EventType.FILE_ACCESS), "Should have 1 file access event");
    }

    @Test
    @DisplayName("Test reset statistics")
    void testResetStatistics() {

    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);

func (target *KafkaTarget) SendFromStore(key store.Key) (err error) {
	if err = target.init(); err != nil {
		return err
	}
	switch {
	case key.ItemCount == 1:
		var event event.Event
		event, err = target.store.Get(key)
		if err != nil {
			// The last event key in a successful batch will be sent in the channel atmost once by the replayEvents()

		}
		objs = append(objs, obj)
	}

	evaluator := NewEvaluator(Lifecycle{})
	events, err := evaluator.Eval(objs)
	if err != nil {
		t.Fatal(err)
	}
	for _, event := range events {
		if event.Action != NoneAction {
			t.Fatalf("got %v, want %v", event.Action, NoneAction)
		}
	}