*
 * <ul>
 *   <li>Each {@code Closeable} resource that is successfully registered will be closed later.
 *   <li>If a {@code Throwable} is thrown in the try block, no exceptions that occur when attempting
 *       to close resources will be thrown from the finally block. The throwable from the try block
 *       will be thrown.
 *   <li>If no exceptions or errors were thrown in the try block, the <i>first</i> exception thrown

	// Check status code
	if rec.Code != test.wantStatusCode {
		t.Errorf("want status code %d, got %d", test.wantStatusCode, rec.Code)
	}

	// Check returned key list is correct
	if test.wantKeyNames != nil {
		keys := []madmin.KMSKeyInfo{}
		err := json.Unmarshal(rec.Body.Bytes(), &keys)
		if err != nil {
			t.Fatal(err)
		}
		if len(keys) != len(test.wantKeyNames) {

        } catch (final InvalidQueryException e) {
            if (logger.isDebugEnabled()) {
                logger.debug("Invalid query: {}", body.q, e);
            }
            throwValidationErrorApi(e.getMessageCode());
        } catch (final ResultOffsetExceededException e) {
            if (logger.isDebugEnabled()) {
                logger.debug("Invalid offset: {}", body.offset, e);

      case FIRST_PRESENT:
        if (list.contains(key)) {
          assertEquals(list.indexOf(key), answer);
          return;
        }
        break;
      case LAST_PRESENT:
        if (list.contains(key)) {
          assertEquals(list.lastIndexOf(key), answer);
          return;
        }
        break;
      case ANY_PRESENT:
        if (list.contains(key)) {

    /**
     * Executes the query.
     *
     * @param ps
     *            {@link PreparedStatement}. Must not be {@literal null}.
     * @return {@link ResultSet}
     * @throws SQLRuntimeException
     *             If a {@link SQLException} occurs.
     */
    public static ResultSet executeQuery(final PreparedStatement ps) throws SQLRuntimeException {
        assertArgumentNotNull("ps", ps);

        try {

		t.Run(fmt.Sprintf("test-%d", i+1), func(t *testing.T) {
			err := test.sizeFilter.Validate()
			if err != nil {
				gotErr := err.(BatchJobYamlErr)
				testErr := test.err.(BatchJobYamlErr)
				if gotErr.message() != testErr.message() {
					t.Fatalf("Expected %v but got %v", test.err, err)
				}
			}
			if err == nil && test.err != nil {
				t.Fatalf("Expected %v but got nil", test.err)
			}
		})
	}

  }

  /**
   * Returns an optional charset for the value of the charset parameter if it is specified.
   *
   * @throws IllegalStateException if multiple charset values have been set for this media type
   * @throws IllegalCharsetNameException if a charset value is present, but illegal
   * @throws UnsupportedCharsetException if a charset value is present, but no support is available
   *     in this instance of the Java virtual machine

    val flags = buf.readShort().toInt() and 0xffff
    require(flags shr 15 != 0) { "not a response" }

    val responseCode = flags and 0xf

    if (responseCode == NXDOMAIN) {
      throw UnknownHostException("$hostname: NXDOMAIN")
    } else if (responseCode == SERVFAIL) {
      throw UnknownHostException("$hostname: SERVFAIL")
    }

    val questionCount = buf.readShort().toInt() and 0xffff

     * @since 4.0.0
     */
    public InputLocation getImportedFrom() {
        return importedFrom;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        InputSource that = (InputSource) o;
        return Objects.equals(modelId, that.modelId)

    placeholder: e.g., 3.9 validations: required: false

-   type: input id: Bazel attributes: label: Bazel version description: if
    compiling from source placeholder: validations: required: false

-   type: input id: Compiler attributes: label: GCC/Compiler version
    description: if compiling from source placeholder: validations: required:
    false

-   type: input id: Cuda attributes: label: CUDA/cuDNN version description: