return; // someone else has run or is running.
    }

    boolean run = !isDone();
    T result = null;
    Throwable error = null;
    try {
      if (run) {
        result = runInterruptibly();
      }
    } catch (Throwable t) {
      restoreInterruptIfIsInterruptedException(t);
      error = t;
    } finally {

    static boolean updateByteBuffer(Checksum cs, ByteBuffer bb) {
      if (UPDATE_BB != null) {
        try {
          UPDATE_BB.invokeExact(cs, bb);
        } catch (Throwable e) {
          // `update` has no `throws` clause.
          sneakyThrow(e);
        }
        return true;
      } else {
        return false;
      }
    }

          route.address.url.toUri(),
          route.proxy.address(),
          e,
        )
      }
      user.connectFailed(route, null, e)
      return ConnectResult(plan = this, throwable = e)
    } finally {
      user.removePlanToCancel(this)
      if (!success) {
        rawSocket?.closeQuietly()
      }
    }
  }

  override fun connectTlsEtc(): ConnectResult {

        assertEquals("java.lang.RuntimeException: Root cause error", exception.getMessage());

        // Test with null cause
        TransportException nullCauseException = new TransportException((Throwable) null);
        assertNull(nullCauseException.getCause());
    }

    @Test
    @DisplayName("Test constructor with message and cause creates exception with both")
    public void testConstructorWithMessageAndCause() {

            if (hasReadMethod()) {
                return MethodUtil.invoke(readMethod, target, EMPTY_ARGS);
            }
            return FieldUtil.get(field, target);
        } catch (final Throwable t) {
            throw new IllegalPropertyRuntimeException(beanDesc.getBeanClass(), propertyName, t);
        }
    }

    @Override
    public void setValue(final Object target, final Object value) {

            return method.equals(getAllStatesMethod)
                ? getAllStates()
                : invokeListMethod(method, args);
          }

          private Set<List<Integer>> getAllStates() {
            return allStates;
          }

          private Object invokeListMethod(Method method, Object[] args) throws Throwable {
            try {

    }

    @Override
    void afterRanInterruptiblySuccess(@ParametricNullness V result) {
      TrustedListenableFutureTask.this.set(result);
    }

    @Override
    void afterRanInterruptiblyFailure(Throwable error) {
      setException(error);
    }

    @Override
    String toPendingString() {
      return callable.toString();
    }
  }

  @WeakOuter

     *            the target field
     * @param cause
     *            the cause
     */
    public BeanFieldSetAccessibleFailureException(final Class<?> componentClass, final Field targetField, final Throwable cause) {
        super("ECL0115", new Object[] { targetField }, cause);
        this.targetClass = componentClass;
        this.targetField = targetField;
    }

    /**
     * Returns the target class.
     *

     *            the target method
     * @param cause
     *            the cause
     */
    public BeanMethodSetAccessibleFailureException(final Class<?> componentClass, final Method targetMethod, final Throwable cause) {
        super("ECL0116", new Object[] { targetMethod }, cause);
        this.targetClass = componentClass;
        this.targetMethod = targetMethod;
    }

    /**
     * Returns the target class.
     *

    SmbAuthException(final int errcode) {
        super(errcode, null);
    }

    SmbAuthException(final String message) {
        super(message);
    }

    SmbAuthException(final String message, final Throwable cause) {
        super(message, cause);
    }