Skip to content

Package: ValidationTreeViewer_PTest

ValidationTreeViewer_PTest

nameinstructionbranchcomplexitylinemethod
ValidationTreeViewer_PTest()
M: 0 C: 3
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 1
100%
M: 0 C: 1
100%
after()
M: 0 C: 5
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 2
100%
M: 0 C: 1
100%
before()
M: 0 C: 6
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 3
100%
M: 0 C: 1
100%
createTreeViewer()
M: 0 C: 5
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 1
100%
M: 0 C: 1
100%
leagueWithPlayers(int)
M: 0 C: 26
100%
M: 0 C: 2
100%
M: 0 C: 2
100%
M: 0 C: 6
100%
M: 0 C: 1
100%
testDoubleClickListener()
M: 49 C: 0
0%
M: 0 C: 0
100%
M: 1 C: 0
0%
M: 13 C: 0
0%
M: 1 C: 0
0%
testEmpty()
M: 0 C: 36
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 8
100%
M: 0 C: 1
100%
testInitLeagueWith2PlayersExpanded()
M: 0 C: 91
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 20
100%
M: 0 C: 1
100%
testInitMultipleDiagnosticsExpanded()
M: 0 C: 91
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 20
100%
M: 0 C: 1
100%
testInitSingleErrorExpanded()
M: 0 C: 48
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 11
100%
M: 0 C: 1
100%
validateLeague(League, int)
M: 0 C: 15
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 3
100%
M: 0 C: 1
100%

Coverage

