Skip to content

Package: RankingHelper_Test

RankingHelper_Test

nameinstructionbranchcomplexitylinemethod
RankingHelper_Test()
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%
setup()
M: 0 C: 8
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 2
100%
M: 0 C: 1
100%
static {...}
M: 0 C: 21
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 4
100%
M: 0 C: 1
100%
testRankingHighestRank()
M: 0 C: 50
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 10
100%
M: 0 C: 1
100%
testRankingNoWinner()
M: 0 C: 17
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 5
100%
M: 0 C: 1
100%
testRankingWithDuplicate()
M: 0 C: 38
100%
M: 0 C: 0
100%
M: 0 C: 1
100%
M: 0 C: 7
100%
M: 0 C: 1
100%

Coverage

1: /*******************************************************************************
2: * Copyright (c) 2011-2017 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: * Mat Hansen - initial API and implementation
13: ******************************************************************************/
14: package org.eclipse.emfforms.common.tests;
15:
16: import static org.junit.Assert.assertEquals;
17: import static org.junit.Assert.assertNull;
18: import static org.junit.Assert.assertTrue;
19:
20: import java.util.ArrayList;
21: import java.util.Arrays;
22: import java.util.Collection;
23: import java.util.List;
24:
25: import org.eclipse.emfforms.common.RankingHelper;
26: import org.eclipse.emfforms.common.RankingHelper.RankTester;
27: import org.junit.Before;
28: import org.junit.Test;
29:
30: /**
31: * @author Mat Hansen <mhansen@eclipsesource.com>
32: *
33: */
34: public class RankingHelper_Test {
35:
36:         private static class DummyRankedElement {
37:
38:                 private final double rank;
39:
40:                 DummyRankedElement(double rank) {
41:                         super();
42:                         this.rank = rank;
43:                 }
44:
45:                 @Override
46:                 @SuppressWarnings("nls")
47:                 public String toString() {
48:                         return super.toString() + "{rank " + rank + "}";
49:                 }
50:
51:         }
52:
53:         private static final DummyRankedElement DUMMY_RANK_1 = new DummyRankedElement(1d);
54:         private static final DummyRankedElement DUMMY_RANK_2 = new DummyRankedElement(2d);
55:         private static final DummyRankedElement DUMMY_RANK_2_REDUNDANT = new DummyRankedElement(2d);
56:         private static final DummyRankedElement DUMMY_RANK_3 = new DummyRankedElement(3d);
57:
58:         private RankingHelper<DummyRankedElement> rankingHelper;
59:
60:         @Before
61:         public void setup() {
62:                 rankingHelper = new RankingHelper<RankingHelper_Test.DummyRankedElement>(DummyRankedElement.class, -1d);
63:         }
64:
65:         @Test
66:         public void testRankingNoWinner() {
67:
68:                 // empty element list should lead to null winner
69:                 final List<DummyRankedElement> emptyElements = Arrays.asList(new DummyRankedElement[] {});
70:
71:                 final DummyRankedElement winner = rankingHelper.getHighestRankingElement(emptyElements,
72:                         new RankTester<RankingHelper_Test.DummyRankedElement>() {
73:
74:                                 @Override
75:                                 public double getRank(DummyRankedElement element) {
76:                                         return element.rank;
77:                                 }
78:                         });
79:
80:                 assertNull(winner);
81:
82:         }
83:
84:         @Test
85:         public void testRankingWithDuplicate() {
86:
87:                 rankingHelper = new RankingHelper<DummyRankedElement>(DummyRankedElement.class, -1d) {
88:                         private boolean warningCreated;
89:                         private boolean warningReported;
90:
91:                         @Override
92:                         public DummyRankedElement getHighestRankingElement(Collection<DummyRankedElement> elements,
93:                                 org.eclipse.emfforms.common.RankingHelper.RankTester<DummyRankedElement> rankTester) {
94:                                 try {
95:                                         return super.getHighestRankingElement(elements, rankTester);
96:                                 } finally {
97:                                         assertTrue(warningCreated);
98:                                         assertTrue(warningReported);
99:                                 }
100:                         }
101:
102:                         @Override
103:                         protected String createWarning(List<DummyRankedElement> highestRankingElements, double rank) {
104:                                 assertEquals(highestRankingElements.size(), 2);
105:                                 assertEquals(DUMMY_RANK_2, highestRankingElements.get(0));
106:                                 assertEquals(DUMMY_RANK_2_REDUNDANT, highestRankingElements.get(1));
107:                                 assertEquals(DUMMY_RANK_2.rank, rank, 0.0d);
108:                                 warningCreated = true;
109:                                 return super.createWarning(highestRankingElements, rank);
110:                         }
111:
112:                         @Override
113:                         protected void reportClashingPriorities(String warning) {
114:                                 warningReported = true;
115:                         }
116:                 };
117:
118:                 final List<DummyRankedElement> elements = Arrays.asList(
119:                         new DummyRankedElement[] { DUMMY_RANK_1, DUMMY_RANK_2, DUMMY_RANK_2_REDUNDANT });
120:
121:                 final DummyRankedElement winner = rankingHelper.getHighestRankingElement(elements,
122:                         new RankTester<RankingHelper_Test.DummyRankedElement>() {
123:
124:                                 @Override
125:                                 public double getRank(DummyRankedElement element) {
126:                                         return element.rank;
127:                                 }
128:                         });
129:
130:                 assertEquals(DUMMY_RANK_2, winner);
131:
132:         }
133:
134:         @Test
135:         public void testRankingHighestRank() {
136:
137:                 DummyRankedElement winner = null;
138:                 final List<DummyRankedElement> elements = new ArrayList<RankingHelper_Test.DummyRankedElement>();
139:                 elements.addAll(Arrays.asList(new DummyRankedElement[] { DUMMY_RANK_1, DUMMY_RANK_2 }));
140:
141:                 final RankTester<DummyRankedElement> tester = new RankTester<RankingHelper_Test.DummyRankedElement>() {
142:
143:                         @Override
144:                         public double getRank(DummyRankedElement element) {
145:                                 return element.rank;
146:                         }
147:                 };
148:
149:                 winner = rankingHelper.getHighestRankingElement(elements, tester);
150:                 assertEquals(DUMMY_RANK_2, winner);
151:
152:                 elements.add(DUMMY_RANK_3);
153:                 winner = rankingHelper.getHighestRankingElement(elements, tester);
154:                 assertEquals(DUMMY_RANK_3, winner);
155:
156:         }
157:
158: }