buildFile.text = "task log { doLast { println 'counter: __' } }"
        int before = buildFile.length()

        expect:
        (10..40).each {
            buildFile.text = "task log { doLast { println 'counter: $it' } }"
            assert buildFile.length() == before

            succeeds('log')
            result.assertOutputContains("counter: $it")
        }
    }

	}

	commandSet := sets.New(fcmd.CombinedOutputLog[1]...)
	if !commandSet.HasAll(iptablesRestoreCmd, "-T", string(TableNAT), "--counters") || commandSet.HasAny("--noflush") {
		t.Errorf("%s flush, restore: Expected cmd containing '%s -T %s --counters', got '%s'", protocol, iptablesRestoreCmd, string(TableNAT), fcmd.CombinedOutputLog[1])
	}

	// FlushTables, NoRestoreCounters

	return r.hdr.Entries
}

// CounterMode returns the counter mode (set, count, atomic) used
// when building for coverage for the program that produce this
// meta-data file.
func (r *CoverageMetaFileReader) CounterMode() coverage.CounterMode {
	return r.hdr.CMode
}

// CounterGranularity returns the counter granularity (single counter per
// function, or counter per block) selected when building for coverage

        given:
        buildFile """
            Integer counter = 0
            def provider = providers.provider { ++counter }

            def property = objects.property(Integer)
            property.set(provider)

            assert property.get() == 1
            assert property.get() == 2

            property.finalizeValue()

            assert counter == 3 // is eager
            assert property.get() == 3

		err             error
		counterIncrease bool
	}{
		{
			name:     "no error, resp w/ cert, no counter increase",
			checkers: []deprecatedCertificateAttributeChecker{&testNegativeChecker{counterRaiser{testCounter, "", ""}}},
			resp:     httpResponseWithCert(),
		},
		{
			name:     "no error, resp w/o cert, no counter increase",

    # TYPE apiserver_encryption_config_controller_automatic_reload_failures_total counter
    apiserver_encryption_config_controller_automatic_reload_failures_total {apiserver_id_hash="sha256:14f9d63e669337ac6bfda2e2162915ee6a6067743eddd4e5c374b572f951ff37"} 1

		ps.funcTable = make(map[fnfile]uint32)
	}
	fm.p = ps
}

// AddUnit passes info on a single coverable unit (file, funcname,
// literal flag, range of lines, and counter value) to the formatter.
// Counter values will be accumulated where appropriate.
func (fm *Formatter) AddUnit(file string, fname string, isfnlit bool, unit coverage.CoverableUnit, count uint32) {
	if fm.p == nil {

	tests := []struct {
		name                      string
		requestURI                string
		requestInfo               *apirequest.RequestInfo
		counts                    map[string]int64
		countErr                  error
		watchCount                int
		maxSeats                  uint64
		initialSeatsExpected      uint64
		finalSeatsExpected        uint64
		additionalLatencyExpected time.Duration
	}{
		{

			Help:           "Counter of events dispatched in watch cache broken by resource type.",
			StabilityLevel: compbasemetrics.ALPHA,
		},
		[]string{"resource"},
	)

	TerminatedWatchersCounter = compbasemetrics.NewCounterVec(
		&compbasemetrics.CounterOpts{
			Namespace:      namespace,
			Name:           "terminated_watchers_total",

import org.gradle.process.internal.worker.RequestHandler;

public class StatefulTestWorker implements RequestHandler<String, String> {
    int counter;

    @Override
    public String run(String request) {
        return request + ":" + (++counter);
    }