this.authMethod = "NTLM";
                        break;
                    }
                    if (currentAuthMethod.indexOf(' ') != 4) {
                        continue;
                    }
                    this.authMethod = "NTLM";
                    authorization = currentAuthMethod.substring(5).trim();
                    break;
                }

La seule différence est que la `HTTPException` de **FastAPI** accepte toute donnée sérialisable en JSON pour le champ `detail`, tandis que la `HTTPException` de Starlette n'accepte que des chaînes.

Ainsi, vous pouvez continuer à lever la `HTTPException` de **FastAPI** normalement dans votre code.

Mais lorsque vous enregistrez un gestionnaire d'exception, vous devez l'enregistrer pour la `HTTPException` de Starlette.

        .build(),
    )
    val url = server.url("/").toUrl()
    val connection = url.openConnection() as HttpURLConnection
    connection.doOutput = true
    connection.setRequestProperty("Expect", "100-Continue")
    connection.outputStream.write("request".toByteArray(UTF_8))
    val inputStream = connection.inputStream
    val reader = BufferedReader(InputStreamReader(inputStream, UTF_8))

                    }
                    continue;
                }
                if (!isUrlCrawlable(paramMap, crawlRequest.getUrl())) {
                    continue;
                }
                counter++;
                final Map<String, Object> localDataMap =

Agora vamos estender este exemplo e adicionar mais detalhes para ver como testar diferentes partes.

### Arquivo de aplicação **FastAPI** estendido { #extended-fastapi-app-file }

Vamos continuar com a mesma estrutura de arquivo de antes:

```
.
├── app
│   ├── __init__.py
│   ├── main.py
│   └── test_main.py
```

        String[] components = path.split("[\\\\/]");

        for (String component : components) {
            if (component.isEmpty()) {
                continue; // Skip empty components (from double slashes)
            }

            // Check component length
            if (component.length() > maxComponentLength) {

                    .get());
            options.addOption(Option.builder(FAIL_AT_END)
                    .longOpt("fail-at-end")
                    .desc("Only fail the build afterwards; allow all non-impacted builds to continue")
                    .get());
            options.addOption(Option.builder(FAIL_NEVER)
                    .longOpt("fail-never")
                    .desc("NEVER fail the build, regardless of project result")

		{"foo", "\n\tnewline \t % $ & * ^ # @ \n", testData, false, true},
	}

	for i, testCase := range testCases {
		if testCase.ignoreIfWindows && runtime.GOOS == "windows" {
			continue
		}
		err := storage.AppendFile(t.Context(), testCase.volumeName, testCase.objectName, testCase.data)
		expectErr := (err != nil)

		if expectErr != testCase.expectErr {

        .Builder()
        .add100Continue()
        .build(),
    )
    val request =
      Request
        .Builder()
        .url(server.url("/"))
        .header("Expect", "100-continue")
        .post("abc".toRequestBody("text/plain".toMediaType()))
        .build()
    val call = client.newCallWithListener(request)
    call.execute()

	// this map, that's an error.
	mustFindInPolicy := make(map[string][]string, len(formValues))
	for key, values := range formValues {
		if keyInPolicyExceptions[key] || strings.HasPrefix(key, "X-Ignore-") {
			continue
		}
		mustFindInPolicy[key] = values
	}

	// Iterate over policy conditions and check them against received form fields
	for _, policy := range postPolicyForm.Conditions.Policies {