// Make a shallow copy to avoid copying response/request objects.
	newEvent := &auditinternal.Event{}
	*newEvent = *e

	newEvent.RequestObject = nil
	newEvent.ResponseObject = nil

	if newEvent.Annotations == nil {
		newEvent.Annotations = make(map[string]string)
	}
	newEvent.Annotations[annotationKey] = annotationValue

	return newEvent
}

func (b *backend) Run(stopCh <-chan struct{}) error {

	allErrs = append(allErrs, ValidateObjectMetaUpdate(&newEvent.ObjectMeta, &oldEvent.ObjectMeta, field.NewPath("metadata"))...)
	// if the series was modified, validate the new data
	if !reflect.DeepEqual(newEvent.Series, oldEvent.Series) {
		allErrs = append(allErrs, validateV1EventSeries(newEvent)...)
	}

	allErrs = append(allErrs, ValidateImmutableField(newEvent.InvolvedObject, oldEvent.InvolvedObject, field.NewPath("involvedObject"))...)

    def canCreateCopyWithNonNullParentId() {
        TestStartEvent event = new TestStartEvent(200L)

        expect:
        def newEvent = event.withParentId('parent')
        newEvent != event
        newEvent.startTime == 200L
        newEvent.parentId == 'parent'
    }

				ReportingInstance:   "node-xyz",
				Action:              "Do",
				Reason:              "Yeees",
				Type:                "Normal",
			}

			newEvent := oldEvent.DeepCopy()
			newEvent.EventTime = tc.New

			updateErrs := ValidateEventUpdate(newEvent, oldEvent, eventsv1.SchemeGroupVersion)
			if e, a := tc.Valid, len(updateErrs) == 0; e != a {
				t.Errorf("%v: expected valid=%v, got %v: %v", tc.Valid, e, a, updateErrs)

				newEvent(v1.EventTypeNormal, "Successfully assigned recycler-for-podRecyclerSuccess to 127.0.0.1"),
				newEvent(v1.EventTypeNormal, "Pulling image \"registry.k8s.io/busybox\""),
				newEvent(v1.EventTypeNormal, "Successfully pulled image \"registry.k8s.io/busybox\""),
				newEvent(v1.EventTypeNormal, "Created container with docker id 83d929aeac82"),

		args.EventName == event.ObjectRemovedDeleteMarkerCreated ||
		args.EventName == event.ObjectRemovedNoOP

	if !isRemovedEvent {
		newEvent.S3.Object.ETag = args.Object.ETag
		newEvent.S3.Object.Size = args.Object.Size
		newEvent.S3.Object.ContentType = args.Object.ContentType
		newEvent.S3.Object.UserMetadata = make(map[string]string, len(args.Object.UserDefined))
		for k, v := range args.Object.UserDefined {

    @Override
    public void onOutput(OutputEvent newEvent) {
        synchronized (lock) {
            queue.add(newEvent);

            if (queue.size() == 10000) {
                renderNow();
                return;
            }

            if (newEvent instanceof InteractiveEvent) {
                renderNow();
                return;
            }

            if (newEvent instanceof EndOutputEvent) {

			if event.outdated {
				foundOldSample = true
				oldSampleIndex = i
			}
		}
		newEvent := timestampedScaleEvent{replicaChange, time.Now(), false}
		if foundOldSample {
			a.scaleUpEvents[key][oldSampleIndex] = newEvent
		} else {
			a.scaleUpEvents[key] = append(a.scaleUpEvents[key], newEvent)
		}
	} else {
		longestPolicyPeriod = getLongestPolicyPeriod(behavior.ScaleDown)

	t.Log("Max batch size encountered.")
	backend.ProcessEvents(newEvents(batchSize + 1)...)
	batch := backend.collectEvents(nil, nil)
	assert.Len(t, batch, batchSize, "Expected full batch")

	t.Log("Partial batch should hang until timer expires.")
	backend.ProcessEvents(newEvents(1)...)
	tc := make(chan time.Time)
	wg := sync.WaitGroup{}
	wg.Add(1)
	go func() {
		defer wg.Done()

					pkgName = cand.Name.Name
				}
			}
		}
		if pkgName == "." {
			return ast.NewIdent(t.Obj().Name())
		}
		return &ast.SelectorExpr{
			X:   ast.NewIdent(pkgName),
			Sel: ast.NewIdent(t.Obj().Name()),
		}
	case *types.Struct:
		return ast.NewIdent(t.String())
	case *types.Interface:
		return ast.NewIdent(t.String())
	default:
		return nil
	}
}