}

    def "ignores external module jar from runtime ClassLoader"() {
        def classesDir = tmpDir.createDir("some-module/build/classes/java/main")
        def staticResourcesDir = tmpDir.createDir("some-module/src/main/resources")
        def cl = classLoaderFor([externalDependency, classesDir, resourcesDir, staticResourcesDir, externalRuntimeDep])
        def registry = new DefaultModuleRegistry(cl, ClassPath.EMPTY, null)

        expect:

    def "closes services for home dir when another home dir is in use"() {
        def dir1 = new File("home-dir-1")
        def dir2 = new File("home-dir-2")

        given:
        def servicesHomeDir1 = homeDirServices.getServicesFor(dir1)
        def homeDir1Service = servicesHomeDir1.get(SomeHomeDirService)

        when:
        def services1 = homeDirServices.getServicesFor(dir2)

        given:
        def action = Mock(Action)

        when:
        def provider = registerService("service", NoParamsServiceImpl, action)

        then:
        1 * action.execute(_)

        when:
        def service = provider.get()

        then:
        service != null
    }

    def "service can be create without action"() {
        when:

    }

    def "build dependencies are calculated from the artifacts visited during graph resolution"() {
        def configuration = conf()
        def targetTask = Mock(Task)
        def task1 = Mock(Task)
        def task2 = Mock(Task)
        def requiredTasks = [task1, task2] as Set
        def artifactTaskDependencies = Mock(TaskDependency)
        def visitedArtifactSet = Mock(VisitedArtifactSet)

        1 * lock.close()
        0 * _
    }

    def "notifies handler when lock is acquired and released"() {
        def action = Mock(Supplier)
        def onOpen = Mock(Consumer)
        def onClose = Mock(Consumer)
        def lock = Mock(FileLock)
        def signal = Mock(FileLockReleasedSignal)
        Consumer contendedAction

class DependencyGraphBuilderTest extends Specification {
    def conflictResolver = Mock(ModuleConflictResolver)
    def idResolver = Mock(DependencyToComponentIdResolver)
    def metaDataResolver = Mock(ComponentMetaDataResolver)
    def attributesSchema = Mock(AttributesSchemaInternal)
    def attributes = ImmutableAttributes.EMPTY
    def moduleReplacements = Mock(ModuleReplacementsData)
    def moduleIdentifierFactory = Mock(ImmutableModuleIdentifierFactory) {

app = FastAPI()


@app.get("/")
def read_root():
    return {"Hello": "World"}


@app.get("/items/{item_id}")
def read_item(item_id: int, q: Union[str, None] = None):
    return {"item_id": item_id, "q": q}
```

<details markdown="1">
<summary>Və ya <code>async def</code>...</summary>

Əgər kodunuzda `async` və ya `await` vardırsa `async def` istifadə edə bilərik:

```Python hl_lines="9  14"

    def "can transport graph of exceptions"() {
        def cause1 = new ExceptionWithState("nested-1", ["a", 1])
        def cause2 = new IOException("nested-2")
        def cause = new DefaultMultiCauseException("nested", cause1, cause2)
        def original = new ExceptionWithExceptionField("message", cause)

        when:
        def transported = transport(new TestPayloadMessage(payload: original))

        given:
        def locator = buildLayoutFactoryFor()

        and: "temporary tree created out of the Gradle build tree"
        def tmpDir = File.createTempFile("stop-", "-at").canonicalFile
        def stopAt = new File(tmpDir, 'stopAt')
        def currentDir = new File(new File(stopAt, "intermediate"), 'current')
        currentDir.mkdirs()

        expect:
        def layout = locator.getLayoutFor(currentDir, true)

        1 * selectedComponentResult.matches(b.id)
        0 * _

    }

    def "chooses newest non rejected matching version without requiring metadata"() {
        given:
        def a = component('1.2')
        def b = component('1.3')
        def c = component('2.0')
        def d = component('1.1')
        def selectedComponentResult = Mock(ComponentSelectionContext)

        when: