}

    private static InputFileChanges caching(InputFileChanges wrapped) {
        CachingChangeContainer cachingChangeContainer = new CachingChangeContainer(MAX_OUT_OF_DATE_MESSAGES, wrapped);
        return new InputFileChangesWrapper(wrapped, cachingChangeContainer);
    }

    private static ChangeContainer errorHandling(Describable executable, ChangeContainer wrapped) {
        return new ErrorHandlingChangeContainer(executable, wrapped);

}

// Tests that single TensorFlow op with no device attribute is not wrapped in `tf_device.launch`.
// CHECK-LABEL: func @no_device_attribute
func.func @no_device_attribute() {
  // CHECK-NOT: "tf_device.launch"
  // CHECK: "tf.opA"
  "tf.opA"() : () -> tensor<i1>
  func.return
}

// Tests that single TensorFlow op with empty device attribute is not wrapped in `tf_device.launch`.
// CHECK-LABEL: func @empty_device_attribute

		callCount++
	})
	// wrap with start and completed handler
	wrapped := TrackCompleted(handler)
	wrapped = TrackStarted(wrapped, tp, filterName)

	testRequest, err := http.NewRequest(http.MethodGet, "/api/v1/namespaces", nil)
	if err != nil {
		t.Fatalf("failed to create new http request - %v", err)
	}

	wrapped.ServeHTTP(httptest.NewRecorder(), testRequest)

	if callCount != 1 {

// caches the result.
type cachedMetrics struct {
	wrapped       MetricsProvider
	resultError   error
	resultMetrics *Metrics
	once          cacheOnce
}

// NewCachedMetrics creates a new cachedMetrics wrapping another
// MetricsProvider and caching the results.
func NewCachedMetrics(provider MetricsProvider) MetricsProvider {
	return &cachedMetrics{wrapped: provider}
}

// the result of the Go function mapped back to JavaScript according to ValueOf.
//
// Invoking the wrapped Go function from JavaScript will
// pause the event loop and spawn a new goroutine.
// Other wrapped functions which are triggered during a call from Go to JavaScript
// get executed on the same goroutine.
//
// As a consequence, if one wrapped function blocks, JavaScript's event loop

// It supports wrapped errors and returns false when the error is nil.
func IsAlreadyExists(err error) bool {
	return ReasonForError(err) == metav1.StatusReasonAlreadyExists
}

// IsConflict determines if the err is an error which indicates the provided update conflicts.
// It supports wrapped errors and returns false when the error is nil.
func IsConflict(err error) bool {

3. unindented.

4. This one
  is a list
  because of the indented text.
5. More wrapped
  items.
6. And unwrapped.

7. The blank line stops the heuristic.
-- gofmt --
Text.

1. Not a list
2. because it is
3. unindented.

 4. This one
    is a list
    because of the indented text.
 5. More wrapped
    items.
 6. And unwrapped.

var _ admission.ValidationInterface = &managedFieldsValidatingAdmissionController{}

// Handles calls the wrapped admission.Interface if applicable
func (admit *managedFieldsValidatingAdmissionController) Handles(operation admission.Operation) bool {
	return admit.wrap.Handles(operation)
}

// Admit calls the wrapped admission.Interface if applicable and resets the managedFields to their state before admission if they

		t.Errorf("expected cause, got %v: %#v", ok, cause)
	}

	wrapped := fmt.Errorf("once: %w", err)
	if cause, ok := StatusCause(wrapped, "SomeCause"); !ok || cause != err.ErrStatus.Details.Causes[0] {
		t.Errorf("expected cause when wrapped, got %v: %#v", ok, cause)
	}

	nested := fmt.Errorf("twice: %w", wrapped)
	if cause, ok := StatusCause(nested, "SomeCause"); !ok || cause != err.ErrStatus.Details.Causes[0] {

				// does the inner handler see the audit ID?
				v, ok := audit.AuditIDFrom(req.Context())

				found = ok
				auditIDGot = string(v)
			})

			wrapped := WithAuditInit(handler)
			if test.newAuditIDFunc != nil {
				wrapped = withAuditInit(handler, test.newAuditIDFunc)
			}

			testRequest, err := http.NewRequest(http.MethodGet, "/api/v1/namespaces", nil)
			if err != nil {