Public Git Hosting - EMFCompare2.git/blob - plugins/org.eclipse.emf.compare.uml2.rcp.ui.tests/src/org/eclipse/emf/compare/uml2/rcp/ui/tests/groups/UMLDifferencesOrderTest.java

1 /*******************************************************************************

4 * are made available under the terms of the Eclipse Public License v1.0

5 * which accompanies this distribution, and is available at

6 * http://www.eclipse.org/legal/epl-v10.html

7 *

8 * Contributors:

9 * Obeo - initial API and implementation

10 *******************************************************************************/

11 package org.eclipse.emf.compare.uml2.rcp.ui.tests.groups;

12

13 import static com.google.common.base.Predicates.alwaysTrue;

14

15 import com.google.common.collect.Lists;

16

17 import java.io.IOException;

18 import java.util.List;

19 import java.util.regex.Pattern;

20

21 import org.eclipse.emf.common.notify.AdapterFactory;

22 import org.eclipse.emf.compare.postprocessor.BasicPostProcessorDescriptorImpl;

23 import org.eclipse.emf.compare.postprocessor.IPostProcessor.Descriptor.Registry;

24 import org.eclipse.emf.compare.postprocessor.PostProcessorDescriptorRegistryImpl;

25 import org.eclipse.emf.compare.provider.spec.CompareItemProviderAdapterFactorySpec;

26 import org.eclipse.emf.compare.rcp.ui.internal.structuremergeviewer.filters.impl.CascadingDifferencesFilter;

27 import org.eclipse.emf.compare.rcp.ui.internal.structuremergeviewer.filters.impl.EmptyMatchedResourcesFilter;

28 import org.eclipse.emf.compare.rcp.ui.internal.structuremergeviewer.filters.impl.IdenticalElementsFilter;

29 import org.eclipse.emf.compare.rcp.ui.internal.structuremergeviewer.filters.impl.PseudoConflictsFilter;

30 import org.eclipse.emf.compare.rcp.ui.internal.structuremergeviewer.groups.impl.BasicDifferenceGroupImpl;

31 import org.eclipse.emf.compare.rcp.ui.internal.structuremergeviewer.groups.provider.TreeItemProviderAdapterFactorySpec;

32 import org.eclipse.emf.compare.rcp.ui.structuremergeviewer.groups.IDifferenceGroup;

33 import org.eclipse.emf.compare.tests.framework.AbstractInputData;

34 import org.eclipse.emf.compare.uml2.internal.postprocessor.UMLPostProcessor;

35 import org.eclipse.emf.compare.uml2.internal.provider.custom.UMLCompareCustomItemProviderAdapterFactory;

36 import org.eclipse.emf.compare.uml2.internal.provider.decorator.UMLCompareItemProviderDecoratorAdapterFactory;

37 import org.eclipse.emf.compare.uml2.rcp.ui.internal.structuremergeviewer.filters.UMLRefinedElementsFilter;

38 import org.eclipse.emf.ecore.resource.Resource;

39 import org.eclipse.emf.edit.provider.ReflectiveItemProviderAdapterFactory;

40 import org.eclipse.emf.edit.tree.TreeNode;

41 import org.eclipse.uml2.uml.edit.providers.UMLItemProviderAdapterFactory;

42 import org.junit.Before;

43 import org.junit.Test;

44

45 /**

46 * Tests the order of the differences the way they would be displayed in the structure merge viewer for UML

47 * differences.

48 *

49 * @author <a href="mailto:arthur.daussy@obeo.fr">Arthur Daussy</a>

50 */

