//
// As it stands now, a "v1" checkpoint contains data for types like the resourcev1alpha2.ResourceHandle
// which may change over time as new fields get added in a backward-compatible way (not unusual
// for API types). That breaks checksuming with pkg/util/hash because it is based on spew output.
// That output includes those new fields.

func TestCheckpointGetOrCreate(t *testing.T) {
	testCases := []struct {

   * {@code <A>} using our implementation unless some of its bounds have changed in resolution. This
   * avoids creating unequal TypeVariable implementation unnecessarily. When the bounds do change,
   * however, it's fine for the synthetic TypeVariable to be unequal to any native TypeVariable
   * anyway.
   */
  static final class NativeTypeVariableEquals<X> {
    static final boolean NATIVE_TYPE_VARIABLE_ONLY =

    }

    private getTomlPath(String name) {
        def tomlResource = getClass().getResource("/org/gradle/api/internal/catalog/parser/${name}.toml").toURI()
        // Paths might be unusual, but we need it because of 1.8
        Paths.get(tomlResource)
    }

    @CompileStatic
    private static class DependencySpec {
        private final DependencyModel model

	runtime.GC()
}

//go:noinline
func escape(x any) { sink2 = x; sink2 = nil }

var sink2 any

// Test zombie object detection and reporting.
func GCZombie() {
	// Allocate several objects of unusual size (so free slots are
	// unlikely to all be re-allocated by the runtime).
	const size = 190
	const count = 8192 / size
	keep := make([]*byte, 0, (count+1)/2)
	free := make([]uintptr, 0, (count+1)/2)

When Go code is built with options like -buildmode=c-shared, it will
be run as part of an existing non-Go program. The non-Go code may
have already installed signal handlers when the Go code starts (that
may also happen in unusual cases when using cgo or SWIG; in that case,
the discussion here applies).  For -buildmode=c-archive the Go runtime
will initialize signals at global constructor time.  For

   * {@code <A>} using our implementation unless some of its bounds have changed in resolution. This
   * avoids creating unequal TypeVariable implementation unnecessarily. When the bounds do change,
   * however, it's fine for the synthetic TypeVariable to be unequal to any native TypeVariable
   * anyway.
   */
  static final class NativeTypeVariableEquals<X> {
    static final boolean NATIVE_TYPE_VARIABLE_ONLY =

 *
 * <ul>
 *   <li>{@link ImmutableListMultimap}
 *   <li>{@link ImmutableSetMultimap}
 *   <li>Configure your own mutable multimap with {@link MultimapBuilder}
 *   <li>{@link LinkedListMultimap} (for one unusual kind of mutable {@code Multimap})
 * </ul>
 *
 * Guava contains a number of other multimap implementations, such as {@link ArrayListMultimap}. In

func sameStringSlice(a []string, b []string) bool {
	if len(a) != len(b) {
		return false
	}
	for i := range a {
		if a[i] != b[i] {
			return false
		}
	}
	return true
}

// This is an unusual case.  Service has a number of inter-related fields and
// in order to avoid breaking clients we try really hard to infer what users
// mean when they change them.
//

 *
 * <ul>
 *   <li>{@link ImmutableListMultimap}
 *   <li>{@link ImmutableSetMultimap}
 *   <li>Configure your own mutable multimap with {@link MultimapBuilder}
 *   <li>{@link LinkedListMultimap} (for one unusual kind of mutable {@code Multimap})
 * </ul>
 *
 * Guava contains a number of other multimap implementations, such as {@link ArrayListMultimap}. In

                public SneakyWorkAction() { }

                public void execute() {
                    super.execute()
                    // These classes were chosen to be relatively stable and would be unusual to see in a worker.
                    def gradleApiClasses = [
                        "${com.google.common.collect.Lists.canonicalName}",
                    ]