import java.lang.reflect.Method;
import java.math.BigInteger;
import junit.framework.TestCase;

/**
 * Tests for {@link DoubleUtils}.
 *
 * @author Louis Wasserman
 */
public class DoubleUtilsTest extends TestCase {
  @AndroidIncompatible // no FpUtils and no Math.nextDown in old versions
  public void testNextDown() throws Exception {
    Method jdkNextDown = getJdkNextDown();

 *
 * @since 4.0.0
 */
@Experimental
@Consumer
@Named
public interface ModelTransformer extends SpiService {

    /**
     * Apply a transformation on the file model.
     *
     * This method will be called on each file model being loaded,
     * just before validation.
     *
     * @param model the input model
     * @return the transformed model, or the input model if no transformation is needed

    expectContents(array);
  }

  /**
   * Returns the {@link Method} instance for {@link #testAdd_supportedNullPresent()} so that tests
   * can suppress it. See {@link CollectionAddTester#getAddNullSupportedMethod()} for details.
   */
  @J2ktIncompatible
  @GwtIncompatible // reflection
  public static Method getAddSupportedNullPresentMethod() {

import java.lang.reflect.Method;

/**
 * Context for an exception thrown by a subscriber.
 *
 * @since 16.0
 */
@ElementTypesAreNonnullByDefault
public class SubscriberExceptionContext {
  private final EventBus eventBus;
  private final Object event;
  private final Object subscriber;
  private final Method subscriberMethod;

  /**

   */
  @J2ktIncompatible
  @GwtIncompatible // reflection
  public static Method getListIteratorFullyModifiableMethod() {
    return getMethod(ListListIteratorTester.class, "testListIterator_fullyModifiable");
  }

  /**
   * Returns the {@link Method} instance for {@link #testListIterator_unmodifiable()} so that it can
   * be suppressed in GWT tests.
   */
  @J2ktIncompatible

    }

    def rendersLinkToApiMethod() {
        def method = method('someMethod', 'org.gradle.SomeClass')

        when:
        def link = renderer.link(method, listener)

        then:
        format(link) == '<apilink class="org.gradle.SomeClass" method="someMethod()"/>'
        _ * model.isKnownType('org.gradle.SomeClass') >> true
    }

    def method(String name, String className) {

        ) {
            assertHasErrors(
                "Method com.example.Source.plus(java.lang.String,java.util.List): Breaking Kotlin modifier change.",
                "Method com.example.Source.plus(int,java.util.List): Breaking Kotlin modifier change.",
                "Method com.example.SourceKt.invoke(java.lang.String,int): Breaking Kotlin modifier change.",
                "Method com.example.SourceKt.invoke(long,int): Breaking Kotlin modifier change.",

   * {@link Collections#frequency} (which would presumably perform more poorly).
   *
   * <p><b>Note:</b> the utility method {@link Iterables#frequency} generalizes this operation; it
   * correctly delegates to this method when dealing with a multiset, but it can also accept any
   * other iterable type.
   *
   * @param element the element to count occurrences of

      }
    };
  }

  @J2ktIncompatible
  @GwtIncompatible // java.lang.reflect
  private static Object invokeAccessibleNonThrowingMethod(
      Method method, Object receiver, Object... params) {
    try {
      return method.invoke(receiver, params);
    } catch (IllegalAccessException e) {
      throw new RuntimeException(e);
    } catch (InvocationTargetException e) {

    }

    private static final long serialVersionUID = 0;
  }

  /**
   * Returns {@link Method} instances for the tests that assume that the inverse will be the same
   * after serialization.
   */
  @J2ktIncompatible
  @GwtIncompatible // reflection
  public static List<Method> getInverseSameAfterSerializingMethods() {
    return Collections.singletonList(getMethod("testInverseSerialization"));
  }