active.isEmpty(), "Expected collection to be empty but had " + active.size() + " elements: " + active);
        assertEquals(1, problems.getErrors().size());
        assertEquals(
                "Failed to determine activation for profile one: BOOM",
                problems.getErrors().get(0));
    }

        context.put("basedir", "myBasedir");
        context.put("project.baseUri", "myBaseUri");
    }

    protected void assertProblemFree(SimpleProblemCollector collector) {
        assertEquals(0, collector.getErrors().size(), "Expected no errors");
        assertEquals(0, collector.getWarnings().size(), "Expected no warnings");
        assertEquals(0, collector.getFatals().size(), "Expected no fatals");
    }

        }

        final SuggestDeleteResponse deleteResponse = deleteByQuery(boolQuery);
        if (deleteResponse.hasError()) {
            throw new SuggestIndexException(deleteResponse.getErrors().get(0));
        }

        final List<SuggestItem> updateItems = new ArrayList<>();
        SearchResponse response = client.prepareSearch(index)
                .setSize(500)

        assertEquals(active, activator.isActive(new org.apache.maven.model.Profile(profile), context, problems));

        assertEquals(0, problems.getErrors().size(), problems.getErrors().toString());
        assertEquals(0, problems.getWarnings().size(), problems.getWarnings().toString());
    }

        if (repositories != null && mirrors != null) {
            for (ArtifactRepository repository : repositories) {
                Mirror mirror = getMirror(repository, mirrors);
                injectMirror(repository, mirror);
            }
        }
    }

    private Mirror getMirror(RepositorySystemSession session, ArtifactRepository repository) {
        if (session != null) {

     * @param mirrors The available mirrors, may be {@code null}.
     * @return The mirror specification for the repository or {@code null} if no mirror matched.
     */
    Mirror getMirror(ArtifactRepository repository, List<Mirror> mirrors);

        this.model = model;
    }

    public Model getModel() {
        return model;
    }

    public List<String> getWarnings() {
        return warnings;
    }

    public List<String> getErrors() {
        return errors;
    }

    public List<String> getFatals() {
        return fatals;
    }

    @Override
    public void add(ModelProblemCollectorRequest req) {

                effectivePolicy.merge(policy);
            }
        }

        return effectivePolicy;
    }

    @Override
    public Mirror getMirror(ArtifactRepository repository, List<Mirror> mirrors) {
        return mirrorSelector.getMirror(repository, mirrors);
    }

    @Override
    public void injectMirror(List<ArtifactRepository> repositories, List<Mirror> mirrors) {

     */
    public boolean deleteAllWords() {
        final SuggestDeleteResponse response = suggester.indexer().deleteAll();
        if (response.hasError()) {
            logger.warn("Failed to delete all words.", response.getErrors().get(0));
            return false;
        }
        refresh();
        return true;
    }

    /**
     * Deletes all document-based words from the suggest index.
     *

        assertEquals(0, channelInfo.getBytesSent());
        assertEquals(0, channelInfo.getBytesReceived());
        assertEquals(0, channelInfo.getRequestsSent());
        assertEquals(0, channelInfo.getErrors());

        channelInfo.addBytesSent(1000);
        channelInfo.addBytesReceived(2000);
        channelInfo.incrementRequestsSent();
        channelInfo.incrementErrors();