}
	mergeKeyRight, ok := typedRight[mergeKey]
	if !ok {
		return false, mergepatch.ErrNoMergeKey(typedRight, mergeKey)
	}
	return mergeKeyLeft == mergeKeyRight, nil
}

// extractKey trims the prefix and return the original key
func extractKey(s, prefix string) (string, error) {
	substrings := strings.SplitN(s, "/", 2)
	if len(substrings) <= 1 || substrings[0] != prefix {
		switch prefix {

            }
        '''

        when:
        def clazz = api.classes.A
        def extracted = api.extractAndLoadApiClassFrom(clazz)

        then:
        clazz.clazz.getDeclaredMethod('foo').modifiers == Modifier.PUBLIC
        hasMethod(extracted, 'foo')

        when:
        def o = createInstance(extracted)
        o.foo()

        then:
        def e = thrown(Exception)

        waiting.releaseAll()
        // wait for the first extracter to start extracting
        firstExtracter.waitForAllPendingCalls()

        // If we've made it here successfully, then no concurrent extracts have been seen
        def secondExtracter = server.expectAndBlock("extract")
        // release the first extracter so it can finish
        firstExtracter.releaseAll()
        // wait for the next one

	sr.ReturnNonDecryptable(true)

	// Debug corrupted streams.
	if false {
		sr.SkipEncrypted(true)
		return sr.DebugStream(os.Stdout)
	}
	extracted := false
	for {
		stream, err := sr.NextStream()
		if err != nil {
			if err == io.EOF {
				if extracted {
					return nil
				}
				return errors.New("no data found on stream")
			}
			if errors.Is(err, estream.ErrNoKey) {
				if stream.Name == "inspect.zip" {

    /**
     * Retrieve the file that contains the extracted class file.
     *
     * <p>
     * This method will extract the class file if it is
     * not extracted yet. Extracted class files are deleted on exit of the Gradle process. The same class is only
     * extracted once.
     * </p>
     *
     * @param className Name of the class to extract.
     * @return File that contains the extracted class file.
     */

    // An outside compiled op can be extracted if its operands are not from
    // other ops in the cluster that cannot be extracted.

    // Check if the side effecting op right before this side effecting op, if
    // it is side effecting, can be head extracted. Because of op ordering due
    // to side effects, if this is not true, this op cannot be head extracted.

            def initialSize = ruleCache.size()
            gradle.buildFinished { println "### extracted new rules: \${ruleCache.size() > initialSize}" }
        """
    }

    boolean getNewRulesExtracted() {
        def match = output =~ /.*### extracted new rules: (true|false).*/
        match[0][1] == "true"
    }

    def "rules extracted from core plugins are reused across builds"() {
        given:
        buildFile << '''

 * The exposed transformer typically gathers the data while transforming.
 * <p>
 * As these objects are stateful, they can only be used for a single compile operation.
 *
 * @param <T> the type of data extracted by this operation
 */
public interface CompileOperation<T> {

    /**
     * A unique id for this operations.
     * <p>

 */

package org.gradle.api.internal.file.archive;

import java.io.Closeable;
import java.io.File;

/**
 * A coordinator that can be used to manage access to decompressed data extracted from archive files like zip and tars.
 *
 * <p>
 * For a given build tree, only a single process is allowed write access to extract archives at a time.
 *

package importC

import "C"
import _ /* ERROR `cannot rename import "C"` */ "C"
import foo /* ERROR `cannot rename import "C"` */ "C"
import . /* ERROR `cannot rename import "C"` */ "C"

// Test cases extracted from issue #22090.

import "unsafe"

const _ C.int = 0xff // no error due to invalid constant type

type T struct {
	Name    string
	Ordinal int
}

func _(args []T) {
	var s string