message["content-type"] = content_type_value
                                if message.get_content_maintype() == "application":
                                    subtype = message.get_content_subtype()
                                    if subtype == "json" or subtype.endswith("+json"):
                                        json_body = await request.json()

    //                                                                            ========
    public String getContent() {
        checkSpecifiedProperty("content");
        return convertEmptyToNull(content);
    }

    public void setContent(String value) {
        registerModifiedProperty("content");
        this.content = value;
    }

    public String getCreatedBy() {

    //                                       ---------------
    protected final Map<String, PropertyGateway> _epgMap = newHashMap();
    {
        setupEpg(_epgMap, et -> ((RelatedContent) et).getContent(), (et, vl) -> ((RelatedContent) et).setContent(DfTypeUtil.toString(vl)),
                "content");
        setupEpg(_epgMap, et -> ((RelatedContent) et).getCreatedBy(),

        assertEquals("", documentHelper.getContent(null, responseData, "  ", dataMap));
        assertEquals("", documentHelper.getContent(null, responseData, "\t", dataMap));
        assertEquals("", documentHelper.getContent(null, responseData, "\t\t", dataMap));
        assertEquals("", documentHelper.getContent(null, responseData, "\t \t", dataMap));

            opLambda.callback(builder);
        }
    }

    public void setContent_Terms() {
        setContent_Terms(null);
    }

    public void setContent_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda) {
        setContent_Terms("content", opLambda, null);
    }

    public void setContent_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda, OperatorCall<BsRelatedContentCA> aggsLambda) {

        return this;
    }

    public void setContent_Equal(String content) {
        setContent_Term(content, null);
    }

    public void setContent_Equal(String content, ConditionOptionCall<TermQueryBuilder> opLambda) {
        setContent_Term(content, opLambda);
    }

    public void setContent_Term(String content) {
        setContent_Term(content, null);
    }

@Experimental
public interface XmlWriterRequest<T> {

    @Nullable
    Path getPath();

    @Nullable
    OutputStream getOutputStream();

    @Nullable
    Writer getWriter();

    @Nonnull
    T getContent();

    static <T> XmlWriterRequestBuilder<T> builder() {
        return new XmlWriterRequestBuilder<>();
    }

    class XmlWriterRequestBuilder<T> {
        Path path;
        OutputStream outputStream;

                .param("size", ComponentUtil.getFessConfig().getPageDictionaryMaxFetchSize()).execute()) {
            final Map<String, Object> contentMap = response.getContent(OpenSearchCurl.jsonParser());
            @SuppressWarnings("unchecked")
            final List<Map<String, Object>> fileList = (List<Map<String, Object>>) contentMap.get("file");

                } else {
                    pair.getSecond().add(new Pair<>(Pattern.compile(regex), entity.getContent()));
                }
            } else {
                pair.getFirst().put(toLowerCase(entity.getTerm()), entity.getContent());
            }
        });
        this.relatedContentMap = relatedContentMap;
        return relatedContentMap.size();
    }

	c.Assert(err, nil)
	c.Assert(response.StatusCode, http.StatusOK)
	// extract the content from response body.
	getContent, err := io.ReadAll(response.Body)
	c.Assert(err, nil)

	// Compare putContent and getContent.
	c.Assert(string(getContent), putContent)
}

// TestGetObjectLarge11MiB - Tests validate fetching of an object of size 11MB.