* <p>
     * For further details on permissions see {@link ConfigurableUserClassFilePermissions}.
     */
    @Override
    ConfigurableUserClassFilePermissions getOther();

    /**
     * Modifies the permissions all other users (non-owner, non-group) have
     * for the file/directory.
     * <p>

    protected PatternSet doCopyFrom(PatternSet from) {
        caseSensitive = from.caseSensitive;

        if (from instanceof IntersectionPatternSet) {
            PatternSet other = ((IntersectionPatternSet) from).getOther();
            PatternSet otherCopy = new PatternSet(other).copyFrom(other);
            PatternSet intersectCopy = new IntersectionPatternSet(otherCopy);
            copyIncludesAndExcludes(intersectCopy, from);

                // Should be ignored because it's not a getter
                public void getVoid() {
                }

                // Should be ignored because it's not a getter
                public int getWithParameter(int count) {
                    return count;
                }

                public long getter() {
                    return 0L;
                }

  void setEmployed(boolean isEmployed)
  boolean isEmployed()
// end::property-type-boolean[]

// tag::property-type-managed[]
  void setMother(Person mother)
  Person getMother()
// end::property-type-managed[]

  void setFather(Person father)
  Person getFather()

// tag::property-type-managedset[]
  ModelSet<Person> getChildren()
// end::property-type-managedset[]

// tag::property-type-file[]

        private final Method getter;
        private final Field field;
        private final Class<?> elementType;

        public PropertyFieldSetter(Method getter, Field field) {
            this(getter, field, ModelType.of(getter.getGenericReturnType()).getTypeVariables().get(0).getRawClass());
        }

        public PropertyFieldSetter(Method getter, Field field, Class<?> elementType) {

            dummyModel("otherValue"),
            [
                { it.value }
            ]
        )

        then:
        def error = thrown(AssertionError)
        error.message.contains("assert getter(actual) == getter(expected)")
        error.message.contains("       |      |       |  |")
        error.message.contains("       |      |       |  'otherValue'")
        error.message.contains("       'someValue'")
    }

	storage := map[string]rest.Storage{}

	// use a simple wrapper so that initialization order won't cause a nil getter
	var policyGetter rest.Getter

	r, err := resolver.NewDiscoveryResourceResolver(p.DiscoveryClient)
	if err != nil {
		return storage, err
	}

	// validatingwebhookconfigurations

	}
	finder := NewCRDFinder(getter)
	found, err := finder.HasCRD(schema.GroupKind{Group: "", Kind: "Pod"})
	if found {
		t.Fatalf("Found the CRD with non-working getter function")
	}
	if err == nil {
		t.Fatalf("Error in getter should be reported")
	}
}

func TestCRDFinder(t *testing.T) {
	getter := func() ([]schema.GroupKind, error) {
		return []schema.GroupKind{
			{
				Group: "crd.com",

        this.getter = getter;
        getter.setAccessible(true);
        this.declaredType = TypeToken.of(getter.getGenericReturnType());
        this.annotationsByCategory = annotationsByCategory;
        this.annotationsByType = collectAnnotationsByType(annotationsByCategory);
    }

    final Supplier<Map<String, String>> getter;
    final Consumer<Properties> setter;

    WrapperProperties(Supplier<Map<String, String>> getter, Consumer<Properties> setter) {
        this.getter = getter;
        this.setter = setter;
    }

    @Override
    public String getProperty(String key) {
        return getter.get().get(key);
    }

    @Override