def test_body_repr_str():
    assert repr(Body("teststr")) == "Body(teststr)"


def test_body_repr_none():
    assert repr(Body(None)) == "Body(None)"


def test_body_repr_ellipsis():
    assert repr(Body(...)) == "Body(PydanticUndefined)"


def test_body_repr_number():
    assert repr(Body(1)) == "Body(1)"


def test_body_repr_list():

     * @param body the request body containing synonym item information
     * @return JSON response with result status
     */
    // POST /api/admin/dict/synonym/setting/{dictId}
    @Execute
    public JsonResponse<ApiResult> post$setting(final String dictId, final CreateBody body) {
        body.dictId = dictId;
        validateApi(body, messages -> {});
        body.crudMode = CrudMode.CREATE;

      message = "moved to val",
      replaceWith = ReplaceWith(expression = "body"),
      level = DeprecationLevel.ERROR,
    )
    fun body(): RequestBody = body

    companion object {
      @JvmStatic
      fun create(body: RequestBody): Part = create(null, body)

      @JvmStatic
      fun create(
        headers: Headers?,
        body: RequestBody,
      ): Part {

     *
     * @param body path mapping setting data to create
     * @return JSON response with created setting ID and status
     */
    @Execute
    public JsonResponse<ApiResult> post$setting(final CreateBody body) {
        validateApi(body, messages -> {});
        body.crudMode = CrudMode.CREATE;
        final PathMapping entity = getPathMapping(body).orElseGet(() -> {

     *
     * @param body related content setting data to create
     * @return JSON response with created setting ID and status
     */
    @Execute
    public JsonResponse<ApiResult> post$setting(final CreateBody body) {
        validateApi(body, messages -> {});
        body.crudMode = CrudMode.CREATE;
        final RelatedContent relatedContent = getRelatedContent(body).map(entity -> {
            try {

    open fun head(): Builder = method("HEAD", null)

    open fun post(body: RequestBody): Builder = method("POST", body)

    @JvmOverloads
    open fun delete(body: RequestBody? = RequestBody.EMPTY): Builder = method("DELETE", body)

    open fun put(body: RequestBody): Builder = method("PUT", body)

    open fun patch(body: RequestBody): Builder = method("PATCH", body)

    /**
     * Sets this request's method to `QUERY`.

     *
     * @param body the request body containing updated bad word information
     * @return JSON response with result status
     */
    @Execute
    public JsonResponse<ApiResult> put$setting(final EditBody body) {
        validateApi(body, messages -> {});
        body.crudMode = CrudMode.EDIT;
        final BadWord badWord = getBadWord(body).map(entity -> {
            try {

    assertThat(body.name(1)).isEqualTo("space, the")
    assertThat(body.name(2)).isEqualTo("%25")
    assertThat(body.encodedValue(0)).isEqualTo("c%2B%3D%26+d")
    assertThat(body.encodedValue(1)).isEqualTo("final+frontier")
    assertThat(body.encodedValue(2)).isEqualTo("%2525")
    assertThat(body.value(0)).isEqualTo("c+=& d")
    assertThat(body.value(1)).isEqualTo("final frontier")
    assertThat(body.value(2)).isEqualTo("%25")

      }

    public fun body(body: Buffer): Builder = body(body.toMockResponseBody())

    public fun body(body: MockResponseBody): Builder =
      apply {
        setHeader("Content-Length", body.contentLength)
        this.body = body
      }

    /** Sets the response body to the UTF-8 encoded bytes of [body]. */
    public fun body(body: String): Builder = body(Buffer().writeUtf8(body))

     *
     * @param body the web configuration data to create
     * @return JSON response containing the created web configuration setting ID
     */
    // POST /api/admin/webconfig/setting
    @Execute
    public JsonResponse<ApiResult> post$setting(final CreateBody body) {
        validateApi(body, messages -> {});
        body.crudMode = CrudMode.CREATE;