builder.addTrustedArtifact(group, name, version, fileName, regex, reason)
        }

        void addGloballyIgnoredKey(String id, String reason = "for tests") {
            builder.addIgnoredKey(new IgnoredKey(id, reason))
        }

                val reason = checkFingerprintValueIsUpToDate(obtainedValue)
                if (reason != null) return reason
            }
            is ConfigurationCacheFingerprint.InitScripts -> input.run {
                val reason = checkInitScriptsAreUpToDate(fingerprints, host.allInitScripts)
                if (reason != null) return reason
            }

            assertHasAccepted(
                "Method com.example.Task.getSourceCompatibility(): Is not binary compatible. Reason for accepting this: Upgraded property" to listOf("Method return type has changed", "Method is now abstract"),
                "Method com.example.Task.setSourceCompatibility(java.lang.String): Is not binary compatible. Reason for accepting this: Upgraded property" to listOf("Method has been removed")
            )
        }
    }

            return cannot("finalize", displayName, reason);
        }

        private String cannotQueryValueOf(Describable displayName, String reason) {
            return cannot("query", displayName, reason);
        }

        private String cannot(String what, Describable displayName, String reason) {
            TreeFormatter formatter = new TreeFormatter();

  override fun close(
    code: Int,
    reason: String?,
  ): Boolean {
    return close(code, reason, webSocketCloseTimeout)
  }

  @Synchronized fun close(
    code: Int,
    reason: String?,
    cancelAfterCloseMillis: Long,
  ): Boolean {
    validateCloseCode(code)

    var reasonBytes: ByteString? = null
    if (reason != null) {
      reasonBytes = reason.encodeUtf8()

                } else {
                    stopNow(reason);
                }
            }
        } finally {
            lock.unlock();
        }
    }

    @Override
    public void requestForcefulStop(String reason) {
        LOGGER.lifecycle(DAEMON_STOPPING_IMMEDIATELY_MESSAGE + reason);
        stopNow(reason);
    }

    /**

  // +optional
  optional string messageExpression = 3;

  // reason provides a machine-readable validation failure reason that is returned to the caller when a request fails this validation rule.
  // The HTTP status code returned to the caller will match the reason of the reason of the first failed validation rule.
  // The currently supported reasons are: "FieldValueInvalid", "FieldValueForbidden", "FieldValueRequired", "FieldValueDuplicate".

  // ClasLoader via its AccessControlContext. It does not seem to be possible to make a
  // URLClassLoader without capturing this reference, and it probably would not be desirable for
  // security reasons anyway. Therefore, the FRQ.close() method provides a way to stop the thread
  // explicitly. This test checks that calling that method does allow an app's ClassLoader to be

		},
	}
	for _, test := range resourceTests {
		t.Run(test.name, func(t *testing.T) {
			test.nodeInfo.SetNode(test.node)
			reasons := generalFilter(test.pod, test.nodeInfo)
			if diff := cmp.Diff(test.reasons, reasons); diff != "" {
				t.Errorf("unexpected failure reasons (-want, +got):\n%s", diff)
			}
		})
	}
}

func TestRejectPodAdmissionBasedOnOSSelector(t *testing.T) {
	tests := []struct {

        containerID: containerIDValue
        exitCode: 1
        finishedAt: "2006-01-01T01:01:01Z"
        message: messageValue
        reason: reasonValue
        signal: 2
        startedAt: "2005-01-01T01:01:01Z"
      waiting:
        message: messageValue
        reason: reasonValue
    name: nameValue
    ready: true
    resources:
      claims:
      - name: nameValue
      limits: