void testSetRequestCredits() {
        // Test case for setRequestCredits method
        int credits = 5;
        mockRequest.setRequestCredits(credits);

        // Verify that setRequestCredits was called with the correct argument
        verify(mockRequest, times(1)).setRequestCredits(credits);
    }

    @Test
    void testIsCancelTrue() {
        // Test case for isCancel method when it returns true

        }
    }

    @Nested
    @DisplayName("Command Constants Tests")
    class CommandConstantsTests {

        @Test
        @DisplayName("Should have correct command constants")
        void testCommandConstants() {
            assertEquals(0x00, ServerMessageBlock2.SMB2_NEGOTIATE);
            assertEquals(0x01, ServerMessageBlock2.SMB2_SESSION_SETUP);

	if err != nil {
		t.Fatalf("Stat failed with %s expected to pass.", err)
	}

	// Get umask of the bits stored.
	currentUmask := 0o777 - uint32(st.Mode().Perm())

	// Verify if umask is correct.
	if int(currentUmask) != testCase.expectedUmask {
		t.Fatalf("Umask check failed expected %d, got %d", testCase.expectedUmask, currentUmask)
	}
}

// Tests if the file creations happen with proper umask.

Caching
=======

OkHttp implements an optional, off by default, Cache. OkHttp aims for RFC correct and
pragmatic caching behaviour, following common real-world browser like Firefox/Chrome and
server behaviour when ambiguous.

# Basic Usage

```kotlin
  private val client: OkHttpClient = OkHttpClient.Builder()
      .cache(Cache(
          directory = File(application.cacheDir, "http_cache"),
          // $0.05 worth of phone storage in 2020

        assertFalse(crawlerEngineClient.equals(other));
    }

    // Test getClass method
    @Test
    public void test_getClass() {
        // Test that getClass returns the correct class
        assertEquals(CrawlerEngineClient.class, crawlerEngineClient.getClass());
    }

    }

    @Test
    public void test_constructor() {
        assertNotNull(target, "Constructor should create instance");
        assertTrue(target instanceof HotThreadMonitorTarget, "Instance should be of correct type");
        assertTrue(target instanceof MonitorTarget, "Instance should be a MonitorTarget");
        assertTrue(target instanceof TimeoutTarget, "Instance should be a TimeoutTarget");
    }

    @Test

La manera en que los formularios HTML (`<form></form>`) envían los datos al servidor normalmente usa una codificación "especial" para esos datos, es diferente de JSON.

**FastAPI** se encargará de leer esos datos del lugar correcto en lugar de JSON.

/// note | Detalles técnicos

Los datos de formularios normalmente se codifican usando el "media type" `application/x-www-form-urlencoded`.

Verás la documentación automática de la API para la sub-aplicación, incluyendo solo sus propias _path operations_, todas bajo el prefijo correcto del sub-path `/subapi`:

<img src="/img/tutorial/sub-applications/image02.png">

////

## Alıntılar { #quotes }

//// tab | Test

Dün bir arkadaşım şunu yazdı: "If you spell incorrectly correctly, you have spelled it incorrectly". Ben de şunu yanıtladım: "Correct, but 'incorrectly' is incorrectly not '"incorrectly"'".

/// note | Not

LLM muhtemelen bunu yanlış çevirecektir. Yeniden çeviri yapıldığında düzeltilmiş çeviriyi koruyup korumadığı önemlidir.

///

////

    Note over Server: Server interprets headers<br/>(if --forwarded-allow-ips is set)

    Server->>Proxy: HTTP Response<br/>with correct HTTPS URLs

    Proxy->>Client: HTTPS Response
```

The **proxy** intercepts the original client request and adds the special *forwarded* headers (`X-Forwarded-*`) before passing the request to the **application server**.