def compare(String s1, String s2) {
        return comparator.compare(new VersionInfo(versionParser.transform(s1)), new VersionInfo(versionParser.transform(s2)))
    }

    def "numeric parts are compared as numbers"() {
        expect:
        compare(smaller, larger) < 0
        compare(larger, smaller) > 0
        compare(smaller, smaller) == 0
        compare(larger, larger) == 0

        where:

}

// An ifacePair is a node in a stack of interface type pairs compared for identity.
type ifacePair struct {
	x, y *Interface
	prev *ifacePair
}

func (p *ifacePair) identical(q *ifacePair) bool {
	return p.x == q.x && p.y == q.y || p.x == q.y && p.y == q.x
}

// A comparer is used to compare types.
type comparer struct {
	ignoreTags     bool // if set, identical ignores struct tags

import javax.annotation.Nullable;
import java.util.ArrayList;
import java.util.List;

/**
 * Preserves identity of {@see OrdinalGroup} instances so there's a 1-to-1 mapping of ordinals to groups allowing groups
 * to be freely compared by identity.
 */
@ServiceScope(Scope.Build.class)
public class OrdinalGroupFactory {

    private final List<OrdinalGroup> groups = new ArrayList<>();

    public final OrdinalGroup group(int ordinal) {

import org.gradle.internal.service.scopes.ServiceScope;

/**
 * Responsible for calculating a {@link FileCollectionFingerprint} for a {@link org.gradle.api.file.FileCollection} representing a Java classpath. Compared to {@link RelativePathFileCollectionFingerprinter} this fingerprinter orders files within any sub-tree.
 *
 * @see org.gradle.api.tasks.Classpath
 */
@ServiceScope(Scope.UserHome.class)

// Test to make sure that we don't try using larger loads for
// generated equality functions on architectures that can't do
// unaligned loads.

package main

// T has a big field that wants to be compared with larger loads/stores.
// T is "special" because of the unnamed field, so it needs a generated equality function.
// T is an odd number of bytes in size and has alignment 1.
type T struct {
	src [8]byte
	_   byte
}

func Compare(x, y string) int {
	return gover.Compare(x, y)
}

// Max returns the maximum of x and y interpreted as toolchain versions,
// compared using Compare.
// If x and y compare equal, Max returns x.
func Max(x, y string) string {
	return gover.Max(x, y)
}

// IsLang reports whether v denotes the overall Go language version
// and not a specific release. Starting with the Go 1.21 release, "1.x" denotes

    T extends @Nullable Object, A extends @Nullable Object, R extends @Nullable Object> {
  /**
   * Creates a {@code CollectorTester} for the specified {@code Collector}. The result of the {@code
   * Collector} will be compared to the expected value using {@link Object#equals}.
   */
  public static <T extends @Nullable Object, A extends @Nullable Object, R extends @Nullable Object>
      CollectorTester<T, A, R> of(Collector<T, A, R> collector) {

// bad backing store pointers but nonzero length, so we can check that
// the backing store never gets compared.
//
// We use two different bad strings so that pointer comparisons of
// backing store pointers fail.

package main

import (
	"fmt"
	"reflect"
	"syscall"
	"unsafe"
)

type SI struct {
	s string
	i int
}

type SS struct {
	s string
	t string
}

// For instance, I can make a transformation from `object => object.name` to only trigger events for changes to the name;
// the output will be compared (using standard equality checking), and only changes will trigger the handler.
// Note this is in addition to the normal event mechanics, so this can only filter things further.

	fuzz.Fuzz(f, func(fg fuzz.Helper) {
		r := fuzz.Struct[*networking.TrafficPolicy_PortTrafficPolicy](fg)

		// The port does not need to be copied.
		r.Port = nil

		// The type has changed and cannot be compared directly.
		// Convert to []byte for comparison.
		copied := shadowCopyPortTrafficPolicy(r)
		rjs, _ := json.Marshal(r)
		cjs, _ := json.Marshal(copied)
		assert.Equal(fg.T(), rjs, cjs)
	})
}