// add items longer than the individual length
	warningRecorder.AddWarning("", "aaaaaaaaaa")  // long item
	warningRecorder.AddWarning("-", "aaaaaaaaaa") // duplicate item
	warningRecorder.AddWarning("", "bb")          // short item
	warningRecorder.AddWarning("", "ccc")         // short item
	warningRecorder.AddWarning("", "Iñtërnâtiô")  // long item
	// check they are preserved

)

// Recorder provides a method for recording warnings
type Recorder interface {
	// AddWarning adds the specified warning to the response.
	// agent must be valid UTF-8, and must not contain spaces, quotes, backslashes, or control characters.
	// text must be valid UTF-8, and must not contain control characters.
	AddWarning(agent, text string)
}

	truncateItemRunes    = 256
)

type recordedWarning struct {
	agent string
	text  string
}

type recorder struct {
	// lock guards calls to AddWarning from multiple threads
	lock sync.Mutex

	// recorded tracks whether AddWarning was already called with a given text
	recorded map[string]bool

	// ordered tracks warnings added so they can be replayed and truncated if needed
	ordered []recordedWarning

        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()
    }

	if len(warnings) == 0 {
		return handler
	}

	return func(req *restful.Request, res *restful.Response) {
		ctx := req.Request.Context()
		for _, msg := range warnings {
			warning.AddWarning(ctx, "", msg)
		}
		handler(req, res)
	}

		job.Strategy.DefaultGarbageCollectionPolicy(ctx) == rest.OrphanDependents {
		// Throw a warning if delete options are not explicitly set as Job deletion strategy by default is orphaning
		// pods in v1.
		warning.AddWarning(ctx, "", deleteOptionWarnings)
	}
	return r.Store.Delete(ctx, name, deleteValidation, options)
}

		return nil, false, nil
	}

	token := parts[1]

	// Empty bearer tokens aren't valid
	if len(token) == 0 {
		// The space before the token case
		if len(parts) == 3 {
			warning.AddWarning(req.Context(), "", invalidTokenWithSpaceWarning)
		}
		return nil, false, nil
	}

	resp, ok, err := a.auth.AuthenticateToken(req.Context(), token)

}

// simple recorder that only appends warning
type recorder struct {
	mu       sync.Mutex
	warnings []*cacheWarning
}

// AddWarning adds a warning to recorder.
func (r *recorder) AddWarning(agent, text string) {
	r.mu.Lock()
	defer r.mu.Unlock()
	r.warnings = append(r.warnings, &cacheWarning{agent: agent, text: text})
}

	}
	managedFieldsAfterAdmission := objectMeta.GetManagedFields()
	if err := managedfields.ValidateManagedFields(managedFieldsAfterAdmission); err != nil {
		objectMeta.SetManagedFields(managedFieldsBeforeAdmission)
		warning.AddWarning(ctx, "",
			fmt.Sprintf(InvalidManagedFieldsAfterMutatingAdmissionWarningFormat,
				err.Error()),
		)
	}
	return nil
}

// Validate calls the wrapped admission.Interface if aplicable

				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")
	})