*/
                getUninterruptibly(delegate);
              } catch (Throwable t) {
                // (including CancellationException and sneaky checked exception)
                // The task is presumably done, run the listeners.
                // TODO(cpovirk): Do *something* in case of Error (and maybe

   * - https://github.com/jspecify/jdk/commit/71d826792b8c7ef95d492c50a274deab938f2552
   */
  /*
   * TODO(cpovirk): Is the unchecked cast avoidable? Would System.arraycopy be similarly fast (if
   * likewise not type-checked)? Could our single caller do something different?
   */
  @SuppressWarnings({"nullness", "unchecked"})
  static <T extends @Nullable Object> T[] copy(Object[] source, int from, int to, T[] arrayOfType) {

                            if (logger.isDebugEnabled()) {
                                // Message below is checked for in the MNG-2199 core IT.
                                logger.warn("Failed to build parent project for " + project.getId(), e);
                            } else {
                                // Message below is checked for in the MNG-2199 core IT.

     * in O(n) time stepping through the two collections.
     */
    Iterator<E> thisIterator = iterator();

    Iterator<?> thatIterator = targets.iterator();
    // known nonempty since we checked targets.size() > 1

    if (!thisIterator.hasNext()) {
      return false;
    }

    Object target = thatIterator.next();
    E current = thisIterator.next();
    try {
      while (true) {

  static {
    AtomicHelper helper;
    Throwable thrownReflectionFailure = null;
    try {
      helper = new SafeAtomicHelper();
    } catch (Throwable reflectionFailure) { // sneaky checked exception
      // Some Android 5.0.x Samsung devices have bugs in JDK reflection APIs that cause
      // getDeclaredField to throw a NoSuchFieldException when the field is definitely there.

import jcifs.CIFSException;
import jcifs.SmbTransport;
import jcifs.SmbTree;

/**
 * Tests for SmbSessionInternal interface using Mockito to exercise
 * method contracts, checked exceptions, and interactions with collaborators.
 */
@ExtendWith(MockitoExtension.class)
public class SmbSessionInternalTest {

    @Mock
    private SmbSessionInternal session;

    @Mock

        this.strategies = strategies;
    }

    /**
     * Executes all applicable upgrade strategies in priority order.
     * Each strategy is checked for applicability before execution.
     *
     * @param context the upgrade context
     * @param pomMap map of all POM files in the project
     * @return the overall result of all strategy executions
     */

   * - https://github.com/jspecify/jdk/commit/71d826792b8c7ef95d492c50a274deab938f2552
   */
  /*
   * TODO(cpovirk): Is the unchecked cast avoidable? Would System.arraycopy be similarly fast (if
   * likewise not type-checked)? Could our single caller do something different?
   */
  @SuppressWarnings({"nullness", "unchecked"})
  static <T extends @Nullable Object> T[] copy(Object[] source, int from, int to, T[] arrayOfType) {

* Check and read the code, see if it makes sense, **run it locally** and see if it actually solves the problem.

* Then **comment** saying that you did that, that's how I will know you really checked it.

/// info

Unfortunately, I can't simply trust PRs that just have several approvals.

      Class<? extends Exception> exceptionClass) {
    try {
      Exception unused = newWithCause(exceptionClass, new Exception());
      return true;
    } catch (Throwable t) { // sneaky checked exception
      return false;
    }
  }

  private static <X extends Exception> X newWithCause(Class<X> exceptionClass, Throwable cause) {