}

    @Override
    protected Map<String, Object> createTestParam(int id) {
        // Not used for this test
        return new HashMap<>();
    }

    @Override
    protected Map<String, Object> getUpdateMap() {
        // Not used for this test
        return new HashMap<>();
    }

    @Override
    @AfterEach
    protected void tearDown() {
        // Custom teardown in tearDownAll
    }

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.EnumMap;
import java.util.HashMap;
import java.util.Map;
import org.jspecify.annotations.Nullable;

/**
 * A {@code BiMap} backed by an {@code EnumMap} instance for keys-to-values, and a {@code HashMap}
 * instance for values-to-keys. Null keys are not permitted, but null values are. An {@code

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

        languageHelper.updateDocument(doc);

        // Should not add any language fields
        assertNull(doc.get("lang"));
        assertEquals(0, doc.size());
    }

    @Test
    public void test_updateDocument_skipExistingLangFields() {
        Map<String, Object> doc = new HashMap<>();
        doc.put("lang", "ja");

    @Override
    protected final Map<String, String> create(Entry<String, String>[] entries) {
      HashMap<String, String> map = new HashMap<>();
      for (Entry<String, String> entry : entries) {
        map.put(entry.getKey(), entry.getValue());
      }
      return wrap(map);
    }

    abstract Map<String, String> wrap(HashMap<String, String> map);
  }

  private static TestSuite wrappedHashMapTests(

        final Map<String, Object> requestBody = new HashMap<>();
        final String keyProp = NAME_PREFIX + id;
        requestBody.put(KEY_PROPERTY, keyProp);
        return requestBody;
    }

    private static final String NEW_SUFFIX = "_new";

    @Override
    protected Map<String, Object> getUpdateMap() {
        final Map<String, Object> requestBody = new HashMap<>();

    Map<String, Integer> underlying = new HashMap<>();
    underlying.put("a", 1);
    Map<String, String> map = transformValues(underlying, Functions.toStringFunction());
    assertThat(map.remove("a")).isEqualTo("1");
    assertThat(map.remove("b")).isNull();
  }

  public void testTransformEqualityOfMapsWithNullValues() {
    Map<String, @Nullable String> underlying = new HashMap<>();
    underlying.put("a", null);

            }
        });

        Map<String, Object> params = new HashMap<>();
        params.put("string_param", "test_value");
        params.put("int_param", 42);
        params.put("double_param", 3.14);
        params.put("boolean_param", true);

        Map<String, String> nestedMap = new HashMap<>();
        nestedMap.put("nested_key", "nested_value");
        params.put("nested_param", nestedMap);

    protected String getIdKey() {
        return "doc_id";
    }

    @Override
    protected Map<String, Object> createTestParam(int id) {
        final Map<String, Object> requestBody = new HashMap<>();
        final Map<String, Object> doc = new HashMap<>();
        final String keyProp = NAME_PREFIX + id;
        doc.put(KEY_PROPERTY, keyProp);
        doc.put("url", "http://example.com/" + id);
        doc.put("boost", id);

        Map<String, Object> docMap = new HashMap<>();
        docMap.put("mimetype", "application/pdf");
        assertTrue(thumbnailGenerator.isTarget(docMap));
    }

    @Test
    public void test_isTarget_withUnsupportedMimeType() {
        // Test with unsupported document type
        Map<String, Object> docMap = new HashMap<>();
        docMap.put("mimetype", "application/unknown");

            @Override
            public String getIndexAdminRequiredFields() {
                return "aaa,bbb";
            }
        };

        HashMap<String, Object> source = new HashMap<>();
        assertFalse(fessConfig.validateIndexRequiredFields(source));
        source.put("aaa", null);
        assertFalse(fessConfig.validateIndexRequiredFields(source));