"gorm.io/gorm/schema"
)

var schemaCache = &sync.Map{}

func TestConvertToCreateValues_DestType_Slice(t *testing.T) {
	type user struct {
		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 comparison result for sorting
     * @throws IOException if an I/O error occurs
     */
    protected int compareTypes(final SmbFile f1, final String f1name, final SmbFile f2) throws IOException {
        String f2name, t1, t2;
        int i;

        if (f1.isDirectory() != f2.isDirectory()) {
            return f1.isDirectory() ? -1 : 1;
        }
        f2name = f2.getName();

    void testConcurrentAccess() throws InterruptedException {
        // Given
        final int threadCount = 10;
        final Thread[] threads = new Thread[threadCount];
        final boolean[] results = new boolean[threadCount];

        // When
        for (int i = 0; i < threadCount; i++) {
            final int index = i;
            threads[i] = new Thread(() -> {
                try {

     *
     * @param inputBuf
     * @param offset
     * @param len
     * @return response token
     */
    @Override
    public byte[] initSecContext(final byte[] inputBuf, final int offset, final int len) throws CIFSException {
        SpnegoToken resp;
        if (this.completed) {
            throw new CIFSException("Already complete");
        }
        if (len == 0) {

      extends ForwardingList<E> {
    final List<E> delegate;
    final int delta;

    MisleadingSizeList(List<E> delegate, int delta) {
      this.delegate = delegate;
      this.delta = delta;
    }

    @Override
    protected List<E> delegate() {
      return delegate;
    }

    @Override
    public int size() {
      return delegate.size() + delta;
    }
  }

            final long requestInterval) {
        final Deferred<SuggestIndexResponse> deferred = new Deferred<>();
        threadPool.execute(() -> {
            final long start = System.currentTimeMillis();
            int numberOfSuggestDocs = 0;
            int numberOfInputDocs = 0;
            final List<Throwable> errors = new ArrayList<>();

     *
     * @return the HTTP status code
     */
    public int getHttpStatusCode() {
        return httpStatusCode;
    }

    /**
     * Sets the HTTP status code of the response.
     *
     * @param statusCode the HTTP status code to set
     */
    public void setHttpStatusCode(final int statusCode) {
        httpStatusCode = statusCode;
    }

    /**

class User(BaseModel):
    username: str
    full_name: str | None = None


@app.put("/items/{item_id}")
async def update_item(
    *,
    item_id: int,
    item: Item,
    user: User,
    importance: int = Body(gt=0),
    q: str | None = None,
):
    results = {"item_id": item_id, "item": item, "user": user, "importance": importance}
    if q:
        results.update({"q": q})

app = FastAPI()


fake_items_db = [{"item_name": "Foo"}, {"item_name": "Bar"}, {"item_name": "Baz"}]


class CommonQueryParams:
    def __init__(self, q: Union[str, None] = None, skip: int = 0, limit: int = 100):
        self.q = q
        self.skip = skip
        self.limit = limit


@app.get("/items/")
async def read_items(commons: CommonQueryParams = Depends()):
    response = {}
    if commons.q:

     * circumstances.
     */
    public static void main(String[] args) throws IOException {
        int exitCode = new MavenEncCling().run(args, null, null, null, false);
        System.exit(exitCode);
    }

    /**
     * ClassWorld Launcher "enhanced" entry point: returning exitCode and accepts Class World.
     */
    public static int main(String[] args, ClassWorld world) throws IOException {