// respective 64 bit atomic instructions are not available
// on all platforms.
var lastID atomic.Uint32

// nextID returns a value increasing monotonically by 1 with
// each call, starting with 1. It may be called concurrently.
func nextID() uint64 { return uint64(lastID.Add(1)) }

// A TypeParam represents a type parameter type.
type TypeParam struct {
	check *Checker  // for lazy type bound completion

    def "can group output from custom test listener with task"() {
        buildFile << """
            test {
                beforeTest { descriptor ->
                    logger.quiet 'Starting test: ' + descriptor.className + ' > ' + descriptor.name
                }
                afterTest { descriptor, result ->
                    logger.quiet 'Finishing test: ' + descriptor.className + ' > ' + descriptor.name

# Default to Global in the root package.
# application.global=Global

# Router
# ~~~~~
# Define the Router object to use for this application.
# This router will be looked up first when the application is starting up,
# so make sure this is the entry point.
# Furthermore, it's assumed your route file is named properly.
# So for an application router like `conf/my.application.Router`,

time kubectl run -i --rm --restart=Never dummy --image=dockerqa/curl:ubuntu-trusty --command -- curl --silent httpbin:8000/delay/5
```

You can also test the httpbin service by starting the [sleep service](../sleep) and calling httpbin from it.

A third option is to access the service from the outside of the mesh through an Ingress Gateway.

    public void start() {
        if (processStdOutput == null) {
            throw new IllegalStateException("Cannot start consuming daemon output because streams have not been connected first.");
        }
        LOGGER.debug("Starting consuming the daemon process output.");

        // Wait for the process' stdout to indicate that the process has been started successfully
        StringWriter output = new StringWriter();

// It then communicates with the container runtime (or a CRI shim for the runtime) to see what is
// currently running.  It synchronizes the configuration data, with the running set of containers
// by starting or stopping containers.
package main

import (
	"os"

	"k8s.io/component-base/cli"
	_ "k8s.io/component-base/logs/json/register"          // for JSON log format registration

- [ ] Ensure that tests pass sanity check: `./gradlew sanityCheck`.
- [ ] Ensure that tests pass locally: `./gradlew <changed-subproject>:quickTest`.

### Reviewing cheatsheet

Before merging the PR, comments starting with 
- ❌ ❓**must** be fixed
- 🤔 💅 **should** be fixed
- 💭 **may** be fixed

import groovy.json.JsonOutput;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class ExecutionGraph {
    // Execution 1,2,3, starting from 1
    int index;
    String title;
    List<Line> data;

    public ExecutionGraph(int index, Line... lines) {
        this.index = index;
        this.title = "Execution " + index + " (ms)";

	c.eventHandlers = append(c.eventHandlers, handler)
}

// Run waits for cache synced and invokes handlers after syncing.
func (c *EndpointSliceConfig) Run(stopCh <-chan struct{}) {
	c.logger.Info("Starting endpoint slice config controller")

	if !cache.WaitForNamedCacheSync("endpoint slice config", stopCh, c.listerSynced) {
		return
	}

	for _, h := range c.eventHandlers {

	"go/token"
	"reflect"
	"strconv"
	"strings"
	"testing"
)

func TestImportGroupStarts(t *testing.T) {
	for _, test := range []struct {
		name string
		in   string
		want []string // paths of group-starting imports
	}{
		{
			name: "one group",
			in: `package p
import (
	"a"
	"b"
	"c"
	"d"
)
`,
			want: []string{"a"},
		},
		{
			name: "several groups",
			in: `package p
import (