if (method.getOverrideSignature().equals(signature)) {
                return method;
            }
        }
        return null;
    }

    public List<MethodMetaData> findDeclaredMethods(String name) {
        List<MethodMetaData> methods = new ArrayList<MethodMetaData>();
        for (MethodMetaData method : declaredMethods) {
            if (method.getName().equals(name)) {
                methods.add(method);

   * #newListMultimap}, {@link #newSetMultimap} or {@link #newSortedSetMultimap} instead, to avoid
   * very surprising behavior from {@link Multimap#equals}.
   *
   * <p>The {@code factory}-generated and {@code map} classes determine the multimap iteration
   * order. They also specify the behavior of the {@code equals}, {@code hashCode}, and {@code
   * toString} methods for the multimap and its returned views. However, the multimap's {@code get}

        boolean found = false;
        for (Iterator<Plugin> i = plugins.iterator(); i.hasNext() && !found; ) {
            Plugin plugin = i.next();
            if (plugin.getPrefix().equals(goalPrefix)) {
                found = true;
            }
        }
        if (!found) {
            Plugin plugin = new Plugin();
            plugin.setPrefix(goalPrefix);

                                .getGenericReturnType();
                        if (returnType instanceof ParameterizedType) {
                            return !((ParameterizedType) returnType).getActualTypeArguments()[0].equals(String.class);
                        } else {
                            return false;
                        }
                    } catch (ReflectiveOperationException | SecurityException e) {

            if (releasedVersion.gradleVersion() > other.gradleVersion()) releasedVersion else other

        private
        fun GradleVersion.finalRelease() = this.equals(baseVersion)
    }

                .map(BuildModelSourceTransformer::toRelativeProject);

        if (mappedProject.isPresent()) {
            RelativeProject project = mappedProject.get();

            if (Objects.equals(groupId, project.getGroupId()) && Objects.equals(artifactId, project.getArtifactId())) {
                return mappedProject;
            }
        }
        return Optional.empty();
    }

                }
            }

            @Override
            public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
                if (Paths.get("target").equals(dir)) {
                    return FileVisitResult.CONTINUE;
                } else {
                    return FileVisitResult.SKIP_SUBTREE;
                }
            }
        });
    }

    @Override
    public String toString() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.toString();
    }

    @Override
    public boolean equals(@Nullable Object o) {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.equals(o);
    }

    @Override
    public int hashCode() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.hashCode();
    }

    @Override

 */
public class MethodUtilTest {

    /**
     * @throws Exception
     */
    @Test
    public void testIsEqualsMethod() throws Exception {
        final Method equalsMethod = ClassUtil.getMethod(getClass(), "equals", Object.class);
        assertThat(MethodUtil.isEqualsMethod(equalsMethod), is(true));
        final Method hashCodeMethod = ClassUtil.getMethod(getClass(), "hashCode");

       * which will have an efficient native implementation in JDK 9.
       *
       */
      String arch = System.getProperty("os.arch");
      if ("amd64".equals(arch) || "aarch64".equals(arch)) {
        theGetter =
            ByteOrder.nativeOrder().equals(ByteOrder.LITTLE_ENDIAN)
                ? UnsafeByteArray.UNSAFE_LITTLE_ENDIAN
                : UnsafeByteArray.UNSAFE_BIG_ENDIAN;
      }
    } catch (Throwable t) {