// Test case 1: Standard padding
        final byte[] data1 = "abc".getBytes();
        assertEquals("YWJj", Base64Util.encode(data1));

        // Test case 2: Single padding
        final byte[] data2 = "abcd".getBytes();
        assertEquals("YWJjZA==", Base64Util.encode(data2));

        // Test case 3: Double padding
        final byte[] data3 = "abcde".getBytes();

        options.dataConfigIds = "data1,data2,data3,data4";

        List<String> result = options.getDataConfigIdList();
        assertNotNull(result);
        assertEquals(4, result.size());
        assertTrue(result.contains("data1"));
        assertTrue(result.contains("data2"));
        assertTrue(result.contains("data3"));
        assertTrue(result.contains("data4"));
    }

    @Test

        crawlJob.dataConfigIds(new String[] { "data1", "data2", "data3" });

        String result = crawlJob.execute();

        assertNotNull(result);
        assertTrue(result.contains("Web  Config Id: web1 web2"));
        assertTrue(result.contains("File Config Id: file1"));
        assertTrue(result.contains("Data Config Id: data1 data2 data3"));
    }

    // Test execute method with sessionId already set

    assertFalse(compound.isDone());
    future1.set(DATA1);
    assertFalse(compound.isDone());
    future2.set(DATA2);
    assertFalse(compound.isDone());
    listener.expectCall();
    future3.set(DATA3);
    assertTrue(listener.wasCalled());

    List<String> results = getDone(compound);
    assertThat(results).containsExactly(DATA1, DATA2, DATA3).inOrder();
  }

    assertFalse(compound.isDone());
    future1.set(DATA1);
    assertFalse(compound.isDone());
    future2.set(DATA2);
    assertFalse(compound.isDone());
    listener.expectCall();
    future3.set(DATA3);
    assertTrue(listener.wasCalled());

    List<String> results = getDone(compound);
    assertThat(results).containsExactly(DATA1, DATA2, DATA3).inOrder();
  }

		{data1[:511], 0, io.ErrUnexpectedEOF},
		{data1[:512], 1, io.ErrUnexpectedEOF},
		{data1[:1024], 1, io.EOF},
		{data1[:1536], 2, io.ErrUnexpectedEOF},
		{data1[:2048], 2, io.EOF},
		{data1, 2, io.EOF},
		{data1[:2048] + data2[:1536], 3, io.EOF},
		{data2[:511], 0, io.ErrUnexpectedEOF},
		{data2[:512], 1, io.ErrUnexpectedEOF},
		{data2[:1195], 1, io.ErrUnexpectedEOF},

    response1 = attacker_client.get("/openapi.json")
    data1 = response1.json()
    assert any(s.get("url") == "/evil-api" for s in data1.get("servers", []))

    # Subsequent legitimate request with no root_path
    clean_client = TestClient(app)
    response2 = clean_client.get("/openapi.json")
    data2 = response2.json()
    servers = [s.get("url") for s in data2.get("servers", [])]
    assert "/evil-api" not in servers

# Veri Akışı { #stream-data }

Veriyi JSON olarak yapılandırabiliyorsanız, [JSON Lines Akışı](../tutorial/stream-json-lines.md) kullanın.

Ancak saf ikili (binary) veri ya da string akıtmak istiyorsanız, bunu şöyle yapabilirsiniz.

/// info | Bilgi

FastAPI 0.134.0 ile eklendi.

///

## Kullanım Senaryoları { #use-cases }

Doğrudan bir AI LLM (Büyük Dil Modeli) servisinin çıktısından saf string'leri akıtmak istediğinizde kullanabilirsiniz.

# 串流資料 { #stream-data }

如果你要串流可用 JSON 結構化的資料，應該[串流 JSON Lines](../tutorial/stream-json-lines.md)。

但如果你想串流純二進位資料或字串，以下是做法。

/// info

已在 FastAPI 0.134.0 新增。

///

## 使用情境 { #use-cases }

當你想串流純字串時可以用這個機制，例如直接轉發來自 AI LLM 服務的輸出。

你也可以用它來串流大型二進位檔案，邊讀邊將每個區塊（chunk）串流出去，而不必一次把整個檔案載入記憶體。

你也可以用同樣方式串流視訊或音訊，甚至可以在處理的同時即時產生並傳送。

## 使用 `yield` 的 `StreamingResponse` { #a-streamingresponse-with-yield }

 */
@NullUnmarked
@GwtIncompatible
@J2ktIncompatible
public class JdkFutureAdaptersTest extends TestCase {
  private static final String DATA1 = "data";

  public void testListenInPoolThreadReturnsSameFuture() throws Exception {
    ListenableFuture<String> listenableFuture = immediateFuture(DATA1);
    assertThat(listenInPoolThread(listenableFuture)).isSameInstanceAs(listenableFuture);
  }