"unitTests": true,
    "functionalTests": true,
    "crossVersionTests": false
  },
  {
    "name": "api-metadata",
    "path": "platforms/core-configuration/api-metadata",
    "unitTests": false,
    "functionalTests": false,
    "crossVersionTests": false
  },
  {
    "name": "architecture-test",
    "path": "testing/architecture-test",
    "unitTests": true,
    "functionalTests": false,

}

data class GradleSubproject(val name: String, val path: String, val unitTests: Boolean = true, val functionalTests: Boolean = true, val crossVersionTests: Boolean = false) {
    fun hasTestsOf(testType: TestType) = (unitTests && testType.unitTests) || (functionalTests && testType.functionalTests) || (crossVersionTests && testType.crossVersionTests)
}

data class Stage(

    testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"

    buildFeatures {
      buildConfig = false
    }

    testOptions {
      unitTests {
        isIncludeAndroidResources = true
      }

      targetSdk = 34
    }
  }

  compileOptions {
    targetCompatibility(JavaVersion.VERSION_11)
    sourceCompatibility(JavaVersion.VERSION_11)

        model.subprojects.subprojects.filter {
            !ignoredSubprojects.contains(it.name)
        }.forEach {
            val dir = File("..", it.path)
            assertEquals(it.unitTests, File(dir, "src/test").isDirectory, "${it.name}'s unitTests is wrong!")
            assertEquals(it.functionalTests, File(dir, "src/integTest").isDirectory, "${it.name}'s functionalTests is wrong!")

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import junit.framework.TestCase;

/**
 * Unittests for {@link CycleDetectingLockFactory}.
 *
 * @author Darick Tong
 */
public class CycleDetectingLockFactoryTest extends TestCase {

  private ReentrantLock lockA;
  private ReentrantLock lockB;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import junit.framework.TestCase;

/**
 * Unittests for {@link CycleDetectingLockFactory}.
 *
 * @author Darick Tong
 */
public class CycleDetectingLockFactoryTest extends TestCase {

  private ReentrantLock lockA;
  private ReentrantLock lockB;

import subprocess
import sys
from unittest.mock import patch

import fastapi.cli
import pytest


def test_fastapi_cli():
    result = subprocess.run(
        [
            sys.executable,
            "-m",
            "coverage",
            "run",
            "-m",
            "fastapi",
            "dev",
            "non_existent_file.py",
        ],
        capture_output=True,
        encoding="utf-8",
    )

from unittest.mock import patch

import pytest
from dirty_equals import IsDict
from fastapi.testclient import TestClient


@pytest.fixture
def client():
    from docs_src.body.tutorial001 import app

    client = TestClient(app)
    return client


def test_body_float(client: TestClient):
    response = client.post("/items/", json={"name": "Foo", "price": 50.5})
    assert response.status_code == 200

from unittest.mock import patch

import pytest
from dirty_equals import IsDict
from fastapi.testclient import TestClient

from ...utils import needs_py310


@pytest.fixture
def client():
    from docs_src.body.tutorial001_py310 import app

    client = TestClient(app)
    return client


@needs_py310
def test_body_float(client: TestClient):
    response = client.post("/items/", json={"name": "Foo", "price": 50.5})

   * not useful to specify {@link TimeUnit#NANOSECONDS} precision here.
   *
   * <p>It is generally not a good idea to use an ambiguous, unitless {@code long} to represent
   * elapsed time. Therefore, we recommend using {@link #elapsed()} instead, which returns a
   * strongly-typed {@code Duration} instance.
   *