func (s StubKMS) ListKeys(ctx context.Context, req *ListRequest) ([]madmin.KMSKeyInfo, string, error) {
	matches := []madmin.KMSKeyInfo{}
	if req.Prefix == "" {
		req.Prefix = "*"
	}
	for _, keyName := range s.KeyNames {
		if wildcard.MatchAsPatternPrefix(req.Prefix, keyName) {
			matches = append(matches, madmin.KMSKeyInfo{Name: keyName, CreatedAt: StubCreatedAt, CreatedBy: StubCreatedBy})
		}
	}

	return matches, "", nil

* etc.

In these cases, you would normally return an **HTTP status code** in the range of **400** (from 400 to 499).

This is similar to the 200 HTTP status codes (from 200 to 299). Those "200" status codes mean that somehow there was a "success" in the request.

The status codes in the 400 range mean that there was an error from the client.

Remember all those **"404 Not Found"** errors (and jokes)?

          keyIndex++
        }
      }
    } while (cursor.next() != -1)
  }

  fun closeCodeExceptionMessage(code: Int): String? =
    if (code < 1000 || code >= 5000) {
      "Code must be in range [1000,5000): $code"
    } else if (code in 1004..1006 || code in 1015..2999) {
      "Code $code is reserved and may not be used."
    } else {
      null
    }

  fun validateCloseCode(code: Int) {

    // Compare to: "\u00c1".equalsIgnoreCase("\u00e1") == true
    assertFalse(Ascii.equalsIgnoreCase("\u00c1", "\u00e1"));
    // Test chars just outside the alphabetic range ('A'-1 vs 'a'-1, 'Z'+1 vs 'z'+1)
    assertFalse(Ascii.equalsIgnoreCase("@", "`"));
    assertFalse(Ascii.equalsIgnoreCase("[", "{"));
  }

  @GwtIncompatible // String.toUpperCase() has browser semantics

    return getExponent(d) <= MAX_EXPONENT;
  }

  static boolean isNormal(double d) {
    return getExponent(d) >= MIN_EXPONENT;
  }

  /*
   * Returns x scaled by a power of 2 such that it is in the range [1, 2). Assumes x is positive,
   * normal, and finite.
   */
  static double scaleNormalize(double x) {
    long significand = doubleToRawLongBits(x) & SIGNIFICAND_MASK;
    return longBitsToDouble(significand | ONE_BITS);

    // Compare to: "\u00c1".equalsIgnoreCase("\u00e1") == true
    assertFalse(Ascii.equalsIgnoreCase("\u00c1", "\u00e1"));
    // Test chars just outside the alphabetic range ('A'-1 vs 'a'-1, 'Z'+1 vs 'z'+1)
    assertFalse(Ascii.equalsIgnoreCase("@", "`"));
    assertFalse(Ascii.equalsIgnoreCase("[", "{"));
  }

  @GwtIncompatible // String.toUpperCase() has browser semantics

			expectStatus: 200,
		},
		{
			name:         "Client Error 400",
			statusCode:   400,
			body:         "bad-request",
			contentType:  "application/xml",
			expectStatus: 400,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			runObjectLambdaTest(t, tc.statusCode, tc.body, tc.contentType, tc.expectStatus)
		})
	}
}

)

var tformats = []string{
	layoutYear,
	layoutMonth,
	layoutDay,
	layoutMinute,
	layoutSecond,
	layoutNanosecond,
}

func parseSQLTimestamp(s string) (t time.Time, err error) {
	for _, f := range tformats {
		t, err = time.Parse(f, s)
		if err == nil {
			break
		}
	}
	return t, err
}

// FormatSQLTimestamp - returns the a string representation of the
// timestamp as used in S3 Select

      // This character doesn't need encoding. Just copy it over.
      writeUtf8CodePoint(codePoint)
    }
    i += Character.charCount(codePoint)
  }
}

/**
 * Returns a substring of `input` on the range `[pos..limit)` with the following
 * transformations:
 *
 *  * Tabs, newlines, form feeds and carriage returns are skipped.
 *
 *  * In queries, ' ' is encoded to '+' and '+' is encoded to "%2B".
 *

		// Valid case with existing object (Test number 12).
		{"test-getobjectinfo", "Asia/asiapics.jpg", resultCases[0], nil, true},
		{"test-getobjectinfo", "Asia/empty-dir/", resultCases[1], nil, true},
	}
	for i, testCase := range testCases {
		result, err := obj.GetObjectInfo(context.Background(), testCase.bucketName, testCase.objectName, opts)
		if err != nil && testCase.shouldPass {