def projectState = Stub(ProjectState)
        def model = new Object()

        given:
        _ * workerThreadRegistry.workerThread >> true
        _ * target.projectPath >> ":some:path"
        _ * target.rootDir >> rootDir
        _ * buildStateRegistry.visitBuilds(_) >> { Consumer consumer ->
            consumer.accept(buildState1)
            consumer.accept(buildState2)

import java.io.File

class NativeStandaloneSessionBuilderAgainstStdlibTest : AbstractStandaloneSessionBuilderAgainstStdlibTest() {
    @Test
    fun testKotlinStdlibJvm() {
        val konanHome = KotlinNativePaths.homePath
        doTestKotlinStdLibResolve(
            NativePlatforms.unspecifiedNativePlatform,
            konanHome.resolve(konanCommonLibraryPath(KONAN_STDLIB_NAME)).toPath()
        )
    }

        isSameNodeType(resultRoot)
        removedNodes == [selectedChild]
        addedNodes.empty
        interaction { noMoreInteractions() }

        where:
        vfsSpec << IS_PREFIX_OF_CHILD + SAME_PATH
    }

    def "invalidate #vfsSpec.searchedPath invalidates children of #vfsSpec.selectedChildPath (#vfsSpec)"() {
        setupTest(vfsSpec)
        def invalidatedChild = mockChild()

        when:

        then:
        1 * execActionFactory.newExecAction() >> action
        1 * action.executable(Jvm.current().javadocExecutable)
    }

    def testCheckCustomExecutable() {
        String executable = "somepath"
        def action = Mock(ExecAction)

        when:
        javadocExecHandleBuilder.executable = executable
        javadocExecHandleBuilder.execHandle

        then:

    DefaultPluginManager pluginManager = Mock(DefaultPluginManager)
    FeatureFlags previews = Mock(FeatureFlags)
    DefaultSettings settings

    def createSettings(String path = '/somepath/root') {
        settingsDir = new File(path).absoluteFile
        startParameter = new StartParameter(currentDir: new File(settingsDir, 'current'), gradleUserHomeDir: new File('gradleUserHomeDir'))

    }

    void "annotations on method params are retained"() {
        given:
        def api = toApi([
            A  : '''
                public class A {
                    public void foo(@Ann(path="somePath") String foo) {}
                }
            ''',
            Ann: '''
                import java.lang.annotation.ElementType;
                import java.lang.annotation.Retention;

# The Python package is not allowed to depend on any CUDA packages.
@test "Pip package doesn't depend on CUDA" {
  bazel cquery \
    --experimental_cc_shared_library \
    --@local_config_cuda//:enable_cuda \
    "somepath(//tensorflow/tools/pip_package:wheel, " \
    "@local_config_cuda//cuda:cudart + "\
    "@local_config_cuda//cuda:cudart + "\
    "@local_config_cuda//cuda:cuda_driver + "\
    "@local_config_cuda//cuda:cudnn + "\

So, if the `dict` contains:

```Python
{
    "username": "johndoe",
    "hashed_password": "some_hash",
}
```

It will be passed to `UserInDB` as:

```Python
UserInDB(username="johndoe", hashed_password="some_hash")
```

## Create your **FastAPI** code

### Create the `FastAPI` app

```Python hl_lines="46"

        configuration.allDependencies as Set == [dependency, projectDependency] as Set
    }

    def "resolves files"() {
        def configuration = conf()
        def fileSet = [new File("somePath")] as Set

        given:
        resolver.resolveGraph(configuration) >> graphResolved(fileSet)

        when:
        def resolved = configuration.resolve()

        then:

        return getClass().getResourceAsStream('customClasspath.xml')
    }

    private Library createSomeLibrary() {
        Library library = new Library(fileReferenceFactory.fromPath("/somepath"))
        library.exported = true
        return library
    }

    private ProjectDependency createProjectDependency(String path, String publicationPath, Map entryAttributes) {