ContentCache cache = new ContentCache(data);

        // Memory-based cache close should not throw exception
        cache.close();

        // Should still be able to get input stream after close for memory cache
        try (InputStream stream = cache.getInputStream()) {
            assertNotNull(stream);
        }
    }

    @Test

    @Secured({ ROLE, ROLE + VIEW })
    public HtmlResponse list(final OptionalThing<Integer> pageNumber, final SearchForm form) {
        pageNumber.ifPresent(num -> {
            rolePager.setCurrentPageNumber(pageNumber.get());
        }).orElse(() -> {
            rolePager.setCurrentPageNumber(0);
        });
        return asHtml(path_AdminRole_AdminRoleJsp).renderWith(data -> {
            searchPaging(data, form);
        });

```JSON hl_lines="22"
{
    "openapi": "3.1.0",
    "info": {
        "title": "FastAPI",
        "version": "0.1.0"
    },
    "paths": {
        "/items/": {
            "get": {
                "summary": "Read Items",
                "operationId": "read_items_items__get",
                "responses": {
                    "200": {
                        "description": "Successful Response",

```JSON hl_lines="22"
{
    "openapi": "3.1.0",
    "info": {
        "title": "FastAPI",
        "version": "0.1.0"
    },
    "paths": {
        "/items/": {
            "get": {
                "summary": "Read Items",
                "operationId": "read_items_items__get",
                "responses": {
                    "200": {
                        "description": "Successful Response",

			),
		},
	}
}

// Wrapper for calling Create Bucket and ensure we get one and only one success.
func TestCreateBucket(t *testing.T) {
	ExecObjectLayerAPITest(ExecObjectLayerAPITestArgs{t: t, objAPITest: testCreateBucket, endpoints: []string{"MakeBucket"}})
}

// testCreateBucket - Test for calling Create Bucket and ensure we get one and only one success.

    System {
      override fun create() = FileSystem.SYSTEM

      override val windows: Boolean
        get() = TestUtil.windows
    },

    FakeUnix {
      override fun create() = FakeFileSystem().apply { emulateUnix() }

      override val windows: Boolean
        get() = false
    },

    FakeWindows {
      override fun create() = FakeFileSystem().apply { emulateWindows() }

            index = SuggestConstants.EMPTY_STRING;
        }

        for (final SearchHit hit : hits) {
            final Map<String, Object> source = hit.getSourceAsMap();
            final String text = source.get(FieldNames.TEXT).toString();
            words.add(text);

            if (detail) {
                items.add(SuggestItem.parseSource(source));
            }
        }

                userHome,
                List.of("eu.maveniverse.maven.plugins:toolbox:" + Environment.TOOLBOX_VERSION + ":dump"),
                List.of("--force-interactive"));

        String log = logs.get("eu.maveniverse.maven.plugins:toolbox:" + Environment.TOOLBOX_VERSION + ":dump");
        assertTrue(log.contains("https://repo1.maven.org/maven2"), log);
        assertFalse(log.contains("https://repo.maven.apache.org/maven2"), log);

In the previous example, we were returning a `dict` from our dependency ("dependable"):

{* ../../docs_src/dependencies/tutorial001_an_py310.py hl[9] *}

But then we get a `dict` in the parameter `commons` of the *path operation function*.

And we know that editors can't provide a lot of support (like completion) for `dict`s, because they can't know their keys and value types.

We can do better...

	t.Run("CheckField/"+f.Name, func(t *testing.T) {
		if fc != nil {
			fc(f)
		}

		if f.TagSettings == nil {
			if f.Tag != "" {
				f.TagSettings = schema.ParseTagSetting(f.Tag.Get("gorm"), ";")
			} else {
				f.TagSettings = map[string]string{}
			}
		}

		parsedField, ok := s.FieldsByDBName[f.DBName]
		if !ok {
			parsedField, ok = s.FieldsByName[f.Name]
		}

		if !ok {