import (
	"context"
	"os"

	"go.uber.org/atomic"
)

// SetForTest sets a variable for the duration of a test, then resets it once the test is complete.
func SetForTest[T any](t Failer, vv *T, v T) {
	old := *vv
	*vv = v
	t.Cleanup(func() {
		*vv = old
	})
}

// SetEnvForTest sets an environment variable for the duration of a test, then resets it once the test is complete.
func SetEnvForTest(t Failer, k, v string) {

        when:
        version.reject('1.0.1', '1.0.2')

        then:
        version.requiredVersion == '1.0'
        version.rejectedVersions == ['1.0.1', '1.0.2']
    }

    def "calling 'prefers' resets the list of rejects"() {
        given:
        def version = new DefaultMutableVersionConstraint('1.0')
        version.reject('1.0.1')

        when:
        version.prefer('1.1')

        then:

 */
public interface LoggingSystem {
    /**
     * Snapshots the current configuration state of this logging system.
     */
    Snapshot snapshot();

    /**
     * Resets this logging system to some previous configuration state.
     */
    void restore(Snapshot state);

    interface Snapshot {
    }

 * test expectations before cleanup so they can be silenced if necessary.
 */
public interface ResettableExpectations {
    /**
     * Resets all pending expectations after verifying them.
     * Must throw when a verification fails.
     */
    void resetExpectations();

	}
}

type timerWrapper struct {
	timer   clock.Timer
	resets  []time.Duration
	onReset func(d time.Duration)
}

func (w *timerWrapper) C() <-chan time.Time { return w.timer.C() }
func (w *timerWrapper) Stop() bool          { return w.timer.Stop() }
func (w *timerWrapper) Reset(d time.Duration) bool {
	w.resets = append(w.resets, d)
	b := w.timer.Reset(d)
	if w.onReset != nil {
		w.onReset(d)
	}
	return b

	err          error
	scratch      [4]byte
}

// Resetter resets a ReadCloser returned by [NewReader] or [NewReaderDict]
// to switch to a new underlying Reader. This permits reusing a ReadCloser
// instead of allocating a new one.
type Resetter interface {
	// Reset discards any buffered data and resets the Resetter as if it was
	// newly initialized with the given reader.
	Reset(r io.Reader, dict []byte) error
}

     */
    void configurationAvailable(BuildCacheConfigurationInternal configuration);

    /**
     * Resets the state of this controller in preparation for loading configuration from the cache.
     */
    void resetState();

	register()
	c.Handle("/metrics", legacyregistry.Handler())
}

// MetricsWithReset install the prometheus metrics handler extended with support for the DELETE method
// which resets the metrics.
type MetricsWithReset struct{}

// Install adds the MetricsWithReset handler
func (m MetricsWithReset) Install(c *mux.PathRecorderMux) {
	register()
	c.Handle("/metrics", legacyregistry.HandlerWithReset())

	"cmd/go/internal/modload"
	"context"
)

var cmdVendor = &base.Command{
	UsageLine: "go work vendor [-e] [-v] [-o outdir]",
	Short:     "make vendored copy of dependencies",
	Long: `
Vendor resets the workspace's vendor directory to include all packages
needed to build and test all the workspace's packages.
It does not include test code for vendored packages.

The -v flag causes vendor to print the names of vendored

func (m *validationMetrics) ObserveRatchetingTime(d time.Duration) {
	m.RatchetingTime.Observe(d.Seconds())
}

// Reset resets the metrics. This is meant to be used for testing. Panics
// if the metrics cannot be re-registered. Returns all the reset metrics
func (m *validationMetrics) Reset() []metrics.Registerable {
	m.RatchetingTime = metrics.NewHistogram(m.RatchetingTime.HistogramOpts)
	return []metrics.Registerable{m.RatchetingTime}