public void test_evaluate_withNestedExpressions() {
        String template = "${level1.level2.value}";
        Map<String, Object> paramMap = new HashMap<>();
        Map<String, Object> level2 = new HashMap<>();
        level2.put("value", "nested");
        Map<String, Object> level1 = new HashMap<>();
        level1.put("level2", level2);
        paramMap.put("level1", level1);

    public void test_constructor() {
        Map<String, Object> parentMap = new HashMap<>();
        DocMap docMap = new DocMap(parentMap);

        assertNotNull(docMap);
        assertTrue(docMap.isEmpty());
        assertEquals(0, docMap.size());
    }

    @Test
    public void test_basic_operations() {
        Map<String, Object> parentMap = new HashMap<>();
        DocMap docMap = new DocMap(parentMap);

        assertNull(sentIndex.get());

        sentIndex.set(null);
        sentDocList.clear();
        docList.add(new HashMap<>(Map.of(//
                "_id", "001", //
                "config_id", "W01", //
                "url", "http://test.com/001"//
        )));
        docList.add(new HashMap<>(Map.of(//
                "_id", "002", //
                "thumbnail", "http://test.com/002", //

import static org.hamcrest.Matchers.greaterThanOrEqualTo;
import static org.hamcrest.Matchers.lessThanOrEqualTo;
import static org.junit.jupiter.api.Assertions.assertTrue;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.codelibs.fess.it.ITBase;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Tag;

    Map<String, String> hashmap = new HashMap<>();
    hashmap.put("foo", "bar");
    hashmap.put(null, "baz");

    StandardImplForwardingMap<String, String> forwardingMap =
        new StandardImplForwardingMap<>(new HashMap<>());
    forwardingMap.put("foo", "bar");
    forwardingMap.put(null, "baz");

    assertThat(forwardingMap.toString()).isEqualTo(hashmap.toString());
  }

        final Map<String, Object> attributes = new HashMap<>();

        authenticator.parseJwtClaim(jwtClaim, attributes);

        assertEquals(95.5, attributes.get("score"));
    }

    @Test
    public void test_parseJwtClaim_emptyObject() throws IOException {
        final String jwtClaim = "{}";
        final Map<String, Object> attributes = new HashMap<>();

        ArgumentCaptor<DfsReferralData> drCap = ArgumentCaptor.forClass(DfsReferralData.class);
        ArgumentCaptor<String> pathCap = ArgumentCaptor.forClass(String.class);
        verify(locator).handleDFSReferral(drCap.capture(), pathCap.capture());

        assertSame(referral, drCap.getValue());
        assertEquals(req, pathCap.getValue());
        verifyNoMoreInteractions(locator);
    }

        Map<String, String> andParams = new HashMap<>();
        andParams.put("q", query.replace("OR", "AND"));
        String andResponse = checkMethodBase(new HashMap<>()).params(andParams).get("/api/v1/documents").asString();
        int andRecordCount = JsonPath.from(andResponse).getInt("record_count");

        Map<String, String> params = new HashMap<>();
        params.put("q", query);

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.it.admin;

import static org.hamcrest.Matchers.equalTo;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.codelibs.fess.it.CrudTestBase;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Tag;

    }

    @Test
    void testGetTrustedDomains_Cached() throws SmbAuthException {
        Dfs.CacheEntry cacheEntry = new Dfs.CacheEntry(300);
        HashMap<String, HashMap> trustedDomains = new HashMap<>();
        trustedDomains.put("domain.com", new HashMap());
        cacheEntry.map = trustedDomains;
        dfs._domains = cacheEntry;

        assertEquals(trustedDomains, dfs.getTrustedDomains(auth));
    }