}
	defer r.Close()

	ret, err := extractWasmPluginBinary(r)
	if err != nil {
		return nil, fmt.Errorf("could not extract wasm binary: %v", err)
	}
	return ret, nil
}

// extractOCIStandardImage extracts the Wasm binary from the
// *compat* variant Wasm image with the standard OCI media type: application/vnd.oci.image.layer.v1.tar+gzip.

import org.gradle.cache.scopes.ScopedCacheBuilderFactory;

import java.io.File;

/**
 * The default implementation of {@link DecompressionCoordinator} that can be used to store decompressed data extracted from archive files like zip and tars.
 *
 * Will manage access to the cache, so that access to the archive's contents are only permitted to one client at a time.
 */

            || exportedPackages.contains(packageNameOf(originalClassName));
    }

    /**
     * Extracts an API class from a given original class.
     *
     * @param originalClassReader the reader containing the original class
     * @return bytecode of the API class extracted from the original class. Returns {@link Optional#empty()} when class should not be included, due to some reason that is not known until visited.

    }

    /**
     * The file to extract debug symbols from.
     */
    @InputFile
    @PathSensitive(PathSensitivity.NONE)
    public RegularFileProperty getBinaryFile() {
        return binaryFile;
    }

    /**
     * The destination file to extract debug symbols into.
     */
    @OutputFile
    public RegularFileProperty getSymbolFile() {

        writeOnly.getters.size() == 0
        writeOnly.setters.size() == 1
    }

    def "extracts property names"() {
        expect:
        def details = ClassInspector.inspect(PropNames)

        details.propertyNames == ['class', 'metaClass', 'a', 'b', 'URL', 'url', '_A'] as Set
    }

    def "extracts properties of a Groovy interface"() {
        expect:
        def details = ClassInspector.inspect(SomeInterface)

// extract identities from the SAN extension.
func ExtractIDs(exts []pkix.Extension) ([]string, error) {
	sanExt := ExtractSANExtension(exts)
	if sanExt == nil {
		return nil, fmt.Errorf("the SAN extension does not exist")
	}

	idsWithType, err := ExtractIDsFromSAN(sanExt)
	if err != nil {
		return nil, fmt.Errorf("failed to extract identities from SAN extension (error %v)", err)
	}

	Bugs []string

	// declarations
	Consts []*Value
	Types  []*Type
	Vars   []*Value
	Funcs  []*Func

	// Examples is a sorted list of examples associated with
	// the package. Examples are extracted from _test.go files
	// provided to NewFromFiles.
	Examples []*Example

	importByName map[string]string
	syms         map[string]bool
}

import java.beans.Introspector
import java.util.concurrent.CopyOnWriteArraySet

class DefaultModelSchemaStoreTest extends ConcurrentSpec {
    def extractor = DefaultModelSchemaExtractor.withDefaultStrategies()
    def store = new DefaultModelSchemaStore(extractor)

    def "caches schema for a type"() {
        // intentionally use two different “instances” of the same type
        def type1 = ModelType.of(SimpleManagedType)

For the p command, each file is prefixed by the name on a line by itself.
For the t command, the listing includes additional file metadata.
For the x command, names are printed as files are extracted.
*/

// validatingAdmissionPolicy must be a unmodified ValidatingAdmissionPolicy API object that was retrieved from the Kubernetes API.
// ExtractValidatingAdmissionPolicy provides a way to perform a extract/modify-in-place/apply workflow.
// Note that an extracted apply configuration will contain fewer fields than what the fieldManager previously
// applied if another fieldManager has updated or force applied any of the previously applied fields.
// Experimental!