from .forward_reference_type import forwardref_method


def passthrough(f):
    @functools.wraps(f)
    def method(*args, **kwargs):
        return f(*args, **kwargs)

    return method


def test_wrapped_method_type_inference():
    """
    Regression test ensuring that when a method imported from another module
    is decorated with something that sets the __wrapped__ attribute (functools.wraps),

  abstract Graph<Integer> createGraph();

  /**
   * A proxy method that adds the node {@code n} to the graph being tested. In case of Immutable
   * graph implementations, this method should replace {@link #graph} with a new graph that includes
   * this node.
   */
  abstract void addNode(Integer n);

  /**
   * A proxy method that adds the edge {@code e} to the graph being tested. In case of Immutable

 */
package org.codelibs.core.exception;

import static org.codelibs.core.collection.ArrayUtil.asArray;

import java.lang.reflect.Method;

/**
 * Exception thrown when accessing a non-{@literal static} {@link Method} without specifying an object.
 *
 * @author koichik
 */
public class MethodNotStaticRuntimeException extends ClRuntimeException {

        assertFalse(info3.equals(info1));
    }

    @Test
    @DisplayName("Test equals method with same object")
    void testEqualsWithSameObject() {
        SmbShareInfo info = new SmbShareInfo(TEST_NET_NAME, TEST_TYPE, TEST_REMARK);
        assertTrue(info.equals(info));
    }

    @Test
    @DisplayName("Test equals method with different object type")
    void testEqualsWithDifferentObjectType() {

   * 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();

        return targetClass;
    }

    /**
     * Returns the method name.
     *
     * @return Method name
     */
    public String getMethodName() {
        return methodName;
    }

    /**
     * Returns the array of {@link Class} for the method arguments.
     *
     * @return Array of {@link Class} for the method arguments
     */
    public Class<?>[] getMethodArgClasses() {

    return emptySet();
  }

  protected Collection<Method> suppressForConcurrentLinkedQueue() {
    return emptySet();
  }

  protected Collection<Method> suppressForLinkedBlockingDeque() {
    return emptySet();
  }

  protected Collection<Method> suppressForLinkedBlockingQueue() {
    return emptySet();
  }

  protected Collection<Method> suppressForPriorityBlockingQueue() {

    for (Method method : testMethods) {
      suite.addTest(new CharSourceTester(factory, string, name, desc, method));
    }
    return suite;
  }

  private final ImmutableList<String> expectedLines;

  private CharSource source;

  public CharSourceTester(
      CharSourceFactory factory, String string, String suiteName, String caseDesc, Method method) {

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;

import java.lang.annotation.Target;

/**
 * Marks a method as an event subscriber.
 *
 * <p>The type of event will be indicated by the method's first (and only) parameter, which cannot
 * be primitive. If this annotation is applied to methods with zero parameters, or more than one
 * parameter, the object containing the method will not be able to register for event delivery from
 * the {@link EventBus}.
 *