assertThat(test.dispatcherA.closed).isTrue()
          assertThat(test.dispatcherB.closed).isTrue()
          assertThat(test.dispatcherC.closed).isFalse() // Never started.
        }
        testInstances.clear()

        // No assertion that serverC and serverD are closed, because the MockWebServerExtension
        // runs after this callback.
        if (false) {
          assertThat(dispatcherD.closed).isTrue()

 * bound. However, it would also let them create `new TypeParameter<@Nullable T>() {}`, which
 * wouldn't behave as users might expect. Additionally, it's not clear how the TypeToken API could
 * support even a "normal" `TypeParameter<T>` when `<T>` has a nullable bound. (See the discussion
 * on TypeToken.where.) So, in the interest of failing fast and encouraging the user to switch to a

     * @see jcifs.Decodable#decode(byte[], int, int)
     */
    @Override
    public int decode(byte[] buffer, int bufferIndex, int len) {
        int start = bufferIndex;
        int end = start + len;
        interfaces.clear();

        while (bufferIndex < end && (bufferIndex + 152) <= end) {
            // Read Next field to determine if there are more entries
            int next = SMBUtil.readInt4(buffer, bufferIndex);

    // so we don't leak that data into the input of the next message.
    if (inflater.bytesRead < totalBytesToRead) {
      deflatedBytes.clear()
      inflaterSource.close()
      this.inflaterSource = null
      this.inflater = null
    }
  }

  @Throws(IOException::class)
  override fun close() {
    inflaterSource?.close()
    inflaterSource = null
    inflater = null
  }

    ],
)
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):
    response = client.get("/items/foo")
    assert response.status_code == 200, response.text

	var zb0004 uint32
	zb0004, err = dc.ReadMapHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if (*z) == nil {
		(*z) = make(DailyAllTierStats, zb0004)
	} else if len((*z)) > 0 {
		clear((*z))
	}
	var field []byte
	_ = field
	for zb0004 > 0 {
		zb0004--
		var zb0001 string
		zb0001, err = dc.ReadString()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}

import java.beans.Introspector;
import java.util.Deque;

/**
 * Utility class for disposing of resources at the end of an application.
 * <p>
 * If there are resources that must be disposed of at the end of the application,
 * create a class that implements {@link Disposable} and register it with this class.
 * </p>
 *
 * @author koichik
 */
public abstract class DisposableUtil {

    /**
     * Do not instantiate.
     */

 * @author Jared Levy
 */
@GwtCompatible
@NullMarked
public class TransposedTableTest extends AbstractTableTest<Character> {

  @Override
  protected Table<String, Integer, Character> create(@Nullable Object... data) {
    Table<Integer, String, Character> original = HashBasedTable.create();
    Table<String, Integer, Character> table = transpose(original);
    table.clear();
    populate(table, data);
    return table;
  }

### Target language

Translate to Traditional Chinese (繁體中文).

Language code: zh-hant.

### Grammar and tone

1) Use clear, concise technical Traditional Chinese consistent with existing docs.
2) Address the reader naturally (commonly using “你/你的”).

### Headings

1) Follow existing Traditional Chinese heading style (short and descriptive).
2) Do not add trailing punctuation to headings.

### Quotes and punctuation

 * bound. However, it would also let them create `new TypeParameter<@Nullable T>() {}`, which
 * wouldn't behave as users might expect. Additionally, it's not clear how the TypeToken API could
 * support even a "normal" `TypeParameter<T>` when `<T>` has a nullable bound. (See the discussion
 * on TypeToken.where.) So, in the interest of failing fast and encouraging the user to switch to a