final String json = new JsonIndexExportFormatter().format(source, Collections.emptySet());

        assertFalse(json.contains("field_with_null"));
    }

    @Test
    public void test_jsonFormatter_emptyMap() {
        final String json = new JsonIndexExportFormatter().format(Collections.emptyMap(), Collections.emptySet());

        assertTrue(json.contains("{"));

        assertEquals(Integer.valueOf(1), result.getRelevantIndexes().get(0));
    }

    @Test
    public void test_withRelevantDocs_emptyLists() {
        List<String> docIds = Collections.emptyList();
        List<Integer> indexes = Collections.emptyList();
        RelevanceEvaluationResult result = RelevanceEvaluationResult.withRelevantDocs(docIds, indexes);

        assertFalse(result.isHasRelevantResults());

                }

                children.add(new ResolutionNode(a, remoteRepositories, this));
            }
            children = Collections.unmodifiableList(children);
        } else {
            children = Collections.emptyList();
        }
        trail = null;
    }

    /**
     * @return {@link List} < {@link String} > with artifact ids

            final boolean hasRelevantResults) {
        this.relevantDocIds = relevantDocIds != null ? Collections.unmodifiableList(relevantDocIds) : Collections.emptyList();
        this.relevantIndexes = relevantIndexes != null ? Collections.unmodifiableList(relevantIndexes) : Collections.emptyList();
        this.hasRelevantResults = hasRelevantResults;
    }

    /**
     * Returns the list of relevant document IDs.

        userResult.setToolchains(Collections.singletonList(toolchain));

        props = new Properties();
        props.put("key", "global_value");
        toolchain = new ToolchainModel();
        toolchain.setType("TYPE");
        toolchain.setProvides(props);
        PersistedToolchains globalResult = new PersistedToolchains();
        globalResult.setToolchains(Collections.singletonList(toolchain));

import org.elasticsearch.common.util.set.Sets;
import org.elasticsearch.gateway.GatewayAllocator;
import org.elasticsearch.snapshots.EmptySnapshotsInfoService;

import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;

public final class Allocators {
    private static class NoopGatewayAllocator extends GatewayAllocator {

package org.codelibs.fess.api;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import jakarta.servlet.http.HttpServletRequest;

/**
 * Factory class for managing and retrieving web API managers.
 * This factory maintains a collection of web API managers and provides

        final Set<String> merged = new LinkedHashSet<>();

        if (array1 != null) {
            Collections.addAll(merged, array1);
        }

        if (array2 != null) {
            Collections.addAll(merged, array2);
        }

        return merged.toArray(new String[merged.size()]);
    }

    /**

            return "test query";
        }

        @Override
        public Map<String, String[]> getFields() {
            return Collections.emptyMap();
        }

        @Override
        public Map<String, String[]> getConditions() {
            return Collections.emptyMap();
        }

        @Override
        public String[] getLanguages() {
            return new String[0];
        }

 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.project;

import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;

import org.apache.maven.execution.MavenSession;
import org.apache.maven.lifecycle.DefaultLifecycles;