*/
    long getServerTimeZoneOffset() throws CIFSException;

    /**
     * Gets the OEM domain name reported by the server
     * @return server reported domain name
     * @throws CIFSException if an error occurs retrieving the domain name
     */
    String getOEMDomainName() throws CIFSException;

    /**
     * Gets the name of the share this tree is connected to

                        "title": "HTTPValidationError",
                        "type": "object",
                        "properties": {
                            "detail": {
                                "title": "Detail",
                                "type": "array",
                                "items": {
                                    "$ref": "#/components/schemas/ValidationError"

)
def test_required_str_missing(path: str):
    client = TestClient(app)
    response = client.get(path)
    assert response.status_code == 422
    assert response.json() == {
        "detail": [
            {
                "type": "missing",
                "loc": ["query", "p"],
                "msg": "Field required",
                "input": IsOneOf(None, {}),
            }
        ]
    }

		ID    int `gorm:"primaryKey"`
		Name  string
		Email string `gorm:"default:(-)"`
		Age   int    `gorm:"default:(-)"`
	}

	s, err := schema.Parse(&user{}, schemaCache, schema.NamingStrategy{})
	if err != nil {
		t.Errorf("parse schema error: %v, is not expected", err)
		return
	}
	dest := []*user{
		{
			ID:    1,
			Name:  "alice",
			Email: "email",
			Age:   18,
		},
		{
			ID:    2,

    static final String[] DESCR = { "WrLehDO\u0000B16BBDz\u0000", "WrLehDz\u0000B16BBDz\u0000", };

    String domain, lastName = null;
    int serverTypes;

    NetServerEnum2(final String domain, final int serverTypes) {
        this.domain = domain;
        this.serverTypes = serverTypes;
        command = SMB_COM_TRANSACTION;

                return await original_route_handler(request)
            except RequestValidationError as exc:
                body = await request.body()
                detail = {"errors": exc.errors(), "body": body.decode()}
                raise HTTPException(status_code=422, detail=detail)

        return custom_route_handler


app = FastAPI()
app.router.route_class = ValidationErrorLoggingRoute


@app.post("/")

    }

    // Happy path: session retrieval with host/domain variations
    @ParameterizedTest
    @DisplayName("getSmbSession(ctx,host,domain) returns session for various inputs")
    @CsvSource({ "server,DOMAIN", "server,", ",DOMAIN", "," })
    void getSmbSession_withTarget(String host, String domain) {
        when(transport.getSmbSession(any(jcifs.CIFSContext.class), any(), any())).thenReturn(session);

        Vector<String> paramNames = new Vector<>();
        paramNames.add("jcifs.smb.client.domain");
        paramNames.add("jcifs.http.enableBasic");
        paramNames.add("someOtherParam");

        lenient().when(servletConfig.getInitParameterNames()).thenReturn(paramNames.elements());
        lenient().when(servletConfig.getInitParameter("jcifs.smb.client.domain")).thenReturn("TESTDOMAIN");

)
def test_required_str_missing(path: str):
    client = TestClient(app)
    response = client.post(path)
    assert response.status_code == 422
    assert response.json() == {
        "detail": [
            {
                "type": "missing",
                "loc": ["body", "p"],
                "msg": "Field required",
                "input": IsOneOf(None, {}),
            }
        ]
    }

* **TCP doesn't know about "domains"**. Only about IP addresses.
    * The information about the **specific domain** requested goes in the **HTTP data**.
* The **HTTPS certificates** "certify" a **certain domain**, but the protocol and encryption happen at the TCP level, **before knowing** which domain is being dealt with.
* **By default**, that would mean that you can only have **one HTTPS certificate per IP address**.