*/
    @Test(expected = ClIllegalArgumentException.class)
    public void testSet() throws Exception {
        final Field field = getClass().getField("intField");
        FieldUtil.set(field, this, "abc");
    }

    /**
     * @throws Exception
     */
    @Test
    public void testGetElementType_Rawtype() throws Exception {

        SMBUtil.writeInt4(1, buffer, notifyOffset + 4);
        SMBUtil.writeInt4(6, buffer, notifyOffset + 8); // 6 bytes filename
        System.arraycopy("abc".getBytes("UnicodeLittleUnmarked"), 0, buffer, notifyOffset + 12, 6);

        // Second notification starts at aligned offset
        notifyOffset = 108; // 80 + 28
        SMBUtil.writeInt4(0, buffer, notifyOffset);

      .isEqualTo("http://host/#=[]:;%22~%7C?%23@%5E/$%25*")
  }

  @Test
  fun toUriSpecialQueryCharacters() {
    val httpUrl = "http://host/?d=abc!@[]^`{}|\\".toHttpUrl()
    val uri = httpUrl.toUri()
    assertThat(uri.toString()).isEqualTo("http://host/?d=abc!@[]%5E%60%7B%7D%7C%5C")
  }

  @Test
  fun toUriWithUsernameNoPassword() {
    val httpUrl =
      HttpUrl
        .Builder()

    assertFailsToDecode(base32(), "let's not talk of love or chains!");
    // An 8n+{1,3,6} length string is never legal base32.
    assertFailsToDecode(base32(), "A", "Invalid input length 1");
    assertFailsToDecode(base32(), "ABC");
    assertFailsToDecode(base32(), "ABCDEF");
    // These have a combination of invalid length, unrecognized characters and wrong padding.
    assertFailsToDecode(base32(), "AB=C", "Unrecognized character: =");

from collections.abc import Sequence
from typing import Annotated, Any, Optional, TypedDict, Union

from annotated_doc import Doc
from pydantic import BaseModel, create_model
from starlette.exceptions import HTTPException as StarletteHTTPException
from starlette.exceptions import WebSocketException as StarletteWebSocketException


class EndpointContext(TypedDict, total=False):
    function: str
    path: str
    file: str
    line: int

    }

    @Test
    public void testConfigInterpolation() throws IOException {
        String config = "a=$\\\\\\\\{var}\n" + "ab=${a}b\n" + "abc=${ab}c";
        Map<String, String> expected = Map.of("a", "$\\{var}", "ab", "$\\{var}b", "abc", "$\\{var}bc");

        java.util.Properties props1 = new java.util.Properties();
        props1.load(new StringReader(config));

    // TODO test jdk.tls.client.enableSessionTicketExtension
    // TODO check debugging information

    enableTls()

    server.enqueue(MockResponse(body = "abc"))

    val request = Request(server.url("/"))

    val response = client.newCall(request).execute()

    response.use {
      assertEquals(200, response.code)
      if (PlatformVersion.majorVersion > 11) {

from collections.abc import Mapping
from typing import (
    Annotated,
    Any,
    BinaryIO,
    Callable,
    Optional,
    TypeVar,
    cast,
)

from annotated_doc import Doc
from pydantic import GetJsonSchemaHandler
from starlette.datastructures import URL as URL  # noqa: F401
from starlette.datastructures import Address as Address  # noqa: F401
from starlette.datastructures import FormData as FormData  # noqa: F401

from collections.abc import AsyncGenerator, Generator
from functools import partial
from typing import Annotated

import pytest
from fastapi import Depends, FastAPI
from fastapi.testclient import TestClient

app = FastAPI()


def function_dependency(value: str) -> str:
    return value


async def async_function_dependency(value: str) -> str:
    return value


def gen_dependency(value: str) -> Generator[str, None, None]:

		},
		// Empty filename name. - 11
		{
			volume, "", 14, 1, nil, errIsNotRegular,
		},
		// Non existent volume name - 12
		{
			"abcd", "", 14, 1, nil, errVolumeNotFound,
		},
		// Non existent filename - 13
		{
			volume, "abcd", 14, 1, nil, errFileNotFound,
		},
	}

	// Create all files needed during testing.
	appendFiles := testCases[:4]