checkState(method == null);
    Method[] methods = getClass().getMethods();
    Arrays.sort(
        methods,
        new Comparator<Method>() {
          @Override
          public int compare(Method a, Method b) {
            return a.getName().compareTo(b.getName());
          }
        });
    for (Method method : methods) {
      if (method.isAnnotationPresent(TestSubtype.class)) {

    extends AbstractTableReadTest<C> {

  protected void populate(Table<String, Integer, C> table, @Nullable Object... data) {
    checkArgument(data.length % 3 == 0);
    for (int i = 0; i < data.length; i += 3) {
      table.put(
          (String) data[i], (Integer) data[i + 1], nullableCellValue((Character) data[i + 2]));
    }
  }

  protected boolean supportsRemove() {
    return true;

     * @param scope cache scope
     * @return lease key or null if not supported
     * @throws SmbException if an error occurs
     */
    public static Smb2LeaseKey requestDirectoryLease(SmbFile smbFile, int requestedState, DirectoryCacheScope scope) throws SmbException {
        if (!smbFile.isDirectory()) {
            throw new SmbException("Directory leasing only supported for directories");
        }

                        && Objects.equals(type, that.type)
                        && Objects.equals(coordinatesString, that.coordinatesString);
            }

            @Override
            public int hashCode() {
                return Objects.hash(groupId, artifactId, version, classifier, extension, type, coordinatesString);
            }

            @Override
            public String toString() {

	for tier, stats := range ts {
		infos = append(infos, madmin.TierInfo{
			Name:  tier,
			Type:  globalTierConfigMgr.TierType(tier),
			Stats: stats,
		})
	}

	sort.Slice(infos, func(i, j int) bool {
		if infos[i].Type == "internal" {
			return true
		}
		if infos[j].Type == "internal" {
			return false
		}
		return infos[i].Name < infos[j].Name
	})
	return infos
}

     */
    @Override
    protected SearchResult search(final String query, final SearchRequestParams params, final OptionalThing<FessUserBean> userBean) {
        final int pageSize = params.getPageSize();
        LaRequestUtil.getOptionalRequest().ifPresent(request -> {
            request.setAttribute(Constants.REQUEST_PAGE_SIZE, pageSize);
        });

  }

  class RealBackend(
    threadFactory: ThreadFactory,
  ) : Backend {
    val executor =
      ThreadPoolExecutor(
        // corePoolSize:
        0,
        // maximumPoolSize:
        Int.MAX_VALUE,
        // keepAliveTime:
        60L,
        TimeUnit.SECONDS,
        SynchronousQueue(),
        threadFactory,
      )

    override fun nanoTime() = System.nanoTime()

Los parámetros de la función se reconocerán de la siguiente manera:

* Si el parámetro también se declara en el **path**, se utilizará como un parámetro de path.
* Si el parámetro es de un **tipo singular** (como `int`, `float`, `str`, `bool`, etc.), se interpretará como un parámetro de **query**.
* Si el parámetro se declara como del tipo de un **modelo de Pydantic**, se interpretará como un **request body**.

/// note | Nota

```Python
from typing import Optional

from fastapi import FastAPI

app = FastAPI()


@app.get("/")
def read_root():
    return {"Hello": "World"}


@app.get("/items/{item_id}")
def read_item(item_id: int, q: Optional[str] = None):
    return {"item_id": item_id, "q": q}
```

* Vous devriez maintenant avoir une structure de répertoire telle que :

```
.
├── app
│   └── main.py
└── Dockerfile
```

        assertNotNull(results);
    }

    @Test
    public void testConvertWithLongText() throws IOException {
        // Test convert with long text
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 100; i++) {
            sb.append("word").append(i).append(" ");
        }
        String text = sb.toString();
        String field = "content";