ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
		BasicConstraintsValid: true,
	}

	hosts := strings.SplitSeq(host, ",")
	for h := range hosts {
		if ip := net.ParseIP(h); ip != nil {
			template.IPAddresses = append(template.IPAddresses, ip)
		} else {
			template.DNSNames = append(template.DNSNames, h)
		}
	}

	template.IsCA = true

        i += 4;

        assert i == body.length;
        return body;
    }

    /**
     * Build a CREATE response body with a single, unrecognized create context.
     * The parser should iterate it but produce an empty contexts array.
     */
    private static byte[] buildCreateBodyWithContext(byte[] fileId, int contextStartOffsetFromHeader) {

  } catch (_: NumberFormatException) {
    defaultValue
  }

/**
 * Returns this as a non-negative integer, or 0 if it is negative, or [Int.MAX_VALUE] if it is too
 * large, or [defaultValue] if it cannot be parsed.
 */
internal fun String?.toNonNegativeInt(defaultValue: Int): Int {
  try {
    val value = this?.toLong() ?: return defaultValue
    return when {
      value > Int.MAX_VALUE -> Int.MAX_VALUE

			ondiskTimestamp, err := time.Parse(time.RFC3339, tagTmStr)
			if err == nil {
				dstOpts.Internal.TaggingTimestamp = ondiskTimestamp
			}
		}
		if retTmStr, ok := lkMap.Lookup(ReservedMetadataPrefixLower + ObjectLockRetentionTimestamp); ok {
			ondiskTimestamp, err := time.Parse(time.RFC3339, retTmStr)
			if err == nil {

            "type": "type_error.integer"
        }
    ]
}
```

eine Textversion mit:

```
Validation errors:
Field: ('path', 'item_id'), Error: Input should be a valid integer, unable to parse string as an integer
```

### Überschreiben des `HTTPException`-Fehlerhandlers { #override-the-httpexception-error-handler }

Auf die gleiche Weise können Sie den `HTTPException`-Handler überschreiben.

```JSON
{
  "detail": [
    {
      "type": "int_parsing",
      "loc": [
        "path",
        "item_id"
      ],
      "msg": "Input should be a valid integer, unable to parse string as an integer",
      "input": "foo"
    }
  ]
}
```

porque o parâmetro de path `item_id` tinha o valor `"foo"`, que não é um `int`.

    This is useful when we use ConstrainedDecimal to represent Numeric(x,0)
    where an integer (but not int typed) is used. Encoding this as a float
    results in failed round-tripping between encode and parse.
    Our Id type is a prime example of this.

    >>> decimal_encoder(Decimal("1.0"))
    1.0

    >>> decimal_encoder(Decimal("1"))
    1

    >>> decimal_encoder(Decimal("NaN"))
    nan
    """

    static {
        try {
            NTLMSSP_OID = new ASN1ObjectIdentifier("1.3.6.1.4.1.311.2.2.10");
        } catch (final IllegalArgumentException e) {
            log.error("Failed to parse OID", e);
        }
    }

    private final NtlmPasswordAuthenticator auth;
    private int ntlmsspFlags;
    private final String workstation;
    private boolean isEstablished = false;

        state == STATE_WRITING_REQUEST_BODY ||
        state == STATE_READ_RESPONSE_HEADERS,
    ) {
      "state: $state"
    }

    try {
      val statusLine = StatusLine.parse(headersReader.readLine())

      val responseBuilder =
        Response
          .Builder()
          .protocol(statusLine.protocol)
          .code(statusLine.code)
          .message(statusLine.message)

        
        while (offset < data.length) {
            // Parse NETWORK_INTERFACE_INFO structure
            int next = readInt4(data, offset);
            int ifIndex = readInt4(data, offset + 4);
            int capability = readInt4(data, offset + 8);
            long linkSpeed = readInt8(data, offset + 16);
            
            // Parse socket address
            InetAddress addr = parseSockaddr(data, offset + 24);