when:
        runTask { withSystemProperties('unrelated' : 'value') }

        then:
        hasNoSystemProperty('mySystemProperty')
    }

    def "Calling withSystemProperties(null) resets to default behavior"() {
        when:
        runTask {
            withSystemProperties('unrelated' : 'value')
            withSystemProperties(null)
        }

        then:

// Add adds an [Error] with given position and error message to an [ErrorList].
func (p *ErrorList) Add(pos token.Position, msg string) {
	*p = append(*p, &Error{pos, msg})
}

// Reset resets an [ErrorList] to no errors.
func (p *ErrorList) Reset() { *p = (*p)[0:0] }

// [ErrorList] implements the sort Interface.
func (p ErrorList) Len() int      { return len(p) }
func (p ErrorList) Swap(i, j int) { p[i], p[j] = p[j], p[i] }

        color = map.getColourFor(Style.FailureHeader)
        color.on(ansi)

        then:
        1 * ansi.fg(Color.MAGENTA)
        1 * ansi.a(Attribute.ITALIC)

        when: 'That color is turned off, it resets to default'
        color.off(ansi)

        then:
        1 * ansi.fg(Color.DEFAULT)
        1 * ansi.a(Attribute.ITALIC_OFF)

        when: 'A Style is overridden with a compound property'

        when:
        createLock(lockMode, file, manager2)

        then:
        thrown(LockTimeoutException)

        where:
        lockMode << [Exclusive, Shared]
    }

    def "lock manage resets the timeout if the lock owner changes"() {
        given:
        FileLockContentionHandler contentionHandler3 = Mock(FileLockContentionHandler)

// Clock returns the clock.
func (m *DialMetrics) Clock() clock.Clock {
	return m.clock
}

// SetClock sets the clock.
func (m *DialMetrics) SetClock(c clock.Clock) {
	m.clock = c
}

// Reset resets the metrics.
func (m *DialMetrics) Reset() {
	m.starts.Reset()
	m.latencies.Reset()
	m.failures.Reset()
}

// ObserveDialStart records the start of a dial attempt, labeled by protocol, transport.

// test them specifically.
type TestFieldManager interface {
	// APIVersion of the object that we're tracking.
	APIVersion() string
	// Reset resets the state of the liveObject by resetting it to an empty object.
	Reset()
	// Live returns a copy of the current liveObject.
	Live() runtime.Object
	// Apply applies the given object on top of the current liveObj, for the
	// given manager and force flag.

// total space allocated for the string being built and includes any bytes
// already written.
func (b *Builder) Cap() int { return cap(b.buf) }

// Reset resets the [Builder] to be empty.
func (b *Builder) Reset() {
	b.addr = nil
	b.buf = nil
}

// grow copies the buffer to a new, larger buffer so that there are at least n
// bytes of capacity beyond len(b.buf).
func (b *Builder) grow(n int) {

	stopTimer((*Timer)(unsafe.Pointer(t)))
}

// Reset stops a ticker and resets its period to the specified duration.
// The next tick will arrive after the new period elapses. The duration d
// must be greater than zero; if not, Reset will panic.
func (t *Ticker) Reset(d Duration) {
	if d <= 0 {
		panic("non-positive interval for Ticker.Reset")
	}
	if !t.initTicker {
		panic("time: Reset called on uninitialized Ticker")
	}

            assert param.settings.is(ivySettings)
            assert IvyContext.context.ivy.is(ivy)
        }

        and:
        IvyContext.currentStack.empty()
    }

    def "resets Ivy settings on reuse"() {
        given:
        def action1 = Mock(Action)
        def action2 = Mock(Action)
        def ivy
        def ivySettings

        when:
        manager.withIvy(action1)

	}
	r.i += int64(m)
	n = int64(m)
	if m != len(s) && err == nil {
		err = io.ErrShortWrite
	}
	return
}

// Reset resets the [Reader] to be reading from s.
func (r *Reader) Reset(s string) { *r = Reader{s, 0, -1} }

// NewReader returns a new [Reader] reading from s.
// It is similar to [bytes.NewBufferString] but more efficient and non-writable.