t := newTimer(runtimeNano(), 1<<63-1, empty, nil, nil)
	defer t.Stop()

	// If this test fails, we will either throw (when siftdownTimer detects
	// bad when on update), or other timers will hang (if the timer in a
	// heap is in a bad state). There is no reliable way to test this, but
	// we wait on a short timer here as a smoke test (alternatively, timers
	// in later tests may hang).
	<-After(25 * Millisecond)
}

cmpenv go.mod $WORK/go.mod.edit2

# -exclude and -retract reject invalid versions.
! go mod edit -exclude=example.com/m@bad
stderr '^go: -exclude=example.com/m@bad: version "bad" invalid: must be of the form v1.2.3$'
! go mod edit -retract=bad
stderr '^go: -retract=bad: version "bad" invalid: must be of the form v1.2.3$'

! go mod edit -exclude=example.com/m@v2.0.0

        authScheme | credsName | creds
        BASIC      | 'missing' | ''
        DIGEST     | 'missing' | ''
        NTLM       | 'missing' | ''
        BASIC      | 'bad'     | badCredentials
        DIGEST     | 'bad'     | badCredentials
        NTLM       | 'bad'     | badCredentials
    }

    def "reports failure resolving with #credsName credentials from #authScheme authenticated HTTP maven repository"() {
        given:

            public class MyASTTransformation extends AbstractASTTransformation {
                @Override
                public void visit(ASTNode[] nodes, SourceUnit source) {
                    assert false: "Bad AST transformation!"
                }
                public void foo() {}
            }
        """
    }

    private String astTransformationDeclaration() {
        """
            project(':b') {

		},
		{
			name:            "invalid: valid config but bad manifest path",
			cfgPath:         testUpgradeDiffConfig,
			setManifestPath: true,
			manifestPath:    "bad-path",
			expectedError:   true,
		},
		{
			name:          "invalid: badly formatted version as argument",
			cfgPath:       testUpgradeDiffConfig,
			args:          []string{"bad-version"},
			expectedError: true,
		},
	}

			optValue, err := strconv.ParseBool(value)
			if err != nil {
				return opts, fmt.Errorf("bad value for option %q: %w", name, err)
			}
			opts.FullPhysicalCPUsOnly = optValue
		case DistributeCPUsAcrossNUMAOption:
			optValue, err := strconv.ParseBool(value)
			if err != nil {
				return opts, fmt.Errorf("bad value for option %q: %w", name, err)
			}
			opts.DistributeCPUsAcrossNUMA = optValue

		}
	}
	if r.Len(false) != len(keys) {
		t.Fatalf("bad len: %v %v", r.Len(false), len(keys))
	}

	expected := []string{
		"10.0.0.0/8",
		"192.168.0.0/20",
		"172.16.0.0/12",
	}
	parents := r.TopLevelPrefixes(false)
	if len(parents) != len(expected) {
		t.Fatalf("bad len: %v %v", len(parents), len(expected))
	}

	for _, k := range expected {

go version
stderr 'go: downloading go1.999testmod \(.*/.*\)'

# GOTOOLCHAIN cached from network
go version
! stderr downloading
stdout go1.999testmod

# GOTOOLCHAIN with GOSUMDB enabled but at a bad URL should operate in cache and not try badurl
env oldsumdb=$GOSUMDB
env GOSUMDB=$oldsumdb' http://badurl'
go version
! stderr downloading
stdout go1.999testmod

			continue
		}
		if len(matches) != 0 {
			t.Errorf("Glob(%#q) = %#v want []", pattern, matches)
		}
	}
}

func TestGlobError(t *testing.T) {
	bad := []string{`[]`, `nonexist/[]`}
	for _, pattern := range bad {
		_, err := Glob(os.DirFS("."), pattern)
		if err != path.ErrBadPattern {
			t.Errorf("Glob(fs, %#q) returned err=%v, want path.ErrBadPattern", pattern, err)
		}
	}
}

	for i := 0; i < b.N; i++ {
		for j := 0; j < 100; j++ {
			if errfn() == io.EOF {
				b.Fatal("bad comparison")
			}
		}
	}
}

func BenchmarkIfaceCmpNil100(b *testing.B) {
	for i := 0; i < b.N; i++ {
		for j := 0; j < 100; j++ {
			if errfn1() == nil {
				b.Fatal("bad comparison")
			}
		}
	}
}

var efaceCmp1 any
var efaceCmp2 any