is IllegalArgumentException -> {
          assertEquals("Android internal error", ioe.message)
        }

        is CertificateException -> {
          assertTrue(ioe.cause?.cause is IllegalArgumentException)
          assertEquals(
            true,
            ioe.cause
              ?.cause
              ?.message
              ?.startsWith("Invalid input to toASCII"),
          )
        }

        }
    }

    private void handleChecksumFailure(String checksumPolicy, String message, Throwable cause)
            throws ChecksumFailedException {
        if (ArtifactRepositoryPolicy.CHECKSUM_POLICY_FAIL.equals(checksumPolicy)) {
            throw new ChecksumFailedException(message, cause);
        } else if (!ArtifactRepositoryPolicy.CHECKSUM_POLICY_IGNORE.equals(checksumPolicy)) {

{* ../../docs_src/custom_response/tutorial009c_py310.py hl[9:14,17] *}

现在，不再是返回：

```json
{"message": "Hello World"}
```

...这个响应将返回：

```json
{
  "message": "Hello World"
}
```

当然，你很可能会找到比格式化 JSON 更好的方式来利用这一点。😉

### `orjson` 或响应模型 { #orjson-or-response-model }

            throw AssertionError("unsupported hashAlgorithm: ${pin.hashAlgorithm}")
          }
        }
      }
    }

    // If we couldn't find a matching pin, format a nice exception.
    val message =
      buildString {
        append("Certificate pinning failure!")
        append("\n  Peer certificate chain:")
        for (element in peerCertificates) {
          append("\n    ")

        try {
            ReflectionValueExtractor.evaluate("h.value[1]", new ValueHolder("string"));
        } catch (Exception e) {
            // TODO assert exception message
        }
    }

    /**
     * <p>testIllegalMappedType.</p>
     *
     * @throws Exception if any.
     */
    @Test
    public void testIllegalMappedType() throws Exception {

        String message = String.format(
            Locale.ROOT,
            "The %s must be set to a JDK installation directory for Java %d but is [%s] corresponding to [%s]",
            description,
            expectedVersion,
            javaHome,
            actualVersion
        );

        throw new GradleException(message);
    }

        put(inputStream(), RepositoryPlugin.PutOptions())
        println("Deployed ${file.name}")
      }
    } catch (e: IllegalArgumentException) {
      if ("Jar does not have a symbolic name" in e.message!!) {
        println("Skipped non-OSGi dependency: ${file.name}")
        return
      }
      throw e
    }
  }

  companion object {
    val fileSystem = FileSystem.SYSTEM

import jcifs.internal.smb2.ServerMessageBlock2;
import jcifs.internal.smb2.ServerMessageBlock2Request;
import jcifs.internal.smb2.Smb2Constants;
import jcifs.internal.util.SMBUtil;

/**
 * SMB2 Session Setup request message. This command is used to establish a security session
 * and authenticate a user to the server.
 *
 * @author mbechler
 *
 */

                                    "anyOf": [{"type": "string"}, {"type": "integer"}]
                                },
                            },
                            "msg": {"title": "Message", "type": "string"},
                            "type": {"title": "Error Type", "type": "string"},
                            "input": {"title": "Input"},

  }

  private void readObject(ObjectInputStream stream) throws InvalidObjectException {
    throw new InvalidObjectException("Use SerializedForm");
  }

  /** Hasher that updates a message digest. */
  private static final class MessageDigestHasher extends AbstractByteHasher {
    private final MessageDigest digest;
    private final int bytes;
    private boolean done;