notices within Derivative Works that You distribute, alongside
          or as an addendum to the NOTICE text from the Work, provided
          that such additional attribution notices cannot be construed
          as modifying the License.

      You may add Your own copyright statement to Your modifications and
      may provide additional or different license terms and conditions

   *
   * @param string the string representation of an integer value
   * @return the integer value represented by {@code string}, or {@code null} if {@code string} has
   *     a length of zero or cannot be parsed as an integer value
   * @throws NullPointerException if {@code string} is {@code null}
   * @since 11.0
   */
  public static @Nullable Integer tryParse(String string) {
    return tryParse(string, 10);

        assertEquals("STATIC_ROLE", secured.value()[0]);
    }

    // Test annotation on constructor (should not compile, but test for completeness)
    static class ConstructorClass {
        // Note: @Secured cannot be applied to constructors due to @Target restrictions
        public ConstructorClass() {
        }
    }

    public void test_constructorCannotBeAnnotated() throws NoSuchMethodException {

    consumer: (BufferedSource) -> T,
    sizeMapper: (T) -> Int,
  ): T {
    val contentLength = contentLength()
    if (contentLength > Int.MAX_VALUE) {
      throw IOException("Cannot buffer entire body for content length: $contentLength")
    }

    val bytes = source().use(consumer)
    val size = sizeMapper(bytes)
    if (contentLength != -1L && contentLength != size.toLong()) {

 *   x = null;  // Hint to the JIT that x is stack-unreachable
 *   return weakRef;
 * }
 * public void testFooLeak() {
 *   GcFinalization.awaitClear(fooWeakRef());
 * }
 * }
 *
 * <p>This class cannot currently be used to test soft references, since this class does not try to
 * create the memory pressure required to cause soft references to be cleared.
 *

            if (throwOnDecode) {
                throw new SMBProtocolDecodingException("Test decode error");
            }
            if (buffer == null) {
                throw new SMBProtocolDecodingException("Buffer cannot be null");
            }
            if (bufferIndex < 0 || len < 0) {
                throw new SMBProtocolDecodingException("Invalid buffer parameters");
            }
            if (bufferIndex + len > buffer.length) {

//   - marker if set should have a common prefix with 'prefix' param, otherwise
//     the request is rejected.
func validateListObjectsArgs(prefix, marker, delimiter, encodingType string, maxKeys int) APIErrorCode {
	// Max keys cannot be negative.
	if maxKeys < 0 {
		return ErrInvalidMaxKeys
	}

	if encodingType != "" {
		// AWS S3 spec only supports 'url' encoding type
		if !strings.EqualFold(encodingType, "url") {

// instead of the original node's output.
//
// Callers must also satisfy the following constraints:
// - `inputs` cannot refer to TF_Outputs within a control flow context. For
//   example, one cannot use the output of "switch" node as input.
// - `inputs` and `outputs` cannot have reference types. Reference types are
//   not exposed through C API and are being replaced with Resources. We support

 *   x = null;  // Hint to the JIT that x is stack-unreachable
 *   return weakRef;
 * }
 * public void testFooLeak() {
 *   GcFinalization.awaitClear(fooWeakRef());
 * }
 * }
 *
 * <p>This class cannot currently be used to test soft references, since this class does not try to
 * create the memory pressure required to cause soft references to be cleared.
 *

{* ../../docs_src/path_params/tutorial003.py hl[6,11] *}

Otherwise, the path for `/users/{user_id}` would match also for `/users/me`, "thinking" that it's receiving a parameter `user_id` with a value of `"me"`.

Similarly, you cannot redefine a path operation:

{* ../../docs_src/path_params/tutorial003b.py hl[6,11] *}

The first one will always be used since the path matches first.

## Predefined values { #predefined-values }