return 0
	}

	stats.RLock()
	defer stats.RUnlock()

	val, ok := stats.apiStats[api]
	if ok {
		return val
	}

	return 0
}

// Load returns the recorded stats.
func (stats *HTTPAPIStats) Load(toLower bool) map[string]int {
	if stats == nil {
		return map[string]int{}
	}

	stats.RLock()
	defer stats.RUnlock()

		TLSCertFile: tlsCert,
		TLSKeyFile:  tlsKey,
	}

	return server, server.Start()
}

// Start starts the mock server.
func (ms *MockOpenIDDiscoveryServer) Start() error {
	var handler http.Handler
	router := mux.NewRouter()
	router.HandleFunc("/.well-known/openid-configuration", ms.openIDCfg).Methods("GET")
	router.HandleFunc("/oauth2/v3/certs", ms.jwtPubKey).Methods("GET")
	handler = router
	if ms.timeout != 0 {

	// Collect information about the task.
	var startStack, endStack trace.Stack
	var startG, endG trace.GoID
	startTime, endTime := ctx.startTime, ctx.endTime
	if task.Start != nil {
		startStack = task.Start.Stack()
		startG = task.Start.Goroutine()
		startTime = task.Start.Time()
	}
	if task.End != nil {
		endStack = task.End.Stack()
		endG = task.End.Goroutine()

These functions can be declared with `async def` or normal `def`.

### `startup` event

To add a function that should be run before the application starts, declare it with the event `"startup"`:

```Python hl_lines="8"
{!../../../docs_src/events/tutorial001.py!}
```

// other packages.
type traceKey struct{}

type traceContext struct {
	t   *tracer
	tid uint64
}

// Start starts a trace which writes to the given file.
func Start(ctx context.Context, file string) (context.Context, func() error, error) {
	traceStarted.Store(true)
	if file == "" {
		return nil, nil, errors.New("no trace file supplied")
	}

            assert operationState.is(operationStateUnderTest)
        }

        where:
        defaultParent << [null, operation("parent")]
    }

    def "fires events when non-wrap-around start operation starts and finishes successfully"() {
        setup:
        def details = Mock(Object)
        def operationDetailsBuilder = displayName("<some-operation>").name("<op>").progressDisplayName("<some-op>").details(details)

package org.gradle.internal.logging;

public interface StandardOutputCapture {
    /**
     * Starts redirection of System.out and System.err to the Gradle logging system.
     *
     * @return this
     */
    StandardOutputCapture start();

    /**
     * Restores System.out and System.err to the values they had before {@link #start()} has been called.
     *
     * @return this
     */
    StandardOutputCapture stop();

                ${server.callFromBuild("pending")}
            } as ${PendingChangesListener.canonicalName})

            task work(type: SimpleTask)
        """

        file("input.txt").text = "start"
    }

    def "build only starts when gate is opened"() {
        server.expect(server.get("command").send("close"))
        def command = server.expectAndBlock(server.get("command").send("open"))

public interface StandardOutputRedirector {

    /**
     * Starts redirection of System.out and System.err to the listener attached to
     * {@link #redirectStandardErrorTo(OutputListener)} and
     * {@link #redirectStandardOutputTo(OutputListener)
     */
    void start();

    /**
     * Restores System.out and System.err to the values they had before {@link #start()} has been called.
     */
    void stop();

    /**
     * Collects whatever state is required the given process. Should not start work.
     */
    void connectStreams(Process process, String processName, Executor executor);

    /**
     * Starts reading/writing/whatever the process' streams. May block until the streams reach some particular state, e.g. indicate that the process has started successfully.
     */
    void start();

    /**