@Test
  public void testGetStartingVersion() throws OseeCoreException {
    ChangeVersion ver1 = ChangeTestUtility.createChange(111L, ModificationType.NEW);
    ChangeVersion ver2 = ChangeTestUtility.createChange(222L, ModificationType.MODIFIED);
    ChangeVersion ver3 = ChangeTestUtility.createChange(333L, ModificationType.DELETED);
    ChangeVersion invalid = ChangeTestUtility.createChange(999L, null);

    try {
      ChangeItemUtil.getStartingVersion(null);
      Assert.fail("This line should not be executed");
    } catch (OseeCoreException ex) {
      Assert.assertTrue(ex instanceof OseeArgumentException);
    }

    ChangeItem item = ChangeTestUtility.createItem(1, ver1, ver2, ver3, null, null);
    Assert.assertEquals(ver1, ChangeItemUtil.getStartingVersion(item));

    item = ChangeTestUtility.createItem(2, invalid, ver2, ver3, null, null);
    Assert.assertEquals(ver2, ChangeItemUtil.getStartingVersion(item));

    item = ChangeTestUtility.createItem(3, invalid, invalid, ver3, null, null);
    Assert.assertEquals(ver3, ChangeItemUtil.getStartingVersion(item));

    try {
      item = ChangeTestUtility.createItem(3, invalid, invalid, invalid, null, null);
      ChangeItemUtil.getStartingVersion(item);
      Assert.fail("This line should not be executed");
    } catch (OseeCoreException ex) {
      Assert.assertTrue(ex instanceof OseeStateException);
    }
  }
  @Test
  public void testIsNewIntroducedDeleted() {
    ChangeVersion object1 = ChangeTestUtility.createChange(200L, null);
    for (ModificationType modType : ModificationType.values()) {
      object1.setModType(null);
      Assert.assertNull(object1.getModType());

      Assert.assertEquals(false, ChangeItemUtil.isNew(object1));
      Assert.assertEquals(false, ChangeItemUtil.isIntroduced(object1));
      Assert.assertEquals(false, ChangeItemUtil.isDeleted(object1));

      object1.setModType(modType);
      Assert.assertEquals(modType, object1.getModType());
      Assert.assertEquals(modType == ModificationType.NEW, ChangeItemUtil.isNew(object1));
      Assert.assertEquals(
          modType == ModificationType.INTRODUCED, ChangeItemUtil.isIntroduced(object1));
      Assert.assertEquals(
          modType == ModificationType.DELETED || modType == ModificationType.ARTIFACT_DELETED,
          ChangeItemUtil.isDeleted(object1));
    }

    Assert.assertEquals(false, ChangeItemUtil.isNew(null));
    Assert.assertEquals(false, ChangeItemUtil.isIntroduced(null));
    Assert.assertEquals(false, ChangeItemUtil.isDeleted(null));
  }
  @Test
  public void testHasBeenDeletedInDestination() {
    ChangeVersion current = ChangeTestUtility.createChange(3333L, ModificationType.INTRODUCED);
    ChangeVersion destination = ChangeTestUtility.createChange(4444L, ModificationType.DELETED);

    ChangeItem item = ChangeTestUtility.createItem(200, null, null, current, destination, null);
    assertTrue(ChangeItemUtil.hasBeenDeletedInDestination(item));

    item = ChangeTestUtility.createItem(200, null, null, current, null, null);
    assertFalse(ChangeItemUtil.hasBeenDeletedInDestination(item));
  }
  @Test
  public void testCreatedAndDeleted() {
    ChangeVersion isNew = ChangeTestUtility.createChange(2222L, ModificationType.NEW);

    ChangeVersion deletedCurrent = ChangeTestUtility.createChange(3333L, ModificationType.DELETED);
    ChangeItem item = ChangeTestUtility.createItem(200, null, isNew, deletedCurrent, null, null);
    assertTrue(ChangeItemUtil.wasCreatedAndDeleted(item));

    ChangeVersion notDeletedCurrent =
        ChangeTestUtility.createChange(3333L, ModificationType.INTRODUCED);
    item = ChangeTestUtility.createItem(200, null, isNew, notDeletedCurrent, null, null);
    assertFalse(ChangeItemUtil.wasCreatedAndDeleted(item));
  }
  @Test
  public void testNewOnSource() {
    ChangeVersion newType = ChangeTestUtility.createChange(2222L, ModificationType.NEW);
    ChangeVersion modified = ChangeTestUtility.createChange(2223L, ModificationType.MODIFIED);

    ChangeItem item = ChangeTestUtility.createItem(200, null, newType, modified, null, null);
    assertTrue(ChangeItemUtil.wasNewOnSource(item));

    item = ChangeTestUtility.createItem(200, null, null, newType, null, null);
    assertTrue(ChangeItemUtil.wasNewOnSource(item));

    item = ChangeTestUtility.createItem(200, null, modified, modified, null, null);
    assertFalse(ChangeItemUtil.wasNewOnSource(item));
  }
  @Test
  public void testIntroducedOnSource() {
    ChangeVersion introduced = ChangeTestUtility.createChange(2222L, ModificationType.INTRODUCED);
    ChangeVersion modified = ChangeTestUtility.createChange(1234L, ModificationType.MODIFIED);
    ChangeItem item;

    item = ChangeTestUtility.createItem(200, null, introduced, modified, null, null);
    assertTrue(ChangeItemUtil.wasIntroducedOnSource(item));

    item = ChangeTestUtility.createItem(200, null, null, introduced, null, null);
    assertTrue(ChangeItemUtil.wasIntroducedOnSource(item));

    item = ChangeTestUtility.createItem(200, null, null, modified, null, null);
    assertFalse(ChangeItemUtil.wasIntroducedOnSource(item));
  }
  @Test
  public void testIsModType() {
    ChangeVersion object1 = ChangeTestUtility.createChange(200L, null);
    Assert.assertNull(object1.getModType());
    Assert.assertEquals(true, ChangeItemUtil.isModType(object1, null));

    for (ModificationType modType : ModificationType.values()) {
      object1.setModType(null);
      Assert.assertNull(object1.getModType());
      object1.setModType(modType);

      Assert.assertEquals(modType, object1.getModType());
      Assert.assertTrue(ChangeItemUtil.isModType(object1, modType));
    }
    Assert.assertEquals(false, ChangeItemUtil.isModType(null, ModificationType.NEW));
  }
  @Test
  public void isDeletedAndDoesNotExistInDestination() {
    ChangeVersion dest, current;
    ChangeItem item;

    current = ChangeTestUtility.createChange(2222L, ModificationType.DELETED);
    dest = null;
    item = ChangeTestUtility.createItem(200, null, null, current, dest, null);
    assertTrue(ChangeItemUtil.isDeletedAndDoesNotExistInDestination(item));

    dest = ChangeTestUtility.createChange(3333L, ModificationType.NEW);
    item = ChangeTestUtility.createItem(200, null, null, current, dest, null);
    assertFalse(ChangeItemUtil.isDeletedAndDoesNotExistInDestination(item));

    dest = ChangeTestUtility.createChange(3333L, null);
    item = ChangeTestUtility.createItem(200, null, null, current, dest, null);
    assertTrue(ChangeItemUtil.isDeletedAndDoesNotExistInDestination(item));
  }
  @Test
  public void testGammasEqual() {
    List<Triplet<ChangeVersion, ChangeVersion, Boolean>> cases =
        new ArrayList<Triplet<ChangeVersion, ChangeVersion, Boolean>>();

    cases.add(createTriplet(3000L, ModificationType.MODIFIED, 3000L, ModificationType.NEW, true));
    cases.add(createTriplet(null, ModificationType.MODIFIED, 3000L, ModificationType.NEW, false));
    cases.add(createTriplet(3000L, null, 3000L, ModificationType.NEW, true));
    cases.add(createTriplet(3000L, ModificationType.MODIFIED, null, ModificationType.NEW, false));
    cases.add(createTriplet(3000L, ModificationType.MODIFIED, 3000L, null, true));
    cases.add(createTriplet(null, null, null, null, true));
    cases.add(createTriplet(3000L, null, 3001L, null, false));

    int index = 0;
    for (Triplet<ChangeVersion, ChangeVersion, Boolean> test : cases) {
      boolean actual = ChangeItemUtil.areGammasEqual(test.getFirst(), test.getSecond());
      Assert.assertTrue("Test " + ++index + ":", test.getThird() == actual);
    }
    assertTrue(ChangeItemUtil.areGammasEqual(null, null));
  }
  @Test
  public void testCopy() throws OseeCoreException {
    ChangeVersion expected = new ChangeVersion(5679L, ModificationType.MERGED);

    ChangeVersion actual = new ChangeVersion();
    ChangeItemUtil.copy(expected, actual);

    ChangeTestUtility.checkChange(expected, actual);

    try {
      ChangeItemUtil.copy(null, expected);
      Assert.fail("Should not be executed");
    } catch (Exception ex) {
      Assert.assertTrue(ex instanceof OseeArgumentException);
    }

    try {
      ChangeItemUtil.copy(expected, null);
      Assert.fail("Should not be executed");
    } catch (Exception ex) {
      Assert.assertTrue(ex instanceof OseeArgumentException);
    }
  }
  @Test
  public void testIgnoreCase() {
    ChangeVersion isNew = ChangeTestUtility.createChange(2222L, ModificationType.NEW);

    ChangeVersion deletedCurrent = ChangeTestUtility.createChange(3333L, ModificationType.DELETED);
    ChangeItem item = ChangeTestUtility.createItem(200, null, isNew, deletedCurrent, null, null);
    assertTrue(ChangeItemUtil.isIgnoreCase(item));

    ChangeVersion current = ChangeTestUtility.createChange(3333L, ModificationType.INTRODUCED);
    ChangeVersion destination = ChangeTestUtility.createChange(3333L, ModificationType.INTRODUCED);
    item = ChangeTestUtility.createItem(200, null, null, current, destination, null);
    assertTrue(ChangeItemUtil.isIgnoreCase(item));

    ChangeVersion dest;

    current = ChangeTestUtility.createChange(2222L, ModificationType.DELETED);
    dest = null;
    item = ChangeTestUtility.createItem(200, null, null, current, dest, null);
    assertTrue(ChangeItemUtil.isIgnoreCase(item));

    current = ChangeTestUtility.createChange(3333L, ModificationType.INTRODUCED);
    destination = ChangeTestUtility.createChange(4444L, ModificationType.DELETED);

    item = ChangeTestUtility.createItem(200, null, null, current, destination, null);
    assertTrue(ChangeItemUtil.isIgnoreCase(item));

    isNew = ChangeTestUtility.createChange(2222L, ModificationType.NEW);
    destination = ChangeTestUtility.createChange(3333L, ModificationType.NEW);
    item = ChangeTestUtility.createItem(200, null, null, isNew, destination, null);
    assertFalse(ChangeItemUtil.isIgnoreCase(item));

    // destination Equal Or Newer Than Current
    isNew = ChangeTestUtility.createChange(2222L, ModificationType.NEW);
    ChangeVersion isIntroduced = ChangeTestUtility.createChange(2222L, ModificationType.NEW);
    dest = ChangeTestUtility.createChange(1111L, ModificationType.NEW);
    item = ChangeTestUtility.createItem(200, null, null, isNew, dest, null);
    assertFalse(ChangeItemUtil.isIgnoreCase(item));

    item = ChangeTestUtility.createItem(200, null, null, isIntroduced, dest, null);
    assertFalse(ChangeItemUtil.isIgnoreCase(item));

    ChangeVersion isNotNew = ChangeTestUtility.createChange(2222L, ModificationType.MODIFIED);
    item = ChangeTestUtility.createItem(200, null, null, isNotNew, dest, null);
    assertFalse(ChangeItemUtil.isIgnoreCase(item));
  }