1: /*******************************************************************************
2: * Copyright (c) 2011-2019 EclipseSource Muenchen GmbH and others.
3: *
4: * All rights reserved. This program and the accompanying materials
5: * are made available under the terms of the Eclipse Public License 2.0
6: * which accompanies this distribution, and is available at
7: * https://www.eclipse.org/legal/epl-2.0/
8: *
9: * SPDX-License-Identifier: EPL-2.0
10: *
11: * Contributors:
12: * Johannes Faltermeier - initial API and implementation
13: * Christian W. Damus - bug 546899
14: ******************************************************************************/
15: package org.eclipse.emf.ecp.ui.validation.test;
16:
17: import static org.junit.Assert.assertEquals;
18:
19: import java.util.LinkedHashMap;
20: import java.util.Map;
21:
22: import org.eclipse.emf.common.util.Diagnostic;
23: import org.eclipse.emf.ecp.diagnostician.ECPDiagnostician;
24: import org.eclipse.emf.ecp.internal.ui.validation.ValidationTreeViewerFactory;
25: import org.eclipse.emf.emfstore.bowling.BowlingFactory;
26: import org.eclipse.emf.emfstore.bowling.League;
27: import org.eclipse.emf.emfstore.bowling.Player;
28: import org.eclipse.jface.viewers.TreeViewer;
29: import org.eclipse.swt.SWT;
30: import org.eclipse.swt.widgets.Event;
31: import org.eclipse.swt.widgets.Listener;
32: import org.eclipse.swt.widgets.Shell;
33: import org.eclipse.swt.widgets.Tree;
34: import org.eclipse.swt.widgets.TreeColumn;
35: import org.eclipse.swt.widgets.TreeItem;
36: import org.junit.After;
37: import org.junit.Before;
38: import org.junit.Ignore;
39: import org.junit.Test;
40:
41: public class ValidationTreeViewer_PTest {
42:
43:         private TreeViewer treeViewer;
44:
45:         @Before
46:         public void before() {
47:                 TestDoubleClickListener.resetHitCount();
48:                 treeViewer = createTreeViewer();
49:         }
50:
51:         @After
52:         public void after() {
53:                 treeViewer.getTree().dispose();
54:         }
55:
56:         @Test
57:         public void testEmpty() {
58:                 final Tree tree = treeViewer.getTree();
59:                 assertEquals(0, tree.getItemCount());
60:                 assertEquals(3, tree.getColumnCount());
61:                 final TreeColumn[] columns = tree.getColumns();
62:                 assertEquals("Description", columns[0].getText());
63:                 assertEquals("EObject", columns[1].getText());
64:                 assertEquals("Structural Feature", columns[2].getText());
65:         }
66:
67:         @Test
68:         public void testInitSingleErrorExpanded() {
69:                 final Diagnostic diagnostic = validateLeague(leagueWithPlayers(0), LeagueValidator.MODE_ONLY_LEAGUE);
70:                 treeViewer.setInput(diagnostic);
71:                 treeViewer.expandAll();
72:                 final Tree tree = treeViewer.getTree();
73:                 assertEquals(1, tree.getItemCount());
74:                 final TreeItem item = tree.getItem(0);
75:                 assertEquals("There is something wrong with the players", item.getText(0));
76:                 assertEquals("League", item.getText(1));
77:                 assertEquals("Players", item.getText(2));
78:                 assertEquals(0, item.getItemCount());
79:         }
80:
81:         @Test
82:         public void testInitLeagueWith2PlayersExpanded() {
83:                 final Diagnostic diagnostic = validateLeague(leagueWithPlayers(2), LeagueValidator.MODE_ALL);
84:                 treeViewer.setInput(diagnostic);
85:                 treeViewer.expandAll();
86:                 final Tree tree = treeViewer.getTree();
87:                 // assertEquals(1, tree.getItemCount());
88:                 final TreeItem item = tree.getItem(0);
89:                 assertEquals("There is something wrong with the players", item.getText(0));
90:                 assertEquals("League", item.getText(1));
91:                 assertEquals("Players", item.getText(2));
92:                 assertEquals(2, item.getItemCount());
93:                 final TreeItem item21 = item.getItem(0);
94:                 assertEquals("There is something wrong with this Player", item21.getText(0));
95:                 assertEquals("Player 1", item21.getText(1));
96:                 assertEquals("", item21.getText(2));
97:                 assertEquals(0, item21.getItemCount());
98:                 final TreeItem item22 = item.getItem(1);
99:                 assertEquals("There is something wrong with this Player", item22.getText(0));
100:                 assertEquals("Player 2", item22.getText(1));
101:                 assertEquals("", item22.getText(2));
102:                 assertEquals(0, item22.getItemCount());
103:         }
104:
105:         @Test
106:         public void testInitMultipleDiagnosticsExpanded() {
107:                 final Diagnostic diagnostic = validateLeague(leagueWithPlayers(3), LeagueValidator.MODE_ONLY_PLAYER);
108:                 treeViewer.setInput(diagnostic);
109:                 treeViewer.expandAll();
110:                 final Tree tree = treeViewer.getTree();
111:                 // assertEquals(3, tree.getItemCount());
112:                 final TreeItem item1 = tree.getItem(0);
113:                 assertEquals("There is something wrong with this Player", item1.getText(0));
114:                 assertEquals("Player 1", item1.getText(1));
115:                 assertEquals("", item1.getText(2));
116:                 assertEquals(0, item1.getItemCount());
117:                 final TreeItem item2 = tree.getItem(1);
118:                 assertEquals("There is something wrong with this Player", item2.getText(0));
119:                 assertEquals("Player 2", item2.getText(1));
120:                 assertEquals("", item2.getText(2));
121:                 assertEquals(0, item2.getItemCount());
122:                 final TreeItem item3 = tree.getItem(2);
123:                 assertEquals("There is something wrong with this Player", item3.getText(0));
124:                 assertEquals("Player 3", item3.getText(1));
125:                 assertEquals("", item3.getText(2));
126:                 assertEquals(0, item3.getItemCount());
127:         }
128:
129:         @Ignore
130:         @Test
131:         public void testDoubleClickListener() {
132:                 final Diagnostic diagnostic = validateLeague(leagueWithPlayers(2), LeagueValidator.MODE_ALL);
133:                 treeViewer.setInput(diagnostic);
134:                 treeViewer.expandAll();
135:                 final Tree tree = treeViewer.getTree();
136:                 final Listener[] listeners = tree.getListeners(SWT.MouseDoubleClick);
137:                 assertEquals(1, listeners.length);
138:                 final Listener listener = listeners[0];
139:                 final Event event = new Event();
140:                 event.type = SWT.MouseDoubleClick;
141:                 event.widget = tree;
142:                 listener.handleEvent(event);
143:                 assertEquals(1, TestDoubleClickListener.getHitCount());
144:         }
145:
146:         private TreeViewer createTreeViewer() {
147:                 return ValidationTreeViewerFactory.createValidationViewer(new Shell());
148:         }
149:
150:         private Diagnostic validateLeague(League league, int mode) {
151:                 final Map<Object, Object> context = new LinkedHashMap<Object, Object>();
152:                 context.put(LeagueValidator.LEAGUE_VALIDATOR_MODE, mode);
153:                 return ECPDiagnostician.INSTANCE.validate(league, context);
154:         }
155:
156:         private League leagueWithPlayers(int playerCount) {
157:                 final League league = BowlingFactory.eINSTANCE.createLeague();
158:•                for (int i = 0; i < playerCount; i++) {
159:                         final Player player = BowlingFactory.eINSTANCE.createPlayer();
160:                         player.setName(String.valueOf(i + 1));
161:                         league.getPlayers().add(player);
162:                 }
163:                 return league;
164:         }
165:
166: }