assert testDiv != null
        def counter = testDiv.select("div.counter")
        assert counter != null
        assert counter.text() == tests as String
    }

    void assertHasFailures(int tests) {
        def testDiv = content.select("div#failures")
        assert testDiv != null
        def counter = testDiv.select("div.counter")
        assert counter != null
        assert counter.text() == tests as String
    }

public class JacocoLimitImpl implements JacocoLimit {

    private String counter = "INSTRUCTION";
    private String value = "COVEREDRATIO";
    private BigDecimal minimum;
    private BigDecimal maximum;

    @Override
    public String getCounter() {
        return counter;
    }

    @Override
    public void setCounter(String counter) {
        this.counter = counter;
    }

    @Override
    public String getValue() {

| `minio_api_requests_rejected_auth_total`       | `counter` | Total number of requests rejected for auth failure      | `type,pool_index,server`         |
| `minio_api_requests_rejected_header_total`     | `counter` | Total number of requests rejected for invalid header    | `type,pool_index,server`         |

int uniqueOpCount = 0
int uniqueExcludeCount = 0

Map<String, Counter> opCounters = [:].withDefault { new Counter(uniqueOpCount++) }
Map<String, Counter> excludeCounters = [:].withDefault { new Counter(uniqueExcludeCount++) }

class Counter {
    final int id
    Counter(int id) { this.id = id}

    int counter = -1

    void inc() {
        counter++
    }

    String getFormattedId() {

	// with a four-byte big-endian counter starting at one, is used
	// directly as the starting counter. For other nonce sizes, the counter
	// is computed by passing it through the GHASH function.
	var counter gcmCount
	if len(nonce) == gcmStandardNonceSize {
		copy(counter[:], nonce)
		counter[gcmBlockSize-1] = 1
	} else {
		var hash [16]byte
		g.paddedGHASH(&hash, nonce)
		lens := gcmLengths(0, uint64(len(nonce))*8)

                    def counter = parameters.counter
                    println "Transforming \${input.name} to \${output.name}"
                    output.withWriter { out ->
                        out.println String.valueOf(counter.getCount())
                        for (int i = 0; i < 4; i++) {
                            out.println String.valueOf(counter.increment())
                        }

	noCopy noCopy

	state atomic.Uint64 // high 32 bits are counter, low 32 bits are waiter count.
	sema  uint32
}

// Add adds delta, which may be negative, to the [WaitGroup] counter.
// If the counter becomes zero, all goroutines blocked on [WaitGroup.Wait] are released.
// If the counter goes negative, Add panics.
//
// Note that calls with a positive delta that occur when the counter is zero

that have terminated but the job controller hasn't yet accounted for in the status counters.\n\nThe job controller creates pods with a finalizer. When a pod terminates (succeeded or failed), the controller does three steps to account for it in the job status:\n\n1. Add the pod UID to the arrays in this field. 2. Remove the pod finalizer. 3. Remove the pod UID from the arrays while increasing the corresponding\n    counter.\n\nOld jobs might not be tracked using this field, in which case the field remains...

    }

    def "read runs after queued writes are processed"() {
        given:
        def counter = 0
        start(cacheAccessWorker)

        when:
        cacheAccessWorker.enqueue { ++counter }
        cacheAccessWorker.enqueue { ++counter }
        def result = cacheAccessWorker.read { counter }

        then:
        result == 2

        cleanup:
        cacheAccessWorker?.stop()
    }

}

// avoid parsing count files multiple times
type parsedCache struct {
	mu sync.Mutex
	m  map[string]*counter.File
}

func (u *uploader) parseCountFile(fname string) (*counter.File, error) {
	u.cache.mu.Lock()
	defer u.cache.mu.Unlock()
	if u.cache.m == nil {
		u.cache.m = make(map[string]*counter.File)
	}
	if f, ok := u.cache.m[fname]; ok {
		return f, nil
	}
	buf, err := os.ReadFile(fname)
	if err != nil {