generator.addWarning()
        generator.addWarning()
        return generator.save()
    }

    TestFile writeJavaCausingTwoCompilationErrorsAndTwoWarnings(String className) {
        def generator = new ProblematicClassGenerator(className)
        generator.addError()
        generator.addError()
        generator.addWarning()
        generator.addWarning()
        return generator.save()
    }

				break loop
			default:
				warning.AddWarning(r.Context(), "a", "1")
			}
		}
		// the request has just timed out, write to catch read/write races
		warning.AddWarning(r.Context(), "agent", "text")

		// give time for the timeout response to be written, then try to
		// write a response header to catch the "Header after Handler finished" panic
		<-clientDoneCh

		warning.AddWarning(r.Context(), "agent", "text")
	})

	test := genericregistrytest.New(t, storage.Job.Store)
	test.TestDelete(validNewJob())
}

type dummyRecorder struct {
	agent string
	text  string
}

func (r *dummyRecorder) AddWarning(agent, text string) {
	r.agent = agent
	r.text = text
	return
}

func (r *dummyRecorder) getWarning() string {
	return r.text
}

var _ warning.Recorder = &dummyRecorder{}

		}
	}

	if r.maxExpirationSeconds > 0 && req.Spec.ExpirationSeconds > r.maxExpirationSeconds {
		//only positive value is valid
		warning.AddWarning(ctx, "", fmt.Sprintf("requested expiration of %d seconds shortened to %d seconds", req.Spec.ExpirationSeconds, r.maxExpirationSeconds))
		req.Spec.ExpirationSeconds = r.maxExpirationSeconds
	}

								celmetrics.Metrics.ObserveAudit(ctx, decision.Elapsed, definition.Name, binding.Name, "active")
							case admissionregistrationv1.Warn:
								warning.AddWarning(ctx, "", fmt.Sprintf("Validation failed for ValidatingAdmissionPolicy '%s' with binding '%s': %s", definition.Name, binding.Name, decision.Message))

			klog.Warningf("Failed to set admission audit annotation %s to %s for mutating webhook %s: %v", key, v, h.Name, err)
		}
	}
	for _, w := range result.Warnings {
		warning.AddWarning(ctx, "", w)
	}

	if !result.Allowed {
		return false, &webhookutil.ErrWebhookRejection{Status: webhookerrors.ToStatusErr(h.Name, result.Result)}
	}

	if len(result.Patch) == 0 {
		return false, nil

					// typical WarningsOnCreate path to emit the warning before syncing the
					// annotations & fields.
					fldPath := field.NewPath("metadata", "annotations").Key(key)
					warning.AddWarning(ctx, "", fmt.Sprintf(`%s: deprecated since v1.30; use the "appArmorProfile" field instead`, fldPath))
				}
			}

			return true
		})
}

				currentFldPath = currentFldPath.Child(compiled.NormalizedRuleFieldPath)
			}

			addErr := func(e *field.Error) {
				if !compiled.UsesOldSelf && correlation.shouldRatchetError() {
					warning.AddWarning(ctx, "", e.Error())
				} else {
					errs = append(errs, e)
				}
			}

			if compiled.MessageExpression != nil {

		r.delegate.ServeHTTP(w, req)
		return
	}

	deprecated := crdInfo.deprecated[requestInfo.APIVersion]
	for _, w := range crdInfo.warnings[requestInfo.APIVersion] {
		warning.AddWarning(req.Context(), "", w)
	}

	verb := strings.ToUpper(requestInfo.Verb)
	resource := requestInfo.Resource
	subresource := requestInfo.Subresource
	scope := metrics.CleanScope(requestInfo)

	sync.Mutex
	warnings sets.Set[string]
}

func newWarningRecorder() *warningRecorder {
	return &warningRecorder{warnings: sets.New[string]()}
}

func (r *warningRecorder) AddWarning(_, text string) {
	r.Lock()
	defer r.Unlock()
	r.warnings.Insert(text)
	return
}

func (r *warningRecorder) hasWarning(text string) bool {
	r.Lock()
	defer r.Unlock()