os.Versioned = versioned
	os.Suspended = suspended
	return os
}

// GetOpts returns ObjectOptions to fetch the object version that may be
// overwritten or deleted depending on bucket versioning status.
func (os *objSweeper) GetOpts() ObjectOptions {
	opts := ObjectOptions{
		VersionID:        os.VersionID,
		Versioned:        os.Versioned,
		VersionSuspended: os.Suspended,

		opts.ServerSideEncryption = encrypt.NewSSE()
	}

	return
}

// get ObjectOptions for GET calls from encryption headers
func getOpts(ctx context.Context, r *http.Request, bucket, object string) (ObjectOptions, error) {
	var opts ObjectOptions

	var partNumber int
	var err error
	if pn := r.Form.Get(xhttp.PartNumber); pn != "" {

		return
	}

	zipPath, object, err := splitZipExtensionPath(object)
	if err != nil {
		writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
		return
	}

	opts, err := getOpts(ctx, r, bucket, zipPath)
	if err != nil {
		writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
		return
	}

	getObjectInfo := objectAPI.GetObjectInfo

	// Check for auth type to return S3 compatible error.

		return
	}
	srcOpts.VersionID = vid

	// convert copy src and dst encryption options for GET/PUT calls
	getOpts := ObjectOptions{VersionID: srcOpts.VersionID}
	if srcOpts.ServerSideEncryption != nil {
		getOpts.ServerSideEncryption = encrypt.SSE(srcOpts.ServerSideEncryption)
	}

	dstOpts, err = copyDstOpts(ctx, r, dstBucket, dstObject, nil)
	if err != nil {

			return true
		}
		return checkCopyObjectPreconditions(ctx, w, r, o)
	}
	getOpts.CheckPrecondFn = checkCopyPrecondFn
	if cpSrcDstSame {
		getOpts.NoLock = true
	}

	var rs *HTTPRangeSpec
	gr, err := getObjectNInfo(ctx, srcBucket, srcObject, rs, r.Header, getOpts)
	if err != nil {
		if isErrPreconditionFailed(err) {
			return
		}

		}

		// If this not a WORM enabled bucket, we should return right here.
		return mode, retainDate, legalHold, ErrNone
	}

	opts, err := getOpts(ctx, rq, bucket, object)
	if err != nil {
		return mode, retainDate, legalHold, toAPIErrorCode(ctx, err)
	}

	replica := rq.Header.Get(xhttp.AmzBucketReplicationStatus) == replication.Replica.String()

        final SearchResultBuilder builder = SearchResult.create();
        searchResponseOpt.ifPresent(searchResponse -> {
            final SearchHits searchHits = searchResponse.getHits();
            builder.allRecordCount(searchHits.getTotalHits().value());
            builder.allRecordCountRelation(searchHits.getTotalHits().relation().toString());
            builder.queryTime(searchResponse.getTook().millis());

            assertEquals("seg" + (i + 1), kuromojiItem.getSegmentation());
            assertEquals("reading" + (i + 1), kuromojiItem.getReading());
            assertEquals("pos" + (i + 1), kuromojiItem.getPos());
            assertFalse(kuromojiItem.isUpdated());
            assertFalse(kuromojiItem.isUpdated());
        }
    }

    /*
    // TODO
    public void test_insert() {

                .setSize(fessConfig.getPageScoreBoosterMaxFetchSizeAsInteger())
                .execute()
                .actionGet(requestTimeout);
        return Arrays.stream(response.getHits().getHits()).map(SearchHit::getId).toArray(n -> new String[n]);
    };

    /**
     * A function to handle requests.
     */
    protected Function<Map<String, Object>, Long> requestHandler = params -> {

        String scrollId = response.getScrollId();
        try {
            while (scrollId != null) {
                final SearchHits searchHits = getSearchHits(response);
                final SearchHit[] hits = searchHits.getHits();
                if (hits.length == 0) {
                    break;
                }

                if (!handler.apply(searchHits)) {
                    break;
                }