}
            }.map { PerformanceScenario(Scenario.fromTestId(configuration.testId), it.testProject) }
    }
}

data class PerformanceTestDuration(
    val scenario: Scenario,
    val durationInMs: Int,
) {
    fun toCsvLine() = "${scenario.className};${scenario.scenario}"
}

data class PerformanceScenario(
    val scenario: Scenario,
    val testProject: String,
)

		Files:  s.Files,
		Ffree:  s.Ffree,
		FSType: getFSType(s.Type),
	}
	// Check for overflows.
	// https://github.com/minio/minio/issues/8035
	// XFS can show wrong values at times error out
	// in such scenarios.
	if info.Free > info.Total {
		return info, fmt.Errorf("detected free space (%d) > total drive space (%d), fs corruption at (%s). please run 'fsck'", info.Free, info.Total, path)
	}
	info.Used = info.Total - info.Free

 * </p>
 * <pre>
 * Map&lt;K, V&gt; syncMap = Collections.synchronizedMap(new LruHashMap&lt;&gt;(100));
 * </pre>
 * <p>
 * Alternatively, for high-concurrency scenarios, consider implementing a custom
 * LRU cache using {@link java.util.concurrent.ConcurrentHashMap} with an eviction strategy.
 * </p>
 *
 * @author koichik
 * @param <K> the key type
 * @param <V> the value type
 */

            includeModule("org.gradle.buildtool.internal", "gradle-ide-starter")
            includeModule("org.gradle.buildtool.internal", "gradle-ide-starter-scenarios")
        }
    }
    google {
        content {
            includeGroup("com.android.databinding")
            includeGroupByRegex("com\\.android\\.tools(\\.[a-z.\\-]*)?")
        }
    }
    maven {

Here is the reference for it and its parameters.

You can import it directly from `fastapi`:

```python
from fastapi import Depends
```

::: fastapi.Depends

## `Security()`

For many scenarios, you can handle security (authorization, authentication, etc.) with dependencies, using `Depends()`.

But when you want to also declare OAuth2 scopes, you can use `Security()` instead of `Depends()`.

/// note

`jsonable_encoder` is actually used by **FastAPI** internally to convert data. But it is useful in many other scenarios.

            fail("ProcessDestroyer inner class should exist");
        }
    }

    // Test exception handling scenarios
    @Test
    public void test_exception_handling_scenarios() throws Exception {
        // Test various exception scenarios without triggering component dependencies

        // Test with null command list
        try {

            verify(ace, times(1)).getFlags();
        }
    }

    @Nested
    @DisplayName("Real-world Usage Scenarios")
    class RealWorldUsageTests {

        @Test
        @DisplayName("Should handle typical file system permission scenarios")
        void shouldHandleFileSystemPermissions() {
            // Read-only file access

 * This action handles SSO authentication flows including login, logout, and metadata
 * operations. It coordinates with the SsoManager to perform authentication using
 * configured SSO providers and handles various authentication scenarios including
 * successful login, authentication failures, and redirects.
 */
public class SsoAction extends FessLoginAction {
    // ===================================================================================

        get() = PerformanceTestType.AD_HOC

    override val failsStage: Boolean
        get() = false

    val buildSpecs: List<FlameGraphGenerationBuildSpec>
        get() =
            scenarios.flatMap { scenario ->
                Os.values().flatMap { os ->
                    val arch = if (os == Os.MACOS) Arch.AARCH64 else Arch.AMD64
                    if (os == Os.WINDOWS) {
                        listOf("jprofiler")