boolean reverse = false;

        if (test.startsWith("!")) {
            reverse = true;
            test = test.substring(1);
        }

        boolean result = actualArch.equals(test);

        return reverse ? !result : result;
    }

    private boolean determineNameMatch(String expectedName, String actualName) {
        String test = expectedName.toLowerCase(Locale.ENGLISH);

  /**
   * Returns an {@link ImmutableSortedSet} containing the same values in the given domain
   * {@linkplain RangeSet#contains contained} by this range set.
   *
   * <p><b>Note:</b> {@code a.asSet(d).equals(b.asSet(d))} does not imply {@code a.equals(b)}! For
   * example, {@code a} and {@code b} could be {@code [2..4]} and {@code (1..5)}, or the empty
   * ranges {@code [3..3)} and {@code [4..4)}.
   *

  }

  public void testEquals_immutableList() {
    Collection<String> c = ImmutableList.of("a", "b", "c");
    assertTrue(c.equals(ImmutableList.of("a", "b", "c")));
    assertFalse(c.equals(ImmutableList.of("a", "c", "b")));
    assertFalse(c.equals(ImmutableList.of("a", "b")));
    assertFalse(c.equals(ImmutableList.of("a", "b", "c", "d")));
  }

  public void testBuilderAdd() {
    ImmutableList<String> list =

   *
   * <p>Two {@code ListMultimap} instances are equal if, for each key, they contain the same values
   * in the same order. If the value orderings disagree, the multimaps will not be considered equal.
   */
  @Override
  public boolean equals(@Nullable Object object) {
    return super.equals(object);
  }

    Object[] params = new Object[paramTypes.length];
    for (int i = 0; i < paramTypes.length; i++) {
      Class<?> paramType = paramTypes[i];
      if (paramType.equals(String.class)) {
        params[i] = cause.toString();
      } else if (paramType.equals(Throwable.class)) {
        params[i] = cause;
      } else {
        return null;
      }
    }
    try {
      return constructor.newInstance(params);

                                && Objects.equals(this.name, that.name())
                                && Objects.equals(this.value, that.value())
                                && Objects.equals(this.attributes, that.attributes())
                                && Objects.equals(this.children, that.children());
            }

            @Override
            public int hashCode() {

        Set<Plugin> plugins;

        // NOTE: The upper-case packaging name is intentional, that's a special hinting mode used for certain tests
        if ("JAR".equals(packaging)) {
            plugins = new LinkedHashSet<>();

            plugins.add(newPlugin("maven-compiler-plugin", "compile", "testCompile"));

        Lifecycle lifecycleMapping = lifecycleMap.get(lifecycle);

        if (lifecycleMapping != null) {
            return lifecycleMapping.getLifecyclePhases();
        } else if ("default".equals(lifecycle)) {
            return phases;
        } else {
            return null;
        }
    }

    @Deprecated
    @Override
    public Map<String, String> getPhases(String lifecycle) {

    @ParametricNullness
    public K getElement() {
      return key;
    }

    void updateLastKnownIndex() {
      if (lastKnownIndex == -1
          || lastKnownIndex >= size()
          || !Objects.equals(key, keys[lastKnownIndex])) {
        lastKnownIndex = indexOf(key);
      }
    }

    @Override
    public int getCount() {
      updateLastKnownIndex();

    int lastEntryIndex = -1;
    do {
      int entryIndex = next - 1;
      int entry = entries[entryIndex];
      if (getHashPrefix(entry, mask) == hashPrefix
          && Objects.equals(key, keys[entryIndex])
          && (values == null || Objects.equals(value, values[entryIndex]))) {
        int newNext = getNext(entry, mask);
        if (lastEntryIndex == -1) {
          // we need to update the root link from table[]