51 public class UMLDifferencesOrderTest extends AbstractDifferenceOrderTest {

52

53 private ExpectedResultData expectedResult;

54

55 @Before

56 @Override

57 public void before() throws IOException {

58 super.before();

59 getFilter().removeFilter(new CascadingDifferencesFilter());

60 getFilter().removeFilter(new PseudoConflictsFilter());

61 getFilter().removeFilter(new EmptyMatchedResourcesFilter());

62 getFilter().removeFilter(new IdenticalElementsFilter());

63 expectedResult = new ExpectedResultData();

64 }

65

66 @Override

67 protected NotifierScopeProvider getInput() {

68 return new DataInput();

69 }

70

71 @Override

72 protected List<AdapterFactory> getAdaptersFactory() {

73 return Lists.<AdapterFactory> newArrayList(new CompareItemProviderAdapterFactorySpec(),

74 new TreeItemProviderAdapterFactorySpec(), new UMLCompareCustomItemProviderAdapterFactory(),

75 new UMLItemProviderAdapterFactory(), new UMLCompareItemProviderDecoratorAdapterFactory(),

76 new ReflectiveItemProviderAdapterFactory());

77 }

78

79 @Override

80 protected Registry<?> getPostProcessorRegistry() {

81 PostProcessorDescriptorRegistryImpl<Object> postProcessorRegistry = new PostProcessorDescriptorRegistryImpl<Object>();

82 BasicPostProcessorDescriptorImpl descriptor = new BasicPostProcessorDescriptorImpl(

83 new UMLPostProcessor(), Pattern.compile("http://www.eclipse.org/uml2/\\d.0.0/UML"), null); //$NON-NLS-1$

84 postProcessorRegistry.put(UMLPostProcessor.class.getName(), descriptor);

85 return postProcessorRegistry;

86 }

87

88 /**

89 * Tests the structured representation of UML differences without the UML refine filter activated.

90 *

91 * @throws IOException

92 */

93 @Test

94 public void testDiffOrder() throws IOException {

95 UMLRefinedElementsFilter umlRefineFilter = new UMLRefinedElementsFilter();

96 getFilter().removeFilter(umlRefineFilter);

97

98 IDifferenceGroup group = new BasicDifferenceGroupImpl(getComparison(), alwaysTrue(),

99 getCrossReferenceAdapter());

100 List<? extends TreeNode> roots = group.getChildren();

101 // Uncomment the following lines to reserialize the expected model

102 // TestWriterHelper writerHelper = createTestHelper();

103 // writerHelper.createExpectedModel("PATH_TO_MODEL_FILE/expectedResult.nodes", roots,false);

104

105 compareTree(expectedResult.getExpectedResultWithoutFilter(), roots, false);

106

107 }

108

109 /**

110 * Tests the structured representation of UML differences with the UML refine filter activated.

111 *

112 * @throws IOException

113 */

114 @Test

115 public void testDiffOrderWithUMLRefineFilter() throws IOException {

116 UMLRefinedElementsFilter umlRefineFilter = new UMLRefinedElementsFilter();

117 getFilter().addFilter(umlRefineFilter);

118

119 IDifferenceGroup group = new BasicDifferenceGroupImpl(getComparison(), alwaysTrue(),

120 getCrossReferenceAdapter());

121 List<? extends TreeNode> roots = group.getChildren();

122 // Uncomment the following lines to reserialize the expected model

123 // TestWriterHelper writerHelper = createTestHelper();

124 // writerHelper.createExpectedModel("PATH_TO_MODEL_FILE/expectedResultWithUMLRefineElement.nodes",

125 // roots);

126

127 compareTree(expectedResult.getExpectedResultWithFilter(), roots, false);

128

129 }

130

131 /**

132 * Input data for this test.

133 *

134 * @author <a href="mailto:arthur.daussy@obeo.fr">Arthur Daussy</a>

135 */

136 private static class DataInput extends AbstractInputData implements NotifierScopeProvider {

137

138 public Resource getLeft() throws IOException {

139 return loadFromClassLoader("data/a1/left.uml");//$NON-NLS-1$

140 }

141

142 public Resource getOrigin() throws IOException {

143 return loadFromClassLoader("data/a1/origin.uml");//$NON-NLS-1$

144 }

145

146 public Resource getRight() throws IOException {

147 return loadFromClassLoader("data/a1/right.uml");//$NON-NLS-1$

148 }

149 }

150

151 /**

152 * Expected result data.

153 *

154 * @author <a href="mailto:arthur.daussy@obeo.fr">Arthur Daussy</a>

155 */

156 private static class ExpectedResultData extends AbstractInputData {

157

158 public Resource getExpectedResultWithoutFilter() throws IOException {

159 return loadFromClassLoader("data/a1/expectedResultWithoutUMLRefineElementFilter.nodes"); //$NON-NLS-1$

160 }

161

162 public Resource getExpectedResultWithFilter() throws IOException {

163 return loadFromClassLoader("data/a1/expectedResultWithUMLRefineElementFilter.nodes"); //$NON-NLS-1$

164 }

165 }

166

167 }