},
                    {
                        "type": "other.Type",
                        "member": "Method other.Type.someMethod",
                        "changes": ["Method has been removed"],
                        "acceptation": "I really want to do this"
                    }
                ]
            }
        """])

        then:

     *
     * @param message the detail message. The detail message is saved for later retrieval by the {@link #getMessage()} method.
     * @param cause the cause (which is saved for later retrieval by the {@link #getCause()} method).
     *              (A {@code null} value is permitted, and indicates that the cause is nonexistent or unknown.)
     */

        ResponseData data = new ResponseData();

        RequestData child1 = new RequestData();
        child1.setMethod(Method.GET);
        child1.setUrl("https://example.com/page1");

        RequestData child2 = new RequestData();
        child2.setMethod(Method.GET);
        child2.setUrl("https://example.com/page2");

        // Add child URLs
        data.addChildUrl(child1);

   * original transformation and its inverse to a value gives you the original value give-or-take
   * numerical errors. Calling this method multiple times on the same instance will always return
   * the same instance. Calling this method on the result of calling this method on an instance will
   * always return that original instance.
   */
  public abstract LinearTransformation inverse();

/**
 * Basic implementation of the {@link ListMultimap} interface. It's a wrapper around {@link
 * AbstractMapBasedMultimap} that converts the returned collections into {@code Lists}. The {@link
 * #createCollection} method must return a {@code List}.
 *
 * @author Jared Levy
 * @since 2.0
 */
@GwtCompatible
abstract class AbstractListMultimap<K extends @Nullable Object, V extends @Nullable Object>

import junit.framework.TestCase;
import org.jspecify.annotations.Nullable;

/**
 * Abstract test case parent for anything implementing {@link ListenableFuture}. Tests the two get
 * methods and the addListener method.
 *
 * @author Sven Mawson
 * @since 10.0
 */
@GwtIncompatible
public abstract class AbstractListenableFutureTest extends TestCase {

  protected CountDownLatch latch;

/**
 * Marks an event subscriber method as being thread-safe. This annotation indicates that EventBus
 * may invoke the event subscriber simultaneously from multiple threads.
 *
 * <p>This does not mark the method, and so should be used in combination with {@link Subscribe}.
 *
 * @author Cliff Biffle
 * @since 10.0
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)

   *
   * <p>If {@code nodeU} and {@code nodeV} are not already present in this graph, this method will
   * silently {@link #addNode(Object) add} {@code nodeU} and {@code nodeV} to the graph.
   *
   * <p>If {@code edge} already connects {@code nodeU} to {@code nodeV} (in the specified order if
   * this network {@link #isDirected()}, else in any order), then this method will have no effect.
   *

   */
  @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

  }

  /**
   * Returns the {@link Method} instances for the test methods in this class which call {@code
   * hashCode()} on the set values so that set tests on unhashable objects can suppress it with
   * {@code FeatureSpecificTestSuiteBuilder.suppressing()}.
   */
  @J2ktIncompatible
  @GwtIncompatible // reflection
  public static Method[] getHashCodeMethods() {
    return new Method[] {