u.SetUID("")
	u.SetResourceVersion("")
	u.SetGeneration(0)
	u.SetCreationTimestamp(metav1.Time{})
	u.SetDeletionTimestamp(nil)
	u.SetDeletionGracePeriodSeconds(nil)
	u.SetLabels(nil)
	u.SetAnnotations(nil)
	u.SetOwnerReferences(nil)
	u.SetFinalizers(nil)
	u.SetManagedFields(nil)

	gotMetadata, _, err := unstructured.NestedFieldNoCopy(u.UnstructuredContent(), "metadata")
	if err != nil {
		t.Error(err)

    void visitValidationFailures(TypeValidationContext validationContext);

    /**
     * Retrieves the annotation of the given type, if present on the type itself.
     */
    <T extends Annotation> Optional<T> getAnnotation(Class<T> annotationType);

    WeaklyTypeReferencingMethod<?, R> getMethod();

    String getMethodName();

    boolean isAnnotationPresent(Class<? extends Annotation> annotationType);

    @Nullable
    <A extends Annotation> A getAnnotation(Class<A> annotationType);

    ModelType<R> getReturnType();

    List<ModelReference<?>> getReferences();

    List<List<Annotation>> getParameterAnnotations();

    @Nullable

 */
class ToBeFixedForConfigurationCacheRule implements TestRule {

    @Override
    Statement apply(Statement base, Description description) {
        def annotation = description.getAnnotation(ToBeFixedForConfigurationCache.class)
        if (GradleContextualExecuter.isNotConfigCache() || annotation == null) {
            return base
        }

        return delegate.toString();
    }

    private void registerSoftwareTypes(TypeMetadata typeMetadata) {
        Optional<RegistersSoftwareTypes> registersSoftwareType = typeMetadata.getTypeAnnotationMetadata().getAnnotation(RegistersSoftwareTypes.class);
        registersSoftwareType.ifPresent(registration -> {
            Class<? extends Plugin<Settings>> registeringPlugin = Cast.uncheckedCast(typeMetadata.getType());

            OwnerServiceEncoding(serviceType)
        } else {
            null
        }
    }

    private
    fun serviceType(type: Class<*>): Class<*>? {
        if (type.getAnnotation(ServiceScope::class.java) != null) {
            return type
        }
        for (superInterface in type.interfaces) {
            val serviceType = serviceType(superInterface)
            if (serviceType != null) {

import static org.junit.Assume.assumeTrue

class UnsupportedWithConfigurationCacheRule implements TestRule {

    @Override
    Statement apply(Statement base, Description description) {
        def annotation = description.getAnnotation(UnsupportedWithConfigurationCache.class)
        if (GradleContextualExecuter.isNotConfigCache() || annotation == null) {
            return base
        }

        assert transported.toString() == original.toString()
        assert transported.stackTrace == original.stackTrace
        assert (transported.class.getAnnotation(Contextual) != null) == (original.class.getAnnotation(Contextual) != null)
    }

    private Object transport(Object arg) {
        def outputStream = new ByteArrayOutputStream()

    public void visitValidationFailures(TypeValidationContext validationContext) {
        validationProblems.replay(null, validationContext);
    }

    @Override
    public <T extends Annotation> Optional<T> getAnnotation(Class<T> annotationType) {
        return Optional.ofNullable(Cast.uncheckedCast(annotations.get(annotationType)));
    }

                // Won't validate interfaces
                return;
            }
            if (!cacheable
                && topLevelBean.getAnnotation(DisableCachingByDefault.class) == null
                && topLevelBean.getAnnotation(UntrackedTask.class) == null
            ) {
                boolean isTask = Task.class.isAssignableFrom(topLevelBean);