options.addOption(Option.builder(Character.toString(NON_RECURSIVE))
                .longOpt("non-recursive")
                .desc(
                        "Do not recurse into sub-projects. When used together with -pl, do not recurse into sub-projects of selected aggregators")
                .build());
        options.addOption(Option.builder(Character.toString(UPDATE_SNAPSHOTS))
                .longOpt("update-snapshots")

        source = Buffer(),
      )

    assertFailsWith<EOFException> {
      parts.nextPart()
    }
  }

  /** Confirm that [MultipartBody] and [MultipartReader] can work together. */
  @Test fun `multipart round trip`() {
    val body =
      MultipartBody
        .Builder("boundary")
        .setType(MultipartBody.PARALLEL)

last came a rumbling of little cartwheels, and the sound of a
good many voices all talking together:  she made out the words:
`Where's the other ladder?--Why, I hadn't to bring but one;
Bill's got the other--Bill! fetch it here, lad!--Here, put 'em up
at this corner--No, tie 'em together first--they don't reach half
high enough yet--Oh! they'll do well enough; don't be particular--

See section `### HTML abbr elements` in the general prompt in `scripts/translate.py`.

////

## HTML "dfn" elements { #html-dfn-elements }

* <dfn title="A group of machines that are configured to be connected and work together in some way.">cluster</dfn>

    }
    // Check for leftovers.
    if (product > 1) {
      bignums.add(BigInteger.valueOf(product));
    }
    // Efficiently multiply all the intermediate products together.
    return listProduct(bignums).shiftLeft(shift);
  }

  static BigInteger listProduct(List<BigInteger> nums) {
    return listProduct(nums, 0, nums.size());
  }

last came a rumbling of little cartwheels, and the sound of a
good many voices all talking together:  she made out the words:
`Where's the other ladder?--Why, I hadn't to bring but one;
Bill's got the other--Bill! fetch it here, lad!--Here, put 'em up
at this corner--No, tie 'em together first--they don't reach half
high enough yet--Oh! they'll do well enough; don't be particular--

                    // Resource will be automatically closed
                }
            }, "Should work in try-with-resources");
        }

        @Test
        @DisplayName("multiple operations should work together")
        void testIntegratedOperations() throws CIFSException {
            // Given
            SmbResource resource = createMockResource();
            when(resource.exists()).thenReturn(true);

     * is still open. This value is either {@code FILE_NO_SHARE} or any
     * combination of {@code FILE_SHARE_READ}, {@code FILE_SHARE_WRITE},
     * and {@code FILE_SHARE_DELETE} logically OR'd together.
     *
     * @param   url A URL string
     * @param   auth The credentials the client should use for authentication
     * @param   shareAccess Specifies what access other clients have while this file is open.

 *         .catching(RpcException.class, e -> false, directExecutor());
 * }
 *
 * <h3>Alternatives</h3>
 *
 * <h4>Frameworks</h4>
 *
 * <p>When chaining together a graph of asynchronous operations, you will often find it easier to
 * use a framework. Frameworks automate the process, often adding features like monitoring,
 * debugging, and cancellation. Examples of frameworks include:
 *

   *   <li>The {@link Predicate} returned by this method catches {@link ClassCastException} and
   *       {@link NullPointerException}.
   *   <li>Code that chains multiple predicates together (especially negations) may be more readable
   *       using this method. For example, {@code not(in(target))} is generally more readable than
   *       {@code not(target::contains)}.