try {
            return connect(loc);
        }
        catch ( UnknownHostException uhe ) {
            throw new SmbException("Failed to connect to server", uhe);
        }
        catch ( SmbException se ) {
            throw se;
        }
        catch ( IOException ioe ) {
            throw new SmbException("Failed to connect to server", ioe);
        }
    }

                    executor.execute(new ResolveTask(
                            classLoader, latch, artifact, session, node.getRemoteRepositories(), result));
                } else {
                    latch.countDown();
                }
            }
            try {
                latch.await();
            } catch (InterruptedException e) {
                result.addErrorArtifactException(

      } catch (ArithmeticException expected) {
      }
    }
  }

  @GwtIncompatible // DoubleMath.roundToInt(double, RoundingMode)
  public void testRoundNaNToIntAlwaysFails() {
    for (RoundingMode mode : ALL_ROUNDING_MODES) {
      try {
        DoubleMath.roundToInt(Double.NaN, mode);
        fail("Expected ArithmeticException");
      } catch (ArithmeticException expected) {
      }

    bestGetCheckedTypeValidator().validateClass(exceptionClass);
    try {
      return future.get(timeout, unit);
    } catch (InterruptedException e) {
      currentThread().interrupt();
      throw newWithCause(exceptionClass, e);
    } catch (TimeoutException e) {
      throw newWithCause(exceptionClass, e);
    } catch (ExecutionException e) {
      wrapAndThrowExceptionOrError(e.getCause(), exceptionClass);
      throw new AssertionError();

      fail();
    } catch (NumberFormatException expected) {
    } catch (IllegalArgumentException expected) {
      // Kotlin native, see above
    }

    try {
      UnsignedInts.parseUnsignedInt("0", Character.MAX_RADIX + 1);
      fail();
    } catch (NumberFormatException expected) {
    } catch (IllegalArgumentException expected) {
      // Kotlin native, see above

      table.at(1, 3);
      fail();
    } catch (IndexOutOfBoundsException expected) {
    }
    try {
      table.at(1, -1);
      fail();
    } catch (IndexOutOfBoundsException expected) {
    }
    try {
      table.at(3, 2);
      fail();
    } catch (IndexOutOfBoundsException expected) {
    }
    try {
      table.at(-1, 2);
      fail();
    } catch (IndexOutOfBoundsException expected) {
    }

      table.at(1, 3);
      fail();
    } catch (IndexOutOfBoundsException expected) {
    }
    try {
      table.at(1, -1);
      fail();
    } catch (IndexOutOfBoundsException expected) {
    }
    try {
      table.at(3, 2);
      fail();
    } catch (IndexOutOfBoundsException expected) {
    }
    try {
      table.at(-1, 2);
      fail();
    } catch (IndexOutOfBoundsException expected) {
    }

    } catch (ignored: IllegalArgumentException) {
    }
    try {
      builder.connectTimeout(Duration.ofNanos(1))
    } catch (ignored: IllegalArgumentException) {
    }
    try {
      builder.writeTimeout(Duration.ofNanos(1))
    } catch (ignored: IllegalArgumentException) {
    }
    try {
      builder.readTimeout(Duration.ofNanos(1))
    } catch (ignored: IllegalArgumentException) {
    }

      fail();
    } catch (IllegalArgumentException expected) {
    }

    try {
      Set<Set<Integer>> unused = powerSet(ContiguousSet.closed(0, Integer.MAX_VALUE / 2));
      fail();
    } catch (IllegalArgumentException expected) {
    }

    try {
      powerSet(singleton(null));
      fail();
    } catch (NullPointerException expected) {
    }
  }

        long defaultStackSize = 0;
        thread =
            bigThreadConstructor.newInstance(
                (ThreadGroup) null, finalizer, threadName, defaultStackSize, inheritThreadLocals);
      } catch (Throwable t) {
        logger.log(
            Level.INFO, "Failed to create a thread without inherited thread-local values", t);
      }
    }
    if (thread == null) {