mod = importlib.import_module(f"docs_src.background_tasks.{request.param}")

    client = TestClient(mod.app)
    return client


def test(client: TestClient):
    log = Path("log.txt")
    if log.is_file():
        os.remove(log)  # pragma: no cover
    response = client.post("/send-notification/******@****.***?q=some-query")
    assert response.status_code == 200, response.text

        }
        return systemProperties
    }

    private
    fun getStudioHome(): String {
        if (autoDownloadAndroidStudio) {
            val androidStudioPath = studioInstallation.studioInstallLocation.asFile.get().absolutePath
            return "-Dstudio.home=$androidStudioPath"
        } else if (androidStudioHome.isPresent) {
            return "-Dstudio.home=${androidStudioHome.get()}"
        }

				}
			} else {
				vars[idx] = nullStr
			}
		case driver.Valuer:
			reflectValue := reflect.ValueOf(v)
			if v != nil && reflectValue.IsValid() && ((reflectValue.Kind() == reflect.Ptr && !reflectValue.IsNil()) || reflectValue.Kind() != reflect.Ptr) {
				r, _ := v.Value()
				convertParams(r, idx)
			} else {
				vars[idx] = nullStr
			}
		case fmt.Stringer:
			reflectValue := reflect.ValueOf(v)

    val name = this.name
    return incoming.files.elements.map {
        require(it.size <= 1) {
            "Expected at most one file in configuration '$name' but found: $it"
        }
        it.firstOrNull()?.asFile
    }
}

fun NamedDomainObjectProvider<Configuration>.getSingleFileProvider(): Provider<File> {
    return this.flatMap { configuration ->
        configuration.getSingleFileProvider()
    }

@DisableCachingByDefault(because = "Not worth caching")
abstract class CheckSubprojectsInfo : SubprojectsInfo() {

    @TaskAction
    fun checkSubprojectsInfo() {
        if (subprojectsJson.asFile.readText() != generateSubprojectsJson()) {
            throw GradleException(
                "New project(s) added without updating subproject JSON. Please run `:${GenerateSubprojectsInfo.TASK_NAME}` task."
            )

    @get:Internal
    abstract val distZipVersion: Property<String>

    override fun asArguments(): Iterable<String> {
        val distributionDir = gradleDistribution.homeDir.get().asFile
        return mapOf(
            "integTest.gradleHomeDir" to distributionDir,
            "integTest.gradleUserHomeDir" to absolutePathOf(gradleUserHomeDir.dir(gradleDistribution.name)),

    private final File acceptedViolationsDir
    private Map<String, String> acceptedViolations = null

    AcceptedViolationsProvider(Directory acceptedViolationsDir) {
        this.acceptedViolationsDir = acceptedViolationsDir.asFile
    }

    Map<String, String> get() {
        if (acceptedViolations == null) {
            acceptedViolations = AcceptedApiChanges.parse(
                acceptedViolationsDir.listFiles()

					if !fieldValue.IsValid() {
						fieldValue = reflect.New(fieldType)
					} else if fieldValue.IsNil() {
						fieldValue.Set(reflect.New(fieldType))
					}
					fieldValue.Elem().Set(reflectV)
					return
				} else if reflectValType.ConvertibleTo(fieldType) {
					if fieldValue.IsNil() {
						fieldValue.Set(reflect.New(fieldType))
					}

					fieldValue.Elem().Set(reflectV.Convert(fieldType))

@DisableCachingByDefault(because = "Not worth caching")
abstract class GenerateSubprojectsInfo : SubprojectsInfo() {

    @TaskAction
    fun generateSubprojectsInfo() {
        subprojectsJson.asFile.writeText(generateSubprojectsJson())
    }

    companion object {
        internal
        const val TASK_NAME = "generateSubprojectsInfo"
    }

    options.compilerArgs.addAll(
      listOf(
        "--patch-module",
        "$moduleName=${compileKotlinTask.destinationDirectory.get().asFile}",
      ),
    )

    classpath = compileKotlinTask.libraries
    modularity.inferModulePath.set(true)
  }