void invokeSubscriberMethod(Object event) throws InvocationTargetException {
    try {
      method.invoke(target, checkNotNull(event));
    } catch (IllegalArgumentException e) {
      throw new Error("Method rejected target/argument: " + event, e);
    } catch (IllegalAccessException e) {
      throw new Error("Method became inaccessible: " + event, e);
    } catch (InvocationTargetException e) {
      if (e.getCause() instanceof Error) {

    }

    public void test_constructor_withCauseChain() {
        // Test constructor with chained exceptions
        final Exception rootCause = new IllegalArgumentException("Invalid argument");
        final Exception middleCause = new RuntimeException("Runtime error", rootCause);
        final JobProcessingException exception = new JobProcessingException(middleCause);

        assertNotNull(exception);

     * Double.POSITIVE_INFINITY.
     */
    bits |= x.signum() & SIGN_MASK;
    return longBitsToDouble(bits);
  }

  /** Returns its argument if it is non-negative, zero if it is negative. */
  static double ensureNonNegative(double value) {
    checkArgument(!isNaN(value));
    return max(value, 0.0);
  }

        return prp.getProperty(key);
    }

    /**
     * Retrieve an <code>int</code>. If the key does not exist or
     * cannot be converted to an <code>int</code>, the provided default
     * argument will be returned.
     *
     * @param key the property key to look up
     * @param def the default value to return if the property is not found or cannot be parsed

    return future instanceof FluentFuture
        ? (FluentFuture<V>) future
        : new ForwardingFluentFuture<V>(future);
  }

  /**
   * Simply returns its argument.
   *
   * @deprecated no need to use this
   * @since 28.0
   */
  @InlineMe(
      replacement = "checkNotNull(future)",
      staticImports = "com.google.common.base.Preconditions.checkNotNull")

 *       <i>j</i><sup>th</sup> item in the <i>i</i><sup>th</sup> equality group, where both equality
 *       groups and the items within equality groups are numbered starting from 1. When either a
 *       constructor argument or an equal object is provided, that becomes group 1.
 * </ul>
 *
 * @author Jim McMaster
 * @author Jige Yu
 * @since 10.0
 */
@GwtCompatible
@NullMarked
public final class EqualsTester {

  were unnecessarily using `--node-ip` with an external cloud provider in 1.23,
  and then running into problems with 1.24, could not fix the problem by just
  removing the unnecessary `--node-ip` from the kubelet arguments, because
  that wouldn't remove the annotation that caused the problems.) ([#112184](https://github.com/kubernetes/kubernetes/pull/112184), [@danwinship](https://github.com/danwinship)) [SIG Network and Node]

        RequestParam rp = RequestParam.NO_RETRY;

        // Act: pass to the collaborator
        consumer.accept(rp);

        // Assert: interaction happened exactly once with correct argument; no other calls
        verify(consumer, times(1)).accept(RequestParam.NO_RETRY);
        verifyNoMoreInteractions(consumer);
    }

    @Nonnull
    Instant getStartTime();

    /**
     * Gets the directory of the topmost project being built, usually the current directory or the
     * directory pointed at by the {@code -f/--file} command line argument.
     *
     * @return the directory of the topmost project, never {@code null}
     * @see Project#isTopProject()
     * @see #getRootDirectory()
     */
    @Nonnull
    Path getTopDirectory();

    /**

    }

    /**
     * Indicates whether some other object is equal to this one.
     *
     * @param obj the reference object with which to compare
     * @return true if this object is the same as the obj argument; false otherwise
     */
    @Override
    public boolean equals(final Object obj) {
        return inputStream.equals(obj);
    }

    /**
     * Returns a hash code value for the object.
     *