public void unregister(final Class<?> eventType, final Object target, final Method method) {
   if (listeners != null) {
     ListenerMethod toBeRemove =
         Iterators.find(
             listeners.iterator(),
             new Predicate<ListenerMethod>() {
               @Override
               public boolean apply(ListenerMethod m) {
                 return m.matches(eventType, target, method);
               }
             });
     if (toBeRemove != null) {
       listeners.remove(toBeRemove);
     }
   }
 }
  private void testAB1(TestKind kind, final Comparison comparison) {
    final List<Diff> differences = comparison.getDifferences();

    // We should have no less and no more than 5 differences
    // Was 6 with UML 4.0 but NamedElement::clientDependency has been made derived in UML 5.0
    assertEquals(5, differences.size());

    Predicate<? super Diff> addInterfaceRealizationDescription = null;
    Predicate<? super Diff> addClientInInterfaceRealizationDescription = null;
    Predicate<? super Diff> addSupplierInInterfaceRealizationDescription = null;
    Predicate<? super Diff> addContractInInterfaceRealizationDescription = null;

    if (kind.equals(TestKind.DELETE)) {
      addInterfaceRealizationDescription =
          removedFromReference("model.Class0", "substitution", "model.Class0.Substitution0");
      addClientInInterfaceRealizationDescription =
          removedFromReference("model.Class0.Substitution0", "client", "model.Class0");
      addSupplierInInterfaceRealizationDescription =
          removedFromReference("model.Class0.Substitution0", "supplier", "model.Class1");
      addContractInInterfaceRealizationDescription =
          changedReference("model.Class0.Substitution0", "contract", "model.Class1", null);
    } else {
      addInterfaceRealizationDescription =
          addedToReference(
              "model.Class0",
              "substitution", //$NON-NLS-1$
              "model.Class0.Substitution0");
      addClientInInterfaceRealizationDescription =
          addedToReference("model.Class0.Substitution0", "client", "model.Class0");
      addSupplierInInterfaceRealizationDescription =
          addedToReference("model.Class0.Substitution0", "supplier", "model.Class1");
      addContractInInterfaceRealizationDescription =
          changedReference("model.Class0.Substitution0", "contract", null, "model.Class1");
    }

    final Diff addInterfaceRealization =
        Iterators.find(differences.iterator(), addInterfaceRealizationDescription);
    final Diff addClientInInterfaceRealization =
        Iterators.find(differences.iterator(), addClientInInterfaceRealizationDescription);
    final Diff addSupplierInInterfaceRealization =
        Iterators.find(differences.iterator(), addSupplierInInterfaceRealizationDescription);
    final Diff addContractInInterfaceRealization =
        Iterators.find(differences.iterator(), addContractInInterfaceRealizationDescription);

    assertNotNull(addInterfaceRealization);
    assertNotNull(addClientInInterfaceRealization);
    assertNotNull(addSupplierInInterfaceRealization);
    assertNotNull(addContractInInterfaceRealization);

    // CHECK EXTENSION
    assertEquals(1, count(differences, instanceOf(DirectedRelationshipChange.class)));
    Diff addUMLDependency = null;
    if (kind.equals(TestKind.ADD)) {
      addUMLDependency =
          Iterators.find(
              differences.iterator(),
              and(instanceOf(DirectedRelationshipChange.class), ofKind(DifferenceKind.ADD)));
    } else {
      addUMLDependency =
          Iterators.find(
              differences.iterator(),
              and(instanceOf(DirectedRelationshipChange.class), ofKind(DifferenceKind.DELETE)));
    }
    assertNotNull(addUMLDependency);
    assertEquals(4, addUMLDependency.getRefinedBy().size());
    assertTrue(addUMLDependency.getRefinedBy().contains(addClientInInterfaceRealization));
    assertTrue(addUMLDependency.getRefinedBy().contains(addSupplierInInterfaceRealization));
    assertTrue(addUMLDependency.getRefinedBy().contains(addContractInInterfaceRealization));
    assertTrue(addUMLDependency.getRefinedBy().contains(addInterfaceRealization));

    // CHECK REQUIREMENT
    if (kind.equals(TestKind.ADD)) {
      assertEquals(1, addClientInInterfaceRealization.getRequires().size());
      assertTrue(addClientInInterfaceRealization.getRequires().contains(addInterfaceRealization));
      assertEquals(1, addSupplierInInterfaceRealization.getRequires().size());
      assertTrue(addSupplierInInterfaceRealization.getRequires().contains(addInterfaceRealization));
      assertEquals(1, addContractInInterfaceRealization.getRequires().size());
      assertTrue(addContractInInterfaceRealization.getRequires().contains(addInterfaceRealization));

      assertEquals(0, addInterfaceRealization.getRequires().size());
      assertEquals(0, addUMLDependency.getRequires().size());
    } else {
      assertEquals(0, addClientInInterfaceRealization.getRequires().size());
      assertEquals(0, addSupplierInInterfaceRealization.getRequires().size());
      assertEquals(0, addContractInInterfaceRealization.getRequires().size());

      assertEquals(3, addInterfaceRealization.getRequires().size());
      assertTrue(addInterfaceRealization.getRequires().contains(addClientInInterfaceRealization));
      assertTrue(addInterfaceRealization.getRequires().contains(addSupplierInInterfaceRealization));
      assertTrue(addInterfaceRealization.getRequires().contains(addContractInInterfaceRealization));

      assertEquals(0, addUMLDependency.getRequires().size());
    }

    // CHECK EQUIVALENCE
    assertEquals(0, comparison.getEquivalences().size());
    assertNull(addClientInInterfaceRealization.getEquivalence());

    testIntersections(comparison);
  }
Example #3
0
  @Test
  @Ignore
  public void testConflicts() throws IOException {
    final Resource left = inputData.getExtlibraryLeft();
    final Resource origin = inputData.getExtlibraryOrigin();
    final Resource right = inputData.getExtlibraryRight();

    final IComparisonScope scope = EMFCompare.createDefaultScope(left, right, origin);
    final Comparison comparison = EMFCompare.builder().build().compare(scope);
    final List<Diff> differences = comparison.getDifferences();

    final Predicate<? super Diff> rightAudiovisualName =
        and(
            fromSide(DifferenceSource.RIGHT),
            changedAttribute(
                "extlibrary.AudioVisualItem.length", "name", "minutesLength", "minutes"));
    final Predicate<? super Diff> leftAudiovisualName =
        and(
            fromSide(DifferenceSource.LEFT),
            changedAttribute(
                "extlibrary.AudioVisualItem.length", "name", "minutesLength", "length"));

    final Diff rightAudiovisualNameDiff =
        Iterators.find(differences.iterator(), rightAudiovisualName);
    final Diff leftAudiovisualNameDiff =
        Iterators.find(differences.iterator(), leftAudiovisualName);

    final Conflict audiovisualNameConflict = rightAudiovisualNameDiff.getConflict();
    assertNotNull(audiovisualNameConflict);
    assertSame(
        Integer.valueOf(2), Integer.valueOf(audiovisualNameConflict.getDifferences().size()));
    assertTrue(audiovisualNameConflict.getDifferences().contains(rightAudiovisualNameDiff));
    assertTrue(audiovisualNameConflict.getDifferences().contains(leftAudiovisualNameDiff));
    assertSame(audiovisualNameConflict, leftAudiovisualNameDiff.getConflict());
    assertSame(ConflictKind.REAL, audiovisualNameConflict.getKind());

    final Predicate<? super Diff> rightRemovedReader =
        and(fromSide(DifferenceSource.RIGHT), removed("extlibrary.BookOnTape.reader"));
    final Predicate<? super Diff> rightUnsetReaderType =
        and(
            fromSide(DifferenceSource.RIGHT),
            changedReference("extlibrary.BookOnTape.reader", "eType", "extlibrary.Person", null));
    final Predicate<? super Diff> leftRemovedReader =
        and(fromSide(DifferenceSource.LEFT), removed("extlibrary.BookOnTape.reader"));
    final Predicate<? super Diff> leftUnsetReaderType =
        and(
            fromSide(DifferenceSource.LEFT),
            changedReference("extlibrary.BookOnTape.reader", "eType", "extlibrary.Person", null));

    final Diff rightRemovedReaderDiff = Iterators.find(differences.iterator(), rightRemovedReader);
    final Diff rightUnsetReaderTypeDiff =
        Iterators.find(differences.iterator(), rightUnsetReaderType);
    final Diff leftRemovedReaderDiff = Iterators.find(differences.iterator(), leftRemovedReader);
    final Diff leftUnsetReaderTypeDiff =
        Iterators.find(differences.iterator(), leftUnsetReaderType);

    final Conflict readerConflict = rightRemovedReaderDiff.getConflict();
    assertNotNull(readerConflict);
    assertSame(Integer.valueOf(4), Integer.valueOf(readerConflict.getDifferences().size()));
    assertTrue(readerConflict.getDifferences().contains(rightRemovedReaderDiff));
    assertTrue(readerConflict.getDifferences().contains(rightUnsetReaderTypeDiff));
    assertTrue(readerConflict.getDifferences().contains(leftRemovedReaderDiff));
    assertTrue(readerConflict.getDifferences().contains(leftUnsetReaderTypeDiff));
    assertSame(readerConflict, rightUnsetReaderTypeDiff.getConflict());
    assertSame(readerConflict, leftRemovedReaderDiff.getConflict());
    assertSame(readerConflict, leftUnsetReaderTypeDiff.getConflict());
    assertSame(ConflictKind.PSEUDO, readerConflict.getKind());

    final Predicate<? super Diff> rightRenamedFamilyname =
        and(
            fromSide(DifferenceSource.RIGHT),
            changedAttribute("extlibrary.Person.familyName", "name", "lastName", "familyName"));
    final Predicate<? super Diff> leftRemovedLastname =
        and(fromSide(DifferenceSource.LEFT), removed("extlibrary.Person.lastName"));

    final Diff rightRenamedFamilyNameDiff =
        Iterators.find(differences.iterator(), rightRenamedFamilyname);
    final Diff leftRemovedLastNameDiff =
        Iterators.find(differences.iterator(), leftRemovedLastname);

    final Conflict familyNameConflict = leftRemovedLastNameDiff.getConflict();
    assertNotNull(familyNameConflict);
    assertSame(Integer.valueOf(2), Integer.valueOf(familyNameConflict.getDifferences().size()));
    assertTrue(familyNameConflict.getDifferences().contains(leftRemovedLastNameDiff));
    assertTrue(familyNameConflict.getDifferences().contains(rightRenamedFamilyNameDiff));
    assertSame(familyNameConflict, rightRenamedFamilyNameDiff.getConflict());
    assertSame(ConflictKind.REAL, familyNameConflict.getKind());

    final Predicate<? super Diff> rightSetPeriodicalSupertype =
        and(
            fromSide(DifferenceSource.RIGHT),
            addedToReference("extlibrary.Magazine", "eSuperTypes", "extlibrary.Periodical"));
    final Predicate<? super Diff> rightRemovedTitle =
        and(fromSide(DifferenceSource.RIGHT), removed("extlibrary.Periodical.title"));
    final Predicate<? super Diff> rightUnsetTitleType =
        and(
            fromSide(DifferenceSource.RIGHT),
            changedReference("extlibrary.Periodical.title", "eType", "ecore.EString", null));
    final Predicate<? super Diff> leftRemovedPeriodical =
        and(fromSide(DifferenceSource.LEFT), removed("extlibrary.Periodical"));
    final Predicate<? super Diff> leftRemovedTitle =
        and(fromSide(DifferenceSource.LEFT), removed("extlibrary.Periodical.title"));
    final Predicate<? super Diff> leftUnsetTitleType =
        and(
            fromSide(DifferenceSource.LEFT),
            changedReference("extlibrary.Periodical.title", "eType", "ecore.EString", null));

    final Diff rightSetPeriodicalSupertypeDiff =
        Iterators.find(differences.iterator(), rightSetPeriodicalSupertype);
    final Diff rightRemovedTitleDiff = Iterators.find(differences.iterator(), rightRemovedTitle);
    final Diff rightUnsetTitleTypeDiff =
        Iterators.find(differences.iterator(), rightUnsetTitleType);
    final Diff leftRemovedPeriodicalDiff =
        Iterators.find(differences.iterator(), leftRemovedPeriodical);
    final Diff leftRemovedTitleDiff = Iterators.find(differences.iterator(), leftRemovedTitle);
    final Diff leftUnsetTitleTypeDiff = Iterators.find(differences.iterator(), leftUnsetTitleType);

    final Conflict periodicalConflict = rightSetPeriodicalSupertypeDiff.getConflict();
    assertNotNull(periodicalConflict);
    /*
     * The test fails. An easy fix is to set the number of diffs in conflicts here to "7" instead of "6".
     * This is wrong. The conflict detection should not set "all diffs under a containment delete" in
     * conflict with "the containment delete". See [381143] for details and fix this test accordingly.
     */
    assertSame(Integer.valueOf(6), Integer.valueOf(periodicalConflict.getDifferences().size()));
    assertTrue(periodicalConflict.getDifferences().contains(rightSetPeriodicalSupertypeDiff));
    assertTrue(periodicalConflict.getDifferences().contains(rightRemovedTitleDiff));
    assertTrue(periodicalConflict.getDifferences().contains(rightUnsetTitleTypeDiff));
    assertTrue(periodicalConflict.getDifferences().contains(leftRemovedPeriodicalDiff));
    assertTrue(periodicalConflict.getDifferences().contains(leftRemovedTitleDiff));
    assertTrue(periodicalConflict.getDifferences().contains(leftUnsetTitleTypeDiff));
    assertSame(ConflictKind.REAL, periodicalConflict.getKind());

    assertSame(Integer.valueOf(4), comparison.getConflicts());
  }
Example #4
0
 /**
  * Returns the first element in {@code iterable} that satisfies the given predicate, or {@code
  * defaultValue} if none found. Note that this can usually be handled more naturally using {@code
  * tryFind(iterable, predicate).or(defaultValue)}.
  *
  * @since 7.0
  */
 @Nullable
 public static <T> T find(
     Iterable<? extends T> iterable, Predicate<? super T> predicate, @Nullable T defaultValue) {
   return Iterators.find(iterable.iterator(), predicate, defaultValue);
 }
Example #5
0
 /**
  * Returns the first element in {@code iterable} that satisfies the given predicate; use this
  * method only when such an element is known to exist. If it is possible that <i>no</i> element
  * will match, use {@link #tryFind} or {@link #find(Iterable, Predicate, Object)} instead.
  *
  * @throws NoSuchElementException if no element in {@code iterable} matches the given predicate
  */
 public static <T> T find(Iterable<T> iterable, Predicate<? super T> predicate) {
   return Iterators.find(iterable.iterator(), predicate);
 }
  private void testAB1(TestKind kind, final Comparison comparison) {
    final List<Diff> differences = comparison.getDifferences();

    // We should have no less and no more than 10 differences
    assertEquals(10, differences.size());

    Predicate<? super Diff> addTimeConstraintDescription = null;
    Predicate<? super Diff> addTimeIntervalDescription = null;
    Predicate<? super Diff> addTimeExpressionMinDescription = null;
    Predicate<? super Diff> addTimeExpressionMaxDescription = null;
    Predicate<? super Diff> addMinValueDescription = null;
    Predicate<? super Diff> addMaxValueDescription = null;
    Predicate<? super Diff> addConstrainedElementInTimeConstraintDescription = null;
    Predicate<? super Diff> addMinInTimeIntervalDescription = null;
    Predicate<? super Diff> addMaxInTimeIntervalDescription = null;

    if (kind.equals(TestKind.DELETE)) {
      addTimeConstraintDescription = removed("model.interaction0.TimeConstraint0"); // $NON-NLS-1$
      addTimeIntervalDescription =
          removed("model.interaction0.TimeConstraint0.TimeInterval"); // $NON-NLS-1$
      addTimeExpressionMinDescription = removed("model.TimeIntervalMin0"); // $NON-NLS-1$
      addTimeExpressionMaxDescription = removed("model.TimeIntervalMax0");
      addMinValueDescription = removed("model.TimeIntervalMin0.min"); // $NON-NLS-1$
      addMaxValueDescription = removed("model.TimeIntervalMax0.max"); // $NON-NLS-1$
      addConstrainedElementInTimeConstraintDescription =
          removedFromReference(
              "model.interaction0.TimeConstraint0",
              "constrainedElement",
              "model.interaction0.Message0Send0");
      addMinInTimeIntervalDescription =
          changedReference(
              "model.interaction0.TimeConstraint0.TimeInterval",
              "min",
              "model.TimeIntervalMin0",
              null);
      addMaxInTimeIntervalDescription =
          changedReference(
              "model.interaction0.TimeConstraint0.TimeInterval",
              "max",
              "model.TimeIntervalMax0",
              null);
    } else {
      addTimeConstraintDescription = added("model.interaction0.TimeConstraint0"); // $NON-NLS-1$
      addTimeIntervalDescription =
          added("model.interaction0.TimeConstraint0.TimeInterval"); // $NON-NLS-1$
      addTimeExpressionMinDescription = added("model.TimeIntervalMin0"); // $NON-NLS-1$
      addTimeExpressionMaxDescription = added("model.TimeIntervalMax0");
      addMinValueDescription = added("model.TimeIntervalMin0.min"); // $NON-NLS-1$
      addMaxValueDescription = added("model.TimeIntervalMax0.max"); // $NON-NLS-1$
      addConstrainedElementInTimeConstraintDescription =
          addedToReference(
              "model.interaction0.TimeConstraint0",
              "constrainedElement",
              "model.interaction0.Message0Send0");
      addMinInTimeIntervalDescription =
          changedReference(
              "model.interaction0.TimeConstraint0.TimeInterval",
              "min",
              null,
              "model.TimeIntervalMin0");
      addMaxInTimeIntervalDescription =
          changedReference(
              "model.interaction0.TimeConstraint0.TimeInterval",
              "max",
              null,
              "model.TimeIntervalMax0");
    }

    final Diff addTimeConstraint =
        Iterators.find(differences.iterator(), addTimeConstraintDescription);
    final Diff addTimeInterval = Iterators.find(differences.iterator(), addTimeIntervalDescription);
    final Diff addTimeExpressionMin =
        Iterators.find(differences.iterator(), addTimeExpressionMinDescription);
    final Diff addTimeExpressionMax =
        Iterators.find(differences.iterator(), addTimeExpressionMaxDescription);
    final Diff addMinValue = Iterators.find(differences.iterator(), addMinValueDescription);
    final Diff addMaxValue = Iterators.find(differences.iterator(), addMaxValueDescription);
    final Diff addConstrainedElementInTimeConstraint =
        Iterators.find(differences.iterator(), addConstrainedElementInTimeConstraintDescription);
    final Diff addMinInTimeInterval =
        Iterators.find(differences.iterator(), addMinInTimeIntervalDescription);
    final Diff addMaxInTimeInterval =
        Iterators.find(differences.iterator(), addMaxInTimeIntervalDescription);

    assertNotNull(addTimeConstraint);
    assertNotNull(addTimeInterval);
    assertNotNull(addTimeExpressionMin);
    assertNotNull(addTimeExpressionMax);
    assertNotNull(addMinValue);
    assertNotNull(addMaxValue);
    assertNotNull(addConstrainedElementInTimeConstraint);
    assertNotNull(addMinInTimeInterval);
    assertNotNull(addMaxInTimeInterval);

    // CHECK EXTENSION
    assertEquals(1, count(differences, instanceOf(IntervalConstraintChange.class)));
    Diff addUMLMessage = null;
    if (kind.equals(TestKind.ADD)) {
      addUMLMessage =
          Iterators.find(
              differences.iterator(),
              and(instanceOf(IntervalConstraintChange.class), ofKind(DifferenceKind.ADD)));
    } else {
      addUMLMessage =
          Iterators.find(
              differences.iterator(),
              and(instanceOf(IntervalConstraintChange.class), ofKind(DifferenceKind.DELETE)));
    }
    assertNotNull(addUMLMessage);
    assertEquals(9, addUMLMessage.getRefinedBy().size());
    assertTrue(addUMLMessage.getRefinedBy().contains(addConstrainedElementInTimeConstraint));
    assertTrue(addUMLMessage.getRefinedBy().contains(addTimeInterval));
    assertTrue(addUMLMessage.getRefinedBy().contains(addMinInTimeInterval));
    assertTrue(addUMLMessage.getRefinedBy().contains(addMaxInTimeInterval));
    assertTrue(addUMLMessage.getRefinedBy().contains(addMinValue));
    assertTrue(addUMLMessage.getRefinedBy().contains(addMaxValue));
    assertTrue(addUMLMessage.getRefinedBy().contains(addTimeExpressionMin));
    assertTrue(addUMLMessage.getRefinedBy().contains(addTimeExpressionMax));
    assertTrue(addUMLMessage.getRefinedBy().contains(addTimeConstraint));

    // CHECK REQUIREMENT
    if (kind.equals(TestKind.ADD)) {

      assertEquals(0, addTimeConstraint.getRequires().size());

      assertEquals(1, addTimeInterval.getRequires().size());
      assertTrue(addTimeInterval.getRequires().contains(addTimeConstraint));

      assertEquals(0, addTimeExpressionMin.getRequires().size());
      assertEquals(0, addTimeExpressionMax.getRequires().size());

      assertEquals(1, addMinValue.getRequires().size());
      assertTrue(addMinValue.getRequires().contains(addTimeExpressionMin));

      assertEquals(1, addMaxValue.getRequires().size());
      assertTrue(addMaxValue.getRequires().contains(addTimeExpressionMax));

      assertEquals(1, addConstrainedElementInTimeConstraint.getRequires().size());
      assertTrue(addTimeInterval.getRequires().contains(addTimeConstraint));

      assertEquals(2, addMinInTimeInterval.getRequires().size());
      assertTrue(addMinInTimeInterval.getRequires().contains(addTimeInterval));
      assertTrue(addMinInTimeInterval.getRequires().contains(addTimeExpressionMin));

      assertEquals(2, addMaxInTimeInterval.getRequires().size());
      assertTrue(addMaxInTimeInterval.getRequires().contains(addTimeInterval));
      assertTrue(addMaxInTimeInterval.getRequires().contains(addTimeExpressionMax));

    } else {
      assertEquals(2, addTimeConstraint.getRequires().size());
      assertTrue(addTimeConstraint.getRequires().contains(addConstrainedElementInTimeConstraint));
      assertTrue(addTimeConstraint.getRequires().contains(addTimeInterval));

      assertEquals(2, addTimeInterval.getRequires().size());
      assertTrue(addTimeInterval.getRequires().contains(addMinInTimeInterval));
      assertTrue(addTimeInterval.getRequires().contains(addMaxInTimeInterval));

      assertEquals(2, addTimeExpressionMin.getRequires().size());
      assertTrue(addTimeExpressionMin.getRequires().contains(addMinValue));
      assertTrue(addTimeExpressionMin.getRequires().contains(addMinInTimeInterval));

      assertEquals(2, addTimeExpressionMax.getRequires().size());
      assertTrue(addTimeExpressionMax.getRequires().contains(addMaxValue));
      assertTrue(addTimeExpressionMax.getRequires().contains(addMaxInTimeInterval));

      assertEquals(0, addMinValue.getRequires().size());

      assertEquals(0, addMaxValue.getRequires().size());

      assertEquals(0, addConstrainedElementInTimeConstraint.getRequires().size());

      assertEquals(0, addMinInTimeInterval.getRequires().size());

      assertEquals(0, addMaxInTimeInterval.getRequires().size());
    }

    // CHECK EQUIVALENCE
    assertEquals(0, comparison.getEquivalences().size());

    testIntersections(comparison);
  }