int eventType = parser.next();
        if (eventType == XmlPullParser.TEXT) {
            eventType = parser.next();
        }
        if (eventType != XmlPullParser.START_TAG && eventType != XmlPullParser.END_TAG) {
            throw new XmlPullParserException(
                    "expected START_TAG or END_TAG not " + XmlPullParser.TYPES[eventType], parser, null);
        }

 * deleted without prior notice.
 *
 */
public interface ExecutionEventCatapult {

    void fire(ExecutionEvent.Type eventType, MavenSession session, MojoExecution mojoExecution);

    void fire(ExecutionEvent.Type eventType, MavenSession session, MojoExecution mojoExecution, Exception exception);

        executor.execute(() -> {
            try {
                final Object eventType = dataMap.remove(getParamValue(localParams, "field.event_type", "event_type"));
                if (getParamValue(localParams, "event.create", "create").equals(eventType)
                        || getParamValue(localParams, "event.modify", "modify").equals(eventType)) {
                    // updated file
                    addDocument(localParams, dataMap);

 *
 * @since 4.0.0
 */
@Experimental
public interface Event {

    /**
     * Gets the type of the event.
     *
     * @return the type of the event, never {@code null}
     */
    @Nonnull
    EventType getType();

    /**
     * Gets the session from which this event originates.
     *
     * @return the current session, never {@code null}
     */
    @Nonnull
    Session getSession();

    /**

    public static final int WITNESS_RESOURCE_STATE_UNAVAILABLE = 0x000000FF;
    
    public WitnessNotification(WitnessEventType eventType, String resourceName) {
        this.eventType = eventType;
        this.resourceName = resourceName;
        this.timestamp = System.currentTimeMillis();
        this.newIPAddresses = new ArrayList<>();

      |data: +2
      |data: 10
      |
      |
      """.trimMargin().replace("\n", "\r\n"),
    )
    assertThat(callbacks.remove()).isEqualTo(Event(null, null, "YHOO\n+2\n10"))
  }

  @Test
  fun eventType() {
    consumeEvents(
      """
      |event: add
      |data: 73857293
      |
      |event: remove
      |data: 2153
      |
      |event: add
      |data: 113411
      |
      |

		case "OpType":
			bts, err = z.OpType.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "OpType")
				return
			}
		case "EventType":
			z.EventType, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "EventType")
				return
			}
		case "RetryCount":
			z.RetryCount, bts, err = msgp.ReadUint32Bytes(bts)
			if err != nil {

						},
						Bucket:    roi.Bucket,
						OpType:    replication.ExistingObjectReplicationType,
						EventType: ReplicateExistingDelete,
					}
					replicateDelete(ctx, doi, objectAPI)
				} else {
					roi.OpType = replication.ExistingObjectReplicationType
					roi.EventType = ReplicateExisting
					replicateObject(ctx, roi, objectAPI)
				}

				st := TargetReplicationResyncStatus{

        TransferEvent transferStartedEvent = event(session, resource, TransferEvent.EventType.STARTED);
        TransferEvent transferProgressedEvent = event(session, resource, TransferEvent.EventType.PROGRESSED);
        TransferEvent transferSucceededEvent = event(session, resource, TransferEvent.EventType.SUCCEEDED);

                // this one should block until all processed
                listener.transferSucceeded(new TransferEvent.Builder(session, resource)
                        .setType(TransferEvent.EventType.SUCCEEDED)
                        .build());

                StringBuilder message = new StringBuilder("Messages [");
                boolean test = true;
                for (int i = 0; i < 999; i++) {