"loc": [
                "path",
                "item_id"
            ],
            "msg": "value is not a valid integer",
            "type": "type_error.integer"
        }
    ]
}
```

以下のようなテキスト版を取得します:

```
1 validation error
path -> item_id
  value is not a valid integer (type=type_error.integer)
```

#### `RequestValidationError`と`ValidationError`

/// warning | 注意

Assim, `0.5` seria um valor válido. Mas `0.0` ou `0` não seria.

E o mesmo para <abbr title="less than"><code>lt</code></abbr>.

{* ../../docs_src/path_params_numeric_validations/tutorial006.py hl[11] *}

## Recapitulando

    @Test
    @DisplayName("Should handle interface method contracts")
    void testMethodContracts() {
        // The interface should allow for various implementations
        // Test that methods can return any valid values

        // Names can be any string
        when(mockNetbiosName.getName()).thenReturn("ANYNAME");
        assertNotNull(mockNetbiosName.getName());

        // Scope can be null or any string

        m.ptype = 0; // Request type
        NdrBuffer buf = new NdrBuffer(new byte[1024], 0);
        m.encode(buf);

        buf.setIndex(0);
        // Decode will throw exception as ptype 0 is not a valid response type
        assertThrows(NdrException.class, () -> m.decode(buf));
    }

    @Test
    void testRoundTripEncodeDecodeForResponseType() throws Exception {

But this example is still valid and it shows how to interact with the internal components.

///

We can also use this same approach to access the request body in an exception handler.

	runtime_arena_arena_Slice(a.a, &sl, cap)
	return sl[:len]
}

// Clone makes a shallow copy of the input value that is no longer bound to any
// arena it may have been allocated from, returning the copy. If it was not
// allocated from an arena, it is returned untouched. This function is useful
// to more easily let an arena-allocated value out-live its arena.
// T must be a pointer, a slice, or a string, otherwise this function will panic.

 * String normalized = normalizer.normalize("ｶﾞｷﾞｸﾞｹﾞｺﾞ", "field");
 * System.out.println(normalized); // Outputs: ガギグゲゴ
 * }
 * </pre>
 *
 * <p>Note: This class assumes that the input string contains valid Hankaku Kana characters
 * and does not perform any validation on the input.</p>
 *
 * @see Normalizer
 */
public class HankakuKanaToZenkakuKana implements Normalizer {
    /**

		Name:   name,
		Method: Deflate,
	}
	return w.CreateHeader(header)
}

// detectUTF8 reports whether s is a valid UTF-8 string, and whether the string
// must be considered UTF-8 encoding (i.e., not compatible with CP-437, ASCII,
// or any other common encoding).
func detectUTF8(s string) (valid, require bool) {
	for i := 0; i < len(s); {
		r, size := utf8.DecodeRuneInString(s[i:])
		i += size

        assertEquals(SsoResponseType.METADATA, values[0]);
        assertEquals(SsoResponseType.LOGOUT, values[1]);
    }

    public void test_valueOf() {
        // Test valueOf for valid enum names
        assertEquals(SsoResponseType.METADATA, SsoResponseType.valueOf("METADATA"));
        assertEquals(SsoResponseType.LOGOUT, SsoResponseType.valueOf("LOGOUT"));
    }

    val responseString = decompressed.body.string()
    assertThat(responseString).isEqualTo("hello unknown algorithm world")
  }

  @Test
  fun testFailsDecompress() {
    val s = "this is not valid zstd".encodeUtf8()

    val response =
      response("https://example.com/", s) {
        header("Content-Encoding", "zstd")
      }

    val decompressed = zstdInterceptor.decompress(response)