ModelSchemaAspectExtractionResult result = strategy.extract(extractionContext, propertyResults);
            if (result != null) {
                aspects.add(result.getAspect());
            }
        }
        return aspects;
    }

type IstioKind struct {
	metav1.TypeMeta
	metav1.ObjectMeta `json:"metadata"`
	Spec              json.RawMessage  `json:"spec"`
	Status            *json.RawMessage `json:"status,omitempty"`
}

// GetSpec from a wrapper
func (in *IstioKind) GetSpec() json.RawMessage {
	return in.Spec
}

// GetStatus from a wrapper
func (in *IstioKind) GetStatus() *json.RawMessage {
	return in.Status
}

// GetObjectMeta from a wrapper

	"istio.io/istio/pkg/ptr"
)

func TestKind(t *testing.T) {
	obj := crd.IstioKind{}

	spec := json.RawMessage(`{"a":"b"}`)
	obj.Spec = spec
	if got := obj.GetSpec(); !reflect.DeepEqual(spec, got) {
		t.Errorf("GetSpec() => got %v, want %v", got, spec)
	}

	status := ptr.Of(json.RawMessage(`{"c":"d"}`))
	obj.Status = status
	if got := obj.GetStatus(); !reflect.DeepEqual(status, got) {

        HierarchicalClassLoaderStructure childNode = new HierarchicalClassLoaderStructure(spec, this);
        return childNode;
    }

    @Override
    public ClassLoaderSpec getSpec() {
        return self;
    }

    @Override
    public HierarchicalClassLoaderStructure getParent() {
        return parent;
    }

    @Override
    public boolean equals(Object o) {

    // Not public. Evaluation of these specs is a major hot spot for large builds, so use an array for iteration
    Spec<? super T>[] getSpecsArray() {
        return specs;
    }

    public List<Spec<? super T>> getSpecs() {
        return Collections.unmodifiableList(Arrays.asList(specs));
    }

    public boolean isEmpty() {
        return specs.length == 0;
    }

    @Override
    public final boolean equals(Object o) {

    }

    public static class TestDetails {
        private final SpecInfo spec;
        private final Method featureMethod;

        TestDetails(FeatureInfo feature) {
            this.spec = feature.getSpec().getBottomSpec();
            this.featureMethod = feature.getFeatureMethod().getReflection();
        }

        public <A extends Annotation> A getAnnotation(Class<A> type) {

                    }
                }
                if (!groups.isEmpty()) {
                    scenarioDefinition.getPerformanceTests().add(new PerformanceTestScenarioDefinition.PerformanceTestsBean("${invocation.getSpec().getReflection().getName()}.$testId", groups))
                }
                Assume.assumeFalse(true)
            } else {
                invocation.proceed()
            }
        }
    }

// ConvertObject converts an IstioObject k8s-style object to the internal configuration model.
func ConvertObject(schema resource.Schema, object IstioObject, domain string) (*config.Config, error) {
	js, err := json.Marshal(object.GetSpec())
	if err != nil {
		return nil, err
	}
	spec, err := FromJSON(schema, string(js))
	if err != nil {
		return nil, err
	}
	status, err := StatusJSONFromMap(schema, object.GetStatus())
	if err != nil {

        }

        @Override
        public CopySpecAddress getParent() {
            return parent;
        }

        @Override
        public CopySpecInternal getSpec() {
            return spec;
        }

        @Override
        public int getAdditionIndex() {
            return additionIndex;
        }

        @Override