@Override
  protected boolean haveEqualReference(final EObject eObject1, final EObject eObject2, final EReference reference) {
    Object value1 = eObject1.eGet(reference);
    Object value2 = eObject2.eGet(reference);


    if (reference.isMany()) {

      // *** important change for Unordered Lists here:
      if (reference.isOrdered()) {
        return equals((List<EObject>) value1, (List<EObject>) value2);
      }

      /**
       * Handle Recursion or Bi Directional References. Only if they are containments, then we need to parse them
       * recursively. Otherwise is if it only association, then attribute level compare is enough.
       */
      boolean containment = reference.isContainment();
      if (containment) {
        return equalsUnOrdered((List<EObject>) value1, (List<EObject>) value2);
      }

      // In bidirectional references, if the object is the container of the current object being visited.
      // It can return true. You need not check on Containers.
      if (reference.isContainer()) {
        return true;
      }

      // Finally if we find out that they are not containments nor containers,
      // then they are treated as unorderedReferences.
      // These need to be compared only based on Attributes.
      return equalUnOrderedReferences((List<EObject>) value1, (List<EObject>) value2);
      // End of Compare.
    }

    if ((value1 != null) && (value2 != null)) {

      boolean containment = reference.isContainment();
      boolean equals = true;
      if (containment) {
        equals = equals((EObject) value1, (EObject) value2);
      }
      else if (reference.isContainer()) {
        equals = true;
      }
      else {
        equals = compareReferenceObject((EObject) value1, (EObject) value2);
      }
      return equals;
    }

    return true;
  }

  /**
   * @param value1
   * @param value2
   * @return
   */
  private boolean equalUnOrderedReferences(final List<EObject> list1, final List<EObject> list2) {
    if (list1.size() != list2.size()) {
      // return false;
      if (this.trace) {
        System.out.println("Reference Sizes is not Equal");
      }
      return false;
    }


    // save the Equal pairs: list1 Elements as Key and list2 Elements as Value
    Map<EObject, EObject> equalFound = new HashMap<EObject, EObject>();
    boolean result = true;
    for (EObject list1El : list1) {
      // try to find an equal Element for list1El in list2
      for (EObject list2El : list2) {
        // skip Elements of list2 that already have an equal Element in list1
        if (!equalFound.containsValue(list2El)) {
          // if list list1El is equal to list2El save it the Map
          // Being only a Reference, we need to compare only its Attributes and not its further references.
          // Therefore i get only the Attributes and validate them.
          result = compareReferenceObject(list1El, list2El);
          if (result) {
            equalFound.put(list1El, list2El);
            break;
          }
        }
      }

      // if no equal Element for listEl1 was found in list2, they couldn't be equal
      if (!equalFound.containsKey(list1El)) {
        return false;
      }

    }

    // For all Elements of list1 an own equal Element in list2 was found.
    return result;
  }

  /**
   * @param result
   * @param object1
   * @param object2
   * @return
   */
  private boolean compareReferenceObject(final EObject object1, final EObject object2) {
    boolean result = true;
    EList<EAttribute> eAllAttributes = object1.eClass().getEAllAttributes();
    for (EAttribute eAttribute : eAllAttributes) {
      if (!haveEqualAttribute(object1, object2, eAttribute)) {
        result = false;
        break;
      }
    }
    if (result) {
      compareMap.put(object1, object2);
    }
    else {
      compareMap.put(object1, null);
    }
    return result;
  }