crawlingInfoService.delete(entity);
                saveInfo(messages -> messages.addSuccessCrudDeleteCrudTable(GLOBAL));
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);
                throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToDeleteCrudTable(GLOBAL, buildThrowableMessage(e)));
            }
        }).orElse(() -> {

	maxBucketVersioningConfigSize = 1 * humanize.MiByte
)

// PutBucketVersioningHandler - PUT Bucket Versioning.
// ----------
func (api objectAPIHandlers) PutBucketVersioningHandler(w http.ResponseWriter, r *http.Request) {
	ctx := newContext(r, w, "PutBucketVersioning")

	defer logger.AuditLog(ctx, w, r, mustGetClaimsFromToken(r))

	vars := mux.Vars(r)
	bucket := vars["bucket"]

	objectAPI := api.ObjectAPI()

        val request = HttpRequest.newBuilder()
            .uri(URI(uri))
            .apply {
                if (githubToken.isPresent) {
                    header("Authorization", "token ${githubToken.get()}")
                }
            }
            .build()
        val response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString())

import jcifs.internal.smb1.ServerMessageBlock;

/**
 * SMB1 Delete Directory request message.
 *
 * This command is used to delete a directory on the server.
 * The directory must be empty before it can be deleted.
 */
public class SmbComDeleteDirectory extends ServerMessageBlock {

    /**
     * Creates a new SMB1 delete directory request.
     *
     * @param config the CIFS configuration

  }

  private fun newResponse(
    responseBody: ResponseBody,
    code: Int = 200,
    fn: Response.Builder.() -> Unit = {},
  ): Response =
    Response
      .Builder()
      .request(
        Request
          .Builder()
          .url("https://example.com/")
          .build(),
      ).protocol(Protocol.HTTP_1_1)
      .code(code)
      .message("OK")
      .body(responseBody)

  @Test
  fun testHttp2() {
    val client = HttpAsyncClients.createHttp2Default()

    client.use { client ->
      client.start()
      val request = SimpleHttpRequests.get("https://google.com/robots.txt")
      val response = client.execute(request, LoggingCallback).get()

      println("Protocol ${response.version}")
      println("Response ${response.code}")
      println("${response.body.bodyText.substring(0, 20)}...")

@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public class ListRemoveAllTester<E> extends AbstractListTester<E> {
  @CollectionFeature.Require(SUPPORTS_REMOVE)
  @CollectionSize.Require(absent = {ZERO, ONE})
  public void testRemoveAll_duplicate() {
    ArrayWithDuplicate<E> arrayAndDuplicate = createArrayWithDuplicateElement();

     * take precedence.
     *
     * @param globalToolchainsSource The global toolchains source, may be {@code null} to disable global toolchains.
     * @return This request, never {@code null}.
     */
    ToolchainsBuildingRequest setGlobalToolchainsSource(Source globalToolchainsSource);

    /**
     * Gets the user toolchains source.
     *

@pytest.fixture(
    name="client",
    params=[
        pytest.param("tutorial004_py39"),
        pytest.param("tutorial004_py310", marks=needs_py310),
    ],
)
def get_client(request: pytest.FixtureRequest):
    mod = importlib.import_module(f"docs_src.additional_responses.{request.param}")

    client = TestClient(mod.app)
    client.headers.clear()
    return client


def test_path_operation(client: TestClient):

        pytest.param("tutorial001_an_py39"),
        pytest.param("tutorial001_an_py310", marks=needs_py310),
    ],
)
def get_client(request: pytest.FixtureRequest):
    mod = importlib.import_module(f"docs_src.extra_data_types.{request.param}")

    client = TestClient(mod.app)
    return client


def test_extra_types(client: TestClient):
    item_id = "ff97dd87-a4a5-4a12-b412-cde99f33e00e"