final Method equalsMethod = ClassUtil.getMethod(getClass(), "equals", Object.class);
        assertThat(MethodUtil.isHashCodeMethod(equalsMethod), is(not(true)));
    }

    /**
     *
     */
    @Test
    public void testIsToStringMethod() {
        final Method toStringMethod = ClassUtil.getMethod(getClass(), "toString");
        assertThat(MethodUtil.isToStringMethod(toStringMethod), is(true));

        return Modifier.isFinal(modifier);
    }

    /**
     * Checks if the specified method is final.
     *
     * @param method
     *            the method to check
     * @return true if final, false otherwise
     */
    public static boolean isFinal(final Method method) {
        return isFinal(method.getModifiers());
    }

    /**
     * Checks if the specified field is transient.
     *

   * rather than just the {@link RuntimeException} or {@link Error} that should be possible. (And in
   * fact the static type of {@link Throwable} is occasionally justified even for a method with no
   * {@code throws} clause: Some such methods can in fact throw a checked exception (e.g., by
   * calling code written in Kotlin).) Typically, we want to let a {@link Throwable} from such a

   * rather than just the {@link RuntimeException} or {@link Error} that should be possible. (And in
   * fact the static type of {@link Throwable} is occasionally justified even for a method with no
   * {@code throws} clause: Some such methods can in fact throw a checked exception (e.g., by
   * calling code written in Kotlin).) Typically, we want to let a {@link Throwable} from such a

    void testGetConfig() {
        // Test getConfig() method
        Configuration mockConfig = mock(Configuration.class);
        when(mockDelegate.getConfig()).thenReturn(mockConfig);
        assertEquals(mockConfig, cifsContextWrapper.getConfig());
        verify(mockDelegate).getConfig();
    }

    @Test
    void testGetDfs() {
        // Test getDfs() method
        DfsResolver mockDfsResolver = mock(DfsResolver.class);

    return emptySet();
  }

  private static Collection<Method> suppressForEmptySortedMap() {
    return emptySet();
  }

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

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

  protected Collection<Method> suppressForHashtable() {

                added("Method", "SourceKt.foo()"),
                added("Method", "SourceKt.fooExt(int)"),
                added("Method", "SourceKt.fooExt(java.lang.String)"),
                added("Method", "SourceKt.getBar()"),
                added("Method", "SourceKt.getBarExt(java.lang.String)"),
                added("Method", "SourceKt.getBazar()"),
                added("Method", "SourceKt.getBazarExt(int)"),

    }

    private boolean isPublicApi(CtMethod method) {
        return Modifier.isPublic(method.modifiers) || Modifier.isProtected(method.modifiers)
    }

    private List<String> filterChangesToReport(CtClass c, Set<CtMethod> methods) {
        return methods.findAll { isFirstPublicClassInHierarchy(it, c) }*.longName.sort()
    }

    private boolean isFirstPublicClassInHierarchy(CtMethod method, CtClass c) {

pkg sync/atomic, method (*Pointer[$0]) Load() *$0 #50860
pkg sync/atomic, method (*Pointer[$0]) Store(*$0) #50860
pkg sync/atomic, method (*Pointer[$0]) Swap(*$0) *$0 #50860
pkg sync/atomic, method (*Uint32) Add(uint32) uint32 #50860
pkg sync/atomic, method (*Uint32) CompareAndSwap(uint32, uint32) bool #50860
pkg sync/atomic, method (*Uint32) Load() uint32 #50860
pkg sync/atomic, method (*Uint32) Store(uint32) #50860

   * run finishes before the limit is reached, this method returns or a wrapped exception is
   * propagated. If, on the other hand, the time limit is reached, we attempt to abort the run, and
   * throw a {@link TimeoutException} to the caller.
   *
   * <p>The difference with {@link #runWithTimeout(Runnable, long, TimeUnit)} is that this method
   * will ignore interrupts on the current thread.