when(request.allowChain(any())).thenReturn(true);

        // When
        boolean async = request.isResponseAsync();
        int size = request.size();
        Integer timeout = request.getOverrideTimeout();
        boolean canChain = request.allowChain(nextRequest);

        // Then
        assertTrue(async);
        assertEquals(100, size);
        assertEquals(3000, timeout);
        assertTrue(canChain);

package schema_test

import (
	"reflect"
	"sync"
	"testing"

	"gorm.io/gorm"
	"gorm.io/gorm/schema"
)

type UserWithCallback struct{}

func (UserWithCallback) BeforeSave(*gorm.DB) error {
	return nil
}

func (UserWithCallback) AfterCreate(*gorm.DB) error {
	return nil
}

func TestCallback(t *testing.T) {
	user, err := schema.Parse(&UserWithCallback{}, &sync.Map{}, schema.NamingStrategy{})
	if err != nil {

# Without aliases


@app.get("/optional-str")
async def read_optional_str(p: Optional[str] = None):
    return {"p": p}


class QueryModelOptionalStr(BaseModel):
    p: Optional[str] = None


@app.get("/model-optional-str")
async def read_model_optional_str(p: Annotated[QueryModelOptionalStr, Query()]):
    return {"p": p.p}

async def get_db():
    db = DBSession()
    try:
        yield db
    finally:

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

app = FastAPI()


async def user_exists(user_id: int):
    return True


@app.get("/users/{user_id}", dependencies=[Depends(user_exists)])
async def read_users(user_id: int):
    pass


client = TestClient(app)


def test_read_users():
    response = client.get("/users/42")
    assert response.status_code == 200, response.text

package schema_test

import (
	"context"
	"database/sql"
	"reflect"
	"sync"
	"testing"
	"time"

	"gorm.io/gorm"
	"gorm.io/gorm/schema"
	"gorm.io/gorm/utils/tests"
)

func TestFieldValuerAndSetter(t *testing.T) {
	var (
		userSchema, _ = schema.Parse(&tests.User{}, &sync.Map{}, schema.NamingStrategy{})
		user          = tests.User{
			Model: gorm.Model{
				ID:        10,
				CreatedAt: time.Now(),

이는 특히 **많은 *경로 작동***에서 **같은 의존성**을 계속해서 사용하는 **거대 코드 기반**안에서 사용하면 유용할 것입니다.

## `async`하게, 혹은 `async`하지 않게

의존성이 (*경로 작동 함수*에서 처럼 똑같이) **FastAPI**에 의해 호출될 수 있으며, 함수를 정의할 때 동일한 규칙이 적용됩니다.

`async def`을 사용하거나 혹은 일반적인 `def`를 사용할 수 있습니다.

그리고 일반적인 `def` *경로 작동 함수* 안에 `async def`로 의존성을 선언할 수 있으며, `async def` *경로 작동 함수* 안에 `def`로 의존성을 선언하는 등의 방법이 있습니다.

아무 문제 없습니다. **FastAPI**는 무엇을 할지 알고 있습니다.

                }
            } else {
                log.warn("Async notify failed: {}", message.getErrorMessage());
            }

            return null;

        } catch (Exception e) {
            throw new IOException("Witness async notify RPC failed", e);
        }
    }

    /**
     * Generates a registration ID from context handle and share name.

@app.post("/optional-list-str", operation_id="optional_list_str")
async def read_optional_list_str(
    p: Annotated[Optional[list[str]], Body(embed=True)] = None,
):
    return {"p": p}


class BodyModelOptionalListStr(BaseModel):
    p: Optional[list[str]] = None


@app.post("/model-optional-list-str", operation_id="model_optional_list_str")
async def read_model_optional_list_str(p: BodyModelOptionalListStr):

//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package cmd

import (
	"context"
	"sync/atomic"
	"time"
)

const (
	lastSyncDurationMillis                 = "last_sync_duration_millis"
	pluginAuthnServiceFailedRequestsMinute = "plugin_authn_service_failed_requests_minute"