metadata.compatibility == LEGACY
        metadata.visualCppDir == new File(dir2, "VC")
        metadata.visualCppVersion == VersionNumber.parse("12.0")
        metadata.version == VersionNumber.parse("12.0")

        where:
        compilerPath              | platform
        "VC/bin/cl.exe"           | "x86"
        "VC/bin/x86_amd64/cl.exe" | "x64"
    }

        1 * windowsRegistry.getStringValue(_, foundIn, "12.0") >> dir2.createDir("VC").absolutePath
        1 * windowsRegistry.getStringValue(_, foundIn, "11.0") >> dir3.createDir("VC").absolutePath

        and:
        metadata.size() == 3
        metadata[0].installDir == dir1
        metadata[0].visualCppDir == new File(dir1, "VC")

	vc, err := sys.Get(bucket)
	if err != nil {
		logger.CriticalIf(GlobalContext, err)
	}
	return vc.PrefixEnabled(prefix)
}

// Suspended suspended versioning?
func (sys *BucketVersioningSys) Suspended(bucket string) bool {
	vc, err := sys.Get(bucket)
	if err != nil {
		logger.CriticalIf(GlobalContext, err)
	}
	return vc.Suspended()
}

import java.util.SortedMap;

public class SortedMapDiffUtil {

    private SortedMapDiffUtil() {}

    public static <K, VP, VC> boolean diff(SortedMap<K, ? extends VP> previous, SortedMap<K, ? extends VC> current, PropertyDiffListener<K, VP, VC> diffListener) {
        Iterator<? extends Map.Entry<K, ? extends VC>> currentEntries = current.entrySet().iterator();

import javax.annotation.Nullable;
import java.util.Comparator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;

public class VirtualPlatformState {
    private final Comparator<String> vC;
    private final ModuleResolveState platformModule;
    private final ResolveOptimizations resolveOptimizations;

    private final Set<ModuleResolveState> participatingModules = new LinkedHashSet<>();

        _ * visualCppMetadataProvider.getVisualCppFromMetadataFile(_) >> { args -> visualCppMetadata(new File(args[0], "VC/Tools/MSVC/1.2.3.4"), "1.2.3.4") }
        _ * visualCppMetadataProvider.getVisualCppFromRegistry(_) >> { args -> visualCppMetadata(localRoot.createDir("Program Files/Microsoft Visual Studio ${args[0]}/VC"), args[0]) }
    }

    void invalidLegacyInstallations() {

// during constraint type inference.
func f4[M4 map[K4]int, K4 comparable](m4 M4) {}

func f5[M5 map[K5]int, K5 comparable](m5 M5) {
	f4(m5)
}

// test case from issue

func Copy[MC ~map[KC]VC, KC comparable, VC any](dst, src MC) {
	for k, v := range src {
		dst[k] = v
	}
}

func Merge[MM ~map[KM]VM, KM comparable, VM any](ms ...MM) MM {
	result := MM{}
	for _, m := range ms {
		Copy(result, m)
	}

		// create injection parameters
		IP := InjectionParameters{}
		err := ff.GenerateStruct(&IP)
		if err != nil {
			return
		}
		if IP.pod == nil {
			return
		}
		vc, err := NewValuesConfig(v)
		if err != nil {
			return
		}
		IP.valuesConfig = vc

		// call RunTemplate()
		_, _, _ = RunTemplate(IP)
	})

        version(alias, vc -> {
            if (richVersion.require != null) {
                vc.require(richVersion.require);
            }
            if (richVersion.prefer != null) {
                vc.prefer(richVersion.prefer);
            }
            if (richVersion.strictly != null) {
                vc.strictly(richVersion.strictly);
            }
        });

 * limitations under the License.
 */

package org.gradle.internal.execution.history.changes;

public interface PropertyDiffListener<K, VP, VC> {
    boolean removed(K previousProperty);

    boolean added(K currentProperty);

    boolean updated(K property, VP previous, VC current);