String text = "test@example.com #hashtag $100";
        String field = "content";
        String lang = "en";

        List<AnalyzeToken> tokens = analyzer.analyze(text, field, lang);

        assertNotNull(tokens);
        assertEquals(5, tokens.size());
        assertEquals("test", tokens.get(0).getTerm());
        assertEquals("example", tokens.get(1).getTerm());

{* ../../docs_src/app_testing/app_a_py310/test_main.py hl[3] *}


...and have the code for the tests just like before.

## Testing: extended example { #testing-extended-example }

Now let's extend this example and add more details to see how to test different parts.

### Extended **FastAPI** app file { #extended-fastapi-app-file }

Let's continue with the same file structure as before:

    @Test
    public void test_parse_quoted_values() {
        String value;
        String[] result;

        // Simple quoted value - quotes are removed
        value = "\"simple\"";
        result = KuromojiCSVUtil.parse(value);
        assertEquals(1, result.length);
        assertEquals("\"simple\"", result[0]);

        // Quoted value with comma - quotes are removed
        value = "\"value,with,commas\"";

    "tax": 3.2,
    "tags": [
        "rock",
        "metal",
        "bar"
    ],
    "images": [
        {
            "url": "http://example.com/baz.jpg",
            "name": "The Foo live"
        },
        {
            "url": "http://example.com/dave.jpg",
            "name": "The Baz"
        }
    ]
}
```

/// info

```


## Adding Microbenchmarks

Before adding a new microbenchmark, make yourself familiar with the JMH API. You can check our existing microbenchmarks and also the
[JMH samples](http://hg.openjdk.java.net/code-tools/jmh/file/tip/jmh-samples/src/main/java/org/openjdk/jmh/samples/).

In contrast to tests, the actual name of the benchmark class is not relevant to JMH. However, stick to the naming convention and

        words.add("apple");
        words.add("application");
        words.add("apply");

        SuggestResponse response = new SuggestResponse("test-index", 100, words, 10, new ArrayList<>());

        assertNotNull(response.getWords());
        assertEquals(3, response.getWords().size());
        assertTrue(response.getWords().contains("apple"));

Requests has a very simple and intuitive design, it's very easy to use, with sensible defaults. But at the same time, it's very powerful and customizable.

That's why, as said in the official website:

> Requests is one of the most downloaded Python packages of all time

The way you use it is very simple. For example, to do a `GET` request, you would write:

```Python

}

// ExampleWriter_ReadFrom demonstrates how to use the ReadFrom method of Writer.
func ExampleWriter_ReadFrom() {
	var buf bytes.Buffer
	writer := bufio.NewWriter(&buf)

	data := "Hello, world!\nThis is a ReadFrom example."
	reader := strings.NewReader(data)

	n, err := writer.ReadFrom(reader)
	if err != nil {
		fmt.Println("ReadFrom Error:", err)
		return
	}

	if err = writer.Flush(); err != nil {

### Réponse résultante { #the-resulting-response }

Si le client demande `http://example.com/items/foo` (un `item_id` « foo »), il recevra un code d'état HTTP 200 et une réponse JSON :

```JSON
{
  "item": "The Foo Wrestlers"
}
```

Mais si le client demande `http://example.com/items/bar` (un `item_id` inexistant « bar »), il recevra un code d'état HTTP 404 (l'erreur « not found ») et une réponse JSON :

### Multiple Applications { #multiple-applications }

In the same server (or servers), there could be **multiple applications**, for example, other API programs or a database.

Only one process can be handling the specific IP and port (the TLS Termination Proxy in our example) but the other applications/processes can be running on the server(s) too, as long as they don't try to use the same **combination of public IP and port**.