---> 100%
```

</div>

**Nota**: Asegúrate de poner `"fastapi[standard]"` entre comillas para asegurar que funcione en todas las terminales.

## Ejemplo { #example }

### Créalo { #create-it }

Crea un archivo `main.py` con:

```Python
from typing import Union

from fastapi import FastAPI

app = FastAPI()


@app.get("/")
def read_root():

    }

    @Override
    protected boolean isUseOneTimeContainer() {
        return true;
    }

    @Override
    public void setUp() throws Exception {
        // create runner instance
        runner = new OpenSearchRunner();
        // create ES nodes
        final String clusterName = UUID.randomUUID().toString();
        runner.onBuild((number, settingsBuilder) -> {
            settingsBuilder.put("http.cors.enabled", true);

Point a web browser running on the host machine to <http://127.0.0.1:9000> and log in with the root credentials.
You can use the Browser to create buckets, upload objects, and browse the contents of the MinIO server.

You can also connect using any S3-compatible tool, such as the MinIO Client `mc` commandline tool:

```sh

    /** Maximum size for fragmented operations */
    protected int maxFragmentedSize;
    /** Maximum size for RDMA read/write operations */
    protected int maxReadWriteSize;

    /**
     * Create new RDMA connection
     *
     * @param remote remote socket address
     * @param local local socket address, may be null
     */
    public RdmaConnection(InetSocketAddress remote, InetSocketAddress local) {

            assertNotNull(customResult);
        }
    }

    @Nested
    @DisplayName("Constructor and initialization")
    class ConstructorTests {

        @Test
        @DisplayName("Should create MimeMap instance successfully")
        void testConstructor() {
            assertDoesNotThrow(() -> new MimeMap());
        }

        @Test
        @DisplayName("Should load mime.map resource properly")

    }

    @Test
    @DisplayName("Test leak detection for unclosed resources")
    @Timeout(value = 5, unit = TimeUnit.SECONDS)
    void testLeakDetection() throws InterruptedException {
        // Create resource that will be garbage collected without closing
        createLeakyResource();

        // Force garbage collection
        System.gc();
        Thread.sleep(200);

        // Check for leaks

## Use `CORSMiddleware` { #use-corsmiddleware }

You can configure it in your **FastAPI** application using the `CORSMiddleware`.

* Import `CORSMiddleware`.
* Create a list of allowed origins (as strings).
* Add it as a "middleware" to your **FastAPI** application.

You can also specify whether your backend allows:

* Credentials (Authorization headers, Cookies, etc).

        {{- end }}
        {{- if .Values.customCommandJob.extraVolumes }}
          {{- toYaml .Values.customCommandJob.extraVolumes | nindent 8 }}
        {{- end }}
      {{- if .Values.serviceAccount.create }}
      serviceAccountName: {{ .Values.serviceAccount.name }}
      {{- end }}
      {{- if .Values.policies }}
      initContainers:
        - name: minio-make-policy

 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package jcifs.internal.smb2.create;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import jcifs.CIFSContext;
import jcifs.Configuration;
import jcifs.internal.smb2.RequestWithFileId;

  protected final CountDownLatch listenerLatch = new CountDownLatch(1);

  protected volatile boolean throwException = false;

  protected final ListenableFutureTask<Integer> task =
      ListenableFutureTask.create(
          new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
              runLatch.countDown();
              taskLatch.await();
              if (throwException) {