// Properties not covered by equals()
    assertThat(graphA.allowsSelfLoops()).isEqualTo(graphB.allowsSelfLoops());
    assertThat(graphA.nodeOrder()).isEqualTo(graphB.nodeOrder());

    assertThat(graphA).isEqualTo(graphB);
  }

  static void assertStronglyEquivalent(ValueGraph<?, ?> graphA, ValueGraph<?, ?> graphB) {
    // Properties not covered by equals()

            if (f.equals(field)) {
                return true;
            }
        }
        return false;
    }

    public boolean isFacetField(final String field) {
        if (StringUtil.isBlank(field)) {
            return false;
        }
        boolean flag = false;
        for (final String f : facetFields) {
            if (field.equals(f)) {
                flag = true;

  }

  @Override
  public List<E> subList(int fromIndex, int toIndex) {
    return delegate().subList(fromIndex, toIndex);
  }

  @Override
  public boolean equals(@CheckForNull Object object) {
    return object == this || delegate().equals(object);
  }

  @Override
  public int hashCode() {
    return delegate().hashCode();
  }

  /**

        System.out.println(a.getScope());
        assertTrue(a.getScope().equals("test"), "Incorrect scope for " + a.getDependencyConflictId());

        // transitive dep, overridden b depMgmt
        assertTrue(b.getScope().equals("runtime"), "Incorrect scope for " + b.getDependencyConflictId());

        // direct dep, overrides depMgmt
        assertTrue(c.getScope().equals("runtime"), "Incorrect scope for " + c.getDependencyConflictId());
    }

          if (!resourceName.equals(JarFile.MANIFEST_NAME)) {
            builder.add(ResourceInfo.of(f, resourceName, classloader));
          }
        }
      }
    }

    @Override
    public boolean equals(@CheckForNull Object obj) {
      if (obj instanceof LocationInfo) {
        LocationInfo that = (LocationInfo) obj;
        return home.equals(that.home) && classloader.equals(that.classloader);

      </fields>
      <!-- prevent modello generation of an incorrect equals method. Could be avoided by using <identity/> tags to mark ID as the only identity field -->
      <codeSegments>
        <codeSegment>
          <version>1.0.0</version>
          <code><![CDATA[
            public boolean equals( Object obj )
            {
                return super.equals( obj );
            }
          ]]></code>
        </codeSegment>

        boolean makeBoth = MavenExecutionRequest.REACTOR_MAKE_BOTH.equals(makeBehavior);

        boolean makeUpstream = makeBoth || MavenExecutionRequest.REACTOR_MAKE_UPSTREAM.equals(makeBehavior);
        boolean makeDownstream = makeBoth || MavenExecutionRequest.REACTOR_MAKE_DOWNSTREAM.equals(makeBehavior);

        if ((makeBehavior != null && !makeBehavior.isEmpty()) && !makeUpstream && !makeDownstream) {

  }

  @Override
  public int hashCode() { // delegate to 's'
    return s.hashCode();
  }

  @Override
  public boolean equals(@Nullable Object other) {
    if (other == null) {
      return false;
    } else if (other instanceof BaseComparable) {
      return s.equals(((BaseComparable) other).s);
    } else {
      return false;
    }
  }

  @Override
  public int compareTo(BaseComparable o) {

        super(false);
        this.startTime = startTime;
        this.format = format;
    }

    public Object getValue(String expression) {
        if ("build.timestamp".equals(expression) || "maven.build.timestamp".equals(expression)) {
            if (formattedDate == null && startTime != null) {
                formattedDate = new SimpleDateFormat(format).format(startTime);
            }

    }
    public boolean equals( Object obj ) {
        Name n;

        if( !( obj instanceof Name )) {
            return false;
        }
        n = (Name)obj;
        if( scope == null && n.scope == null ) {
            return name.equals( n.name ) && hexCode == n.hexCode;
        }
        return name.equals( n.name ) && hexCode == n.hexCode && scope.equals( n.scope );
    }