import org.gradle.internal.execution.history.changes.CompareStrategy.ChangeDetector;
import org.gradle.internal.execution.history.changes.CompareStrategy.ChangeFactory;

import java.util.Map;

/**
 * Compares collections if either current or previous are empty, or both current and previous have one element.
 */
public class TrivialChangeDetector<S> implements ChangeDetector<S> {
    private final ItemComparator<S> itemComparator;

import org.gradle.internal.fingerprint.impl.IgnoredPathFingerprintingStrategy;
import org.gradle.internal.hash.HashCode;

import java.util.Comparator;
import java.util.List;
import java.util.Map;

/**
 * Compares {@link FileCollectionFingerprint}s ignoring the path.
 */
public class IgnoredPathCompareStrategy extends AbstractFingerprintCompareStrategy {

	for key, value := range subset {
		if supersetValue, ok := superset[key]; !ok || supersetValue != value {
			return false
		}
	}
	return true
}

// EqualFunc is like Equal, but compares values using eq.
// Keys are still compared with ==.
func EqualFunc[M1 ~map[K]V1, M2 ~map[K]V2, K comparable, V1, V2 any](m1 M1, m2 M2, eq func(V1, V2) bool) bool {
	return maps.EqualFunc(m1, m2, eq)

                                                                            .put("sp", 6).build();
    /**
     * Compares 2 versions. Algorithm is inspired by PHP version_compare one.
     */
    @Override
    public int compare(Version version1, Version version2) {
        if (version1.equals(version2)) {
            return 0;
        }

        return lastSeparator;
    }

    /**
     * Compares to the first segment of a relative path.
     *
     * A segment of a path is the part between two file separators.
     * For example, the path some/long/path has the segments some, long and path.
     *
     * Similar to {@link #lengthOfCommonPrefix(String, CaseSensitivity)},
     * only that this method compares to the first segment of the path if there is no common prefix.

        when:
        metadata.sort(new JvmInstallationMetadataComparator(getJavaHome()))

        then:
        metadata == [jdk, jre]
    }

    @Issue("https://github.com/gradle/gradle/issues/17195")
    def "compares installation paths as a last resort"() {
        given:
        def prevJdk = jvmMetadata("8.0.1", true, ADOPTOPENJDK, "/jdks/openjdk-8.0.1")
        def nextJdk = jvmMetadata("8.0.1", true, ADOPTOPENJDK, "/jdks/openjdk-8.0.1.1")

    }
    return builder.toString();
  }

  /**
   * Returns a comparator that compares two arrays of unsigned {@code int} values <a
   * href="http://en.wikipedia.org/wiki/Lexicographical_order">lexicographically</a>. That is, it
   * compares, using {@link #compare(int, int)}), the first pair of values that follow any common

    }
    return builder.toString();
  }

  /**
   * Returns a comparator that compares two arrays of unsigned {@code int} values <a
   * href="http://en.wikipedia.org/wiki/Lexicographical_order">lexicographically</a>. That is, it
   * compares, using {@link #compare(int, int)}), the first pair of values that follow any common

import org.gradle.internal.fingerprint.FileSystemLocationFingerprint;

import javax.annotation.Nullable;
import java.util.Iterator;
import java.util.Map;

/**
 * Compares two {@link FileCollectionFingerprint}s representing classpaths.
 *
 * That means that the comparison happens in-order with relative path sensitivity.
 */

// The versions x and y must not begin with a "go" prefix: just "1.21" not "go1.21".
// Malformed versions compare less than well-formed versions and equal to each other.
// The language version "1.21" compares less than the release candidate and eventual releases "1.21rc1" and "1.21.0".
func Compare(x, y string) int {
	return gover.Compare(x, y)
}

// Max returns the maximum of x and y interpreted as toolchain versions,