public boolean hasOutput(long classId, long testId, TestOutputEvent.Destination destination) {
            if (dataFile == null) {
                return false;
            }

            Index index = getIndex(classId, testId);
            if (index == null) {
                return false;
            } else {
                Region region = destination == TestOutputEvent.Destination.StdOut ? index.stdOut : index.stdErr;

        boolQueryBuilder.mustNot(QueryBuilders.termQuery(FieldNames.KINDS, SuggestItem.Kind.USER.toString()));

        SuggestUtil.deleteByQuery(ComponentUtil.getSearchEngineClient(), suggester.settings(), suggester.getIndex(), boolQueryBuilder);
    }

    public void purgeSearchlogSuggest(final LocalDateTime time) {
        final BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        boolQueryBuilder

            if (response.isFailed()) {
                if (ignoreAlreadyExists) {
                    continue;
                }
                sb.append("\n[").append(i).append("]: index [").append(response.getIndex()).append("], id [").append(response.getId())
                        .append("], message [").append(response.getFailureMessage()).append("]");
            }
        }
        if (sb.length() > 0) {

        return new SuggestIndexer(client, getUpdateAlias(index), readingConverter, contentsReadingConverter, normalizer, analyzer,
                suggestSettings, threadPool);
    }

    public String getIndex() {
        return index;
    }

    public long getAllWordsNum() {
        return getNum(QueryBuilders.matchAllQuery());
    }

    public long getDocumentWordsNum() {

        final List<SuggestItem> firstItems = new ArrayList<>();
        final List<SuggestItem> secondItems = new ArrayList<>();

        final String index;
        if (hits.length > 0) {
            index = hits[0].getIndex();
        } else {
            index = SuggestConstants.EMPTY_STRING;
        }

        final boolean singleWordQuery = isSingleWordQuery(query);
        final boolean hiraganaQuery = isHiraganaQuery(query);

                    if (obj instanceof NestedExceptionPlaceholder) {
                        NestedExceptionPlaceholder placeholder = (NestedExceptionPlaceholder) obj;
                        int index = placeholder.getIndex();
                        switch (placeholder.getKind()) {
                            case cause:
                                return causes.get(index);
                            case suppressed:

            this.element = element;
            this.index = index;
        }

        public Element<T> getElement() {
            return element;
        }

        public Integer getIndex() {
            return index;
        }
    }

        int count = 0;
        for (String index : getIndexResponse.getIndices()) {
            if (index.startsWith(suggester.getIndex())) {
                count++;
            }
        }
        assertEquals(2, count);

        suggester.removeDisableIndices();

    get_item.emitOpError("found tf.TensorListGetItemOp on unknown TensorList.");
    return failure();
  }
  OpBuilder builder(get_item);
  auto index = cutil::ReshapeScalarToSizeType(builder, get_item.getIndex(),
                                              get_item.getLoc());
  auto element =
      cutil::GetElement(index, buffer, OpBuilder(get_item), get_item.getLoc());
  get_item.getItem().replaceAllUsesWith(element);

                    final BulkRequestBuilder bulkRequest = client.prepareBulk();
                    for (final SearchHit hit : hits) {
                        bulkRequest.add(client.prepareDelete().setIndex(hit.getIndex()).setId(hit.getId()));
                    }
                    return bulkRequest.execute();
                });
                if (bulkResponse.hasFailures()) {