but that goroutine may create other goroutines,
which run concurrently.
</p>

<p class="rule">
If a package <code>p</code> imports package <code>q</code>, the completion of
<code>q</code>'s <code>init</code> functions happens before the start of any of <code>p</code>'s.
</p>

<p class="rule">
The completion of all <code>init</code> functions is synchronized before

        when:
        def result = parser.parse(classMetaData, listener)

        then:
        format(result.docbook) == '<anchor id="org.gradle.Class.anchor"/>'
        _ * classMetaData.className >> 'org.gradle.Class'
    }

    def convertsAnAElementWithAUrlFragment() {
        _ * classMetaData.rawCommentText >> '<a href="#anchor">some value</a>'

        when:

import jcifs.Address;
import jcifs.CIFSContext;
import jcifs.NetbiosAddress;
import jcifs.NetbiosName;


/**
 * This class represents a NetBIOS over TCP/IP address. Under normal
 * conditions, users of jCIFS need not be concerned with this class as
 * name resolution and session services are handled internally by the smb package.
 * 
 * <p>
 * Applications can use the methods <code>getLocalHost</code>,

 * See {@link jcifs.Configuration#isDfsConvertToFQDN()} for a workaround.
 * 
 * @author mbechler
 */
public class JAASAuthenticator extends Kerb5Authenticator implements CallbackHandler, SmbRenewableCredentials {

    private static final Logger log = LoggerFactory.getLogger(JAASAuthenticator.class);

    /**
     * 
     */
    private static final long serialVersionUID = -1648420815038372844L;

import org.slf4j.LoggerFactory;

import jakarta.annotation.PostConstruct;
import jakarta.annotation.PreDestroy;

/**
 * @author shinsuke
 *
 */
public class JodExtractor extends AbstractExtractor {
    private static final Logger logger = LoggerFactory.getLogger(JodExtractor.class);

    protected OfficeManager officeManager;

    protected File tempDir = null;

    protected String outputEncoding = Constants.UTF_8;

# `Response` class

You can declare a parameter in a *path operation function* or dependency to be of type `Response` and then you can set data for the response like headers or cookies.

You can also use it directly to create an instance of it and return it from your *path operations*.

You can import it directly from `fastapi`:

```python
from fastapi import Response
```

from typing import List, Union

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()


class Item(BaseModel):
    name: str
    description: Union[str, None] = None
    price: float
    tax: Union[float, None] = None
    tags: List[str] = []


@app.post("/items/")
async def create_item(item: Item) -> Item:
    return item


@app.get("/items/")
async def read_items() -> List[Item]:

    assertThrows(IllegalArgumentException.class, () -> base64().withSeparator("=", 3));

    assertThrows(
        IllegalArgumentException.class, () -> base64().withPadChar('#').withSeparator("!#!", 3));
  }

  public void testAtMostOneSeparator() {
    BaseEncoding separated = base64().withSeparator("\n", 3);
    assertThrows(UnsupportedOperationException.class, () -> separated.withSeparator("$", 4));
  }

<a href="https://www.starlette.io/background/" class="external-link" target="_blank">`Starlette의 공식 문서`</a>에서 백그라운드 작업에 대한 자세한 내용을 확인할 수 있습니다.

## 경고

만약 무거운 백그라운드 작업을 수행해야하고 동일한 프로세스에서 실행할 필요가 없는 경우 (예: 메모리, 변수 등을 공유할 필요가 없음) <a href="https://docs.celeryq.dev" class="external-link" target="_blank">`Celery`</a>와 같은 큰 도구를 사용하면 도움이 될 수 있습니다.

import org.opensearch.index.query.QueryBuilders;

public class WildcardQueryCommand extends QueryCommand {
    private static final Logger logger = LogManager.getLogger(WildcardQueryCommand.class);

    protected boolean lowercaseWildcard = true;

    @Override
    protected String getQueryClassName() {
        return WildcardQuery.class.getSimpleName();
    }

    @Override