*
     * <p>Note that the caller must call {@link WorkerLeaseRegistry.WorkerLeaseCompletion#leaseFinish()} to mark the completion of the lease and to release the lease for other threads to use.
     *
     * <p>It is generally better to use {@link WorkerThreadRegistry#runAsWorkerThread(Runnable)} instead of this method.</p>
     */
    WorkerLeaseRegistry.WorkerLeaseCompletion startWorker();

    /**

// on different platforms.
package mmap

import (
	"os"
)

// The backing file is never closed, so Data
// remains valid for the lifetime of the process.
type Data struct {
	// TODO(pjw): might be better to define versions of Data
	// for the 3 specializations
	f    *os.File
	Data []byte
	// Some windows magic
	Windows interface{}
}

// Mmap maps the given file into memory.

import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Attached to a service implementation to indicate that the instance should be registered as a listener.
 *
 * <p>Generally, it is better to use {@link StatefulListener}, which is lazy and applies some validation to ensure no events are missed.
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Inherited
public @interface ListenerService {

Specifically, to see Uvicorn, Starlette and FastAPI compared together (among many other tools).

The simpler the problem solved by the tool, the better performance it will get. And most of the benchmarks don't test the additional features provided by the tool.

The hierarchy is like:

* **Uvicorn**: an ASGI server
    * **Starlette**: (uses Uvicorn) a web microframework

func IsPathSeparator(c uint8) bool {
	return PathSeparator == c
}

// splitPath returns the base name and parent directory.
func splitPath(path string) (string, string) {
	// if no better parent is found, the path is relative from "here"
	dirname := "."

	// Remove all but one leading slash.
	for len(path) > 1 && path[0] == '/' && path[1] == '/' {
		path = path[1:]
	}

	i := len(path) - 1

                // whereas console failure logging based on the _thrown exception_ happens up outside session scope. It would be better to refactor so that a result can be returned from here
                throw UncheckedException.throwAsUncheckedException(t);
            } else {

                // whereas console failure logging based on the _thrown exception_ happens up outside session scope. It would be better to refactor so that a result can be returned from here
                throw UncheckedException.throwAsUncheckedException(t);
            } else {

        }
        performanceTestIdProvider.setTestSpec(runner)
    }

    @Rule
    PerformanceTestIdProvider performanceTestIdProvider = new PerformanceTestIdProvider()

    static {
        // TODO - find a better way to cleanup
        System.addShutdownHook {
            ((Closeable) RESULT_STORE).close()
        }
    }

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This file holds test cases for individual issues
// for which there is (currently) no better location.

package syntax

import (
	"strings"
	"testing"
)

func TestIssue67866(t *testing.T) {
	var tests = []string{
		"package p; var _ = T{@0: 0}",
		"package p; var _ = T{@1 + 2: 0}",

import org.gradle.internal.declarativedsl.language.UnsupportedConstruct


sealed interface DocumentError


data class SyntaxError(val parsingError: ParsingError) : DocumentError // TODO: use a better representation once integration can be done


data class UnsupportedKotlinFeature(val unsupportedConstruct: UnsupportedConstruct) : DocumentError