}

        if (classLoaderStructure.getSpec() instanceof FilteringClassLoader.Spec) {
            encoder.writeByte(FILTERING_SPEC);
            filteringClassLoaderSpecSerializer.write(encoder, (FilteringClassLoader.Spec) classLoaderStructure.getSpec());
        } else if (classLoaderStructure.getSpec() instanceof VisitableURLClassLoader.Spec) {

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) {

 * limitations under the License.
 */

package org.gradle.workers.internal;

import org.gradle.internal.classloader.ClassLoaderSpec;

public interface ClassLoaderStructure {
    ClassLoaderSpec getSpec();

    ClassLoaderStructure getParent();

        } else {
            // Climb up the hierarchy looking for the highest parent
            ClassLoader parent = createWorkerClassLoaderWithStructure(workerInfrastructureClassloader, classLoaderStructure.getParent(), legacyTypesSupport);
            return createClassLoaderFromSpec(parent, classLoaderStructure.getSpec(), legacyTypesSupport);
        }
    }

        this.spec = spec;
    }

    public ConfigurableRule<ComponentMetadataContext> getConfigurableRule() {
        return configurableRule;
    }

    public Spec<ModuleVersionIdentifier> getSpec() {
        return spec;
    }

    private List<Map.Entry<FileNormalizationSpec, FileCollectionFingerprinter>> entriesFrom(Collection<FingerprinterRegistration> registrations) {
        return registrations.stream().map(registration -> Maps.immutableEntry(registration.getSpec(), registration.getFingerprinter())).collect(ImmutableList.toImmutableList());
    }

    @Override
    public FileCollectionFingerprinter getFingerprinter(FileNormalizationSpec spec) {

        this.action = action;
        this.spec = spec;
    }

    public RuleAction<? super T> getAction() {
        return action;
    }

    public Spec<? super T> getSpec() {
        return spec;
    }

    private final VisitableURLClassLoader.Spec spec;

    public FlatClassLoaderStructure(VisitableURLClassLoader.Spec spec) {
        this.spec = spec;
    }

    @Override
    public VisitableURLClassLoader.Spec getSpec() {
        return spec;
    }

    @Override
    public ClassLoaderStructure getParent() {
        return null;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {

    private FingerprinterRegistration(FileNormalizationSpec spec, FileCollectionFingerprinter fingerprinter) {
        this.spec = spec;
        this.fingerprinter = fingerprinter;
    }

    public FileNormalizationSpec getSpec() {
        return spec;
    }

    public FileCollectionFingerprinter getFingerprinter() {
        return fingerprinter;
    }