public ImmutableBiMap<K, V> build() {
      return buildOrThrow();
    }

    @Override
    public ImmutableBiMap<K, V> buildOrThrow() {
      ImmutableMap<K, V> map = super.buildOrThrow();
      if (map.isEmpty()) {
        return of();
      }
      return new RegularImmutableBiMap<K, V>(super.buildOrThrow());
    }

    @Override
    ImmutableBiMap<K, V> buildJdkBacked() {
      return build();
    }

    @Override
    public Artifact createPluginArtifact(Plugin plugin) {
        VersionRange versionRange;
        try {
            String version = plugin.getVersion();
            if (version == null || version.isEmpty()) {
                version = "RELEASE";
            }
            versionRange = VersionRange.createFromVersionSpec(version);
        } catch (InvalidVersionSpecificationException e) {
            return null;

        }

        final Set<String> matchedLabelSet = ComponentUtil.getLabelTypeHelper().getMatchedLabelValueSet(url);
        if (!matchedLabelSet.isEmpty()) {
            final Set<String> newLabelSet = new HashSet<>();
            final String[] oldLabels = DocumentUtil.getValue(dataMap, fessConfig.getIndexFieldLabel(), String[].class);

     * @throws CrawlingAccessException if the bucket does not exist
     */
    protected StatObjectResponse getStatObject(final String bucketName, final String path) {
        if (StringUtil.isEmpty(path)) {
            return null;
        }

        try {
            final StatObjectArgs args = StatObjectArgs.builder().bucket(bucketName).object(path).build();
            return minioClient.statObject(args);

        String response = checkGetMethod(searchBody, "").asString();
        final Map<String, Object> res = JsonPath.from(response).getMap("response.setting");
        assertTrue(!res.isEmpty());
        assertEquals(Integer.valueOf(0), JsonPath.from(response).get("response.status"));
    }

    @Override
    protected void tearDown() {
        // do nothing
    }

    @Test

  public void testEmptyMap() {
    Map<Character, String> map = ImmutableMap.of();
    ArrayBasedEscaperMap fem = ArrayBasedEscaperMap.create(map);
    // Non-null array of zero length.
    assertThat(fem.getReplacementArray()).isEmpty();
  }

  public void testMapLength() {
    Map<Character, String> map =
        ImmutableMap.of(
            'a', "first",
            'z', "last");

    protected boolean canDetectActivation(Profile profile) {
        return profile.getActivation() != null
                && profile.getActivation().getJdk() != null
                && !profile.getActivation().getJdk().isEmpty();
    }

        assertEquals(pom0Basedir, project1.getParent().getBasedir());
        Set set = project1.getArtifacts();
        assertNotNull(set, "No artifacts");
        assertFalse(set.isEmpty(), "No Artifacts");

        for (Object aSet : set) {
            Artifact artifact = (Artifact) aSet;
            System.out.println("Artifact: " + artifact.getDependencyConflictId() + " " + artifact.getVersion()

        resourceManager.registerResource(resource);

        var activeResources = resourceManager.getActiveResources();
        assertNotNull(activeResources);
        assertFalse(activeResources.isEmpty());

        boolean found = activeResources.stream().anyMatch(desc -> desc.contains("TestResource"));
        assertTrue(found);
    }

    @Test

        void shouldReturnMeaningfulToString() {
            String result = transport.toString();
            assertTrue(result.startsWith("Transport"));
            assertFalse(result.isEmpty());
        }

        @Test
        @DisplayName("should handle response map operations")
        void shouldHandleResponseMapOperations() {
            assertEquals(0, transport.getResponseMapSize());