Commit | Line | Data |
---|---|---|
63c43609 MR |
1 | /******************************************************************************* |
2 | * Copyright (c) 2014 École Polytechnique de Montréal | |
3 | * | |
4 | * All rights reserved. This program and the accompanying materials are | |
5 | * made available under the terms of the Eclipse Public License v1.0 which | |
6 | * accompanies this distribution, and is available at | |
7 | * http://www.eclipse.org/legal/epl-v10.html | |
8 | * | |
9 | * Contributors: | |
10 | * Guilliano Molaire - Initial API and implementation | |
11 | * Mathieu Rail - Initial API and implementation | |
12 | *******************************************************************************/ | |
13 | ||
2bdf0193 | 14 | package org.eclipse.tracecompass.tmf.core.tests.analysis; |
63c43609 MR |
15 | |
16 | import java.util.ArrayList; | |
17 | import java.util.List; | |
18 | import java.util.Set; | |
19 | ||
aa353506 | 20 | import org.eclipse.jdt.annotation.NonNull; |
2bdf0193 AM |
21 | import org.eclipse.tracecompass.tmf.core.analysis.TmfAnalysisRequirement; |
22 | import org.eclipse.tracecompass.tmf.core.analysis.TmfAnalysisRequirement.ValuePriorityLevel; | |
63c43609 MR |
23 | |
24 | import static org.junit.Assert.assertEquals; | |
25 | import static org.junit.Assert.assertFalse; | |
26 | import static org.junit.Assert.assertNull; | |
27 | import static org.junit.Assert.assertTrue; | |
28 | ||
29 | import org.junit.Test; | |
30 | ||
31 | /** | |
32 | * Test suite for the {@link TmfAnalysisRequirement} class. | |
33 | * | |
34 | * @author Guilliano Molaire | |
35 | * @author Mathieu Rail | |
36 | */ | |
37 | public class AnalysisRequirementTest { | |
38 | ||
39 | /* Requirements used in the tests */ | |
40 | private TmfAnalysisRequirement fRequirement; | |
41 | private TmfAnalysisRequirement fSubRequirement; | |
42 | ||
43 | /* Types of requirement type strings */ | |
44 | private static final String TYPE_A = "Test Type A"; | |
45 | private static final String TYPE_B = "Test Type B"; | |
46 | ||
47 | /* Requirement value name strings */ | |
48 | private static final String VALUE_A = "Test Value A"; | |
49 | private static final String VALUE_B = "Test Value B"; | |
50 | private static final String VALUE_C = "Test Value C"; | |
51 | private static final String VALUE_D = "Test Value D"; | |
52 | private static final String VALUE_E = "Test Value E"; | |
53 | private static final String VALUE_F = "Test Value F"; | |
54 | ||
55 | /* Requirement information strings */ | |
aa353506 AM |
56 | private static final @NonNull String INFO_A = "This is an information."; |
57 | private static final @NonNull String INFO_B = "This is another information."; | |
58 | private static final @NonNull String INFO_C = "This is the last information."; | |
63c43609 MR |
59 | |
60 | /** | |
61 | * Test suite for the {@link TmfAnalysisRequirement#addInformation} and the | |
62 | * {@link TmfAnalysisRequirement#getInformation} methods. | |
63 | */ | |
64 | @Test | |
65 | public void testAddAndGetInformation() { | |
66 | fRequirement = new TmfAnalysisRequirement(TYPE_A); | |
67 | ||
68 | fRequirement.addInformation(INFO_A); | |
69 | fRequirement.addInformation(INFO_B); | |
70 | fRequirement.addInformation(INFO_B); | |
71 | ||
72 | Set<String> information = fRequirement.getInformation(); | |
73 | ||
74 | assertEquals(2, information.size()); | |
75 | ||
76 | assertTrue(information.contains(INFO_A)); | |
77 | assertTrue(information.contains(INFO_B)); | |
78 | } | |
79 | ||
80 | /** | |
81 | * Test suite for the {@link TmfAnalysisRequirement#addValues} and the | |
82 | * {@link TmfAnalysisRequirement#addValue} methods. | |
83 | */ | |
84 | @Test | |
85 | public void testAddValuesToRequirement() { | |
86 | fRequirement = new TmfAnalysisRequirement(TYPE_A); | |
87 | ||
88 | assertEquals(0, fRequirement.getValues().size()); | |
89 | ||
90 | List<String> values = new ArrayList<>(); | |
91 | values.add(VALUE_A); | |
92 | values.add(VALUE_B); | |
93 | values.add(VALUE_C); | |
94 | values.add(VALUE_C); | |
95 | ||
96 | /* | |
97 | * Add values to the requirement with the same level, Value C should | |
98 | * only exist once | |
99 | */ | |
100 | fRequirement.addValues(values, ValuePriorityLevel.MANDATORY); | |
101 | assertEquals(3, fRequirement.getValues().size()); | |
102 | ||
103 | /* | |
104 | * The new value should only exist once and its level should be | |
105 | * mandatory | |
106 | */ | |
107 | fRequirement.addValue(VALUE_D, ValuePriorityLevel.OPTIONAL); | |
108 | fRequirement.addValue(VALUE_D, ValuePriorityLevel.MANDATORY); | |
109 | ||
110 | assertEquals(4, fRequirement.getValues().size()); | |
111 | assertEquals(ValuePriorityLevel.MANDATORY, fRequirement.getValueLevel(VALUE_D)); | |
112 | } | |
113 | ||
114 | /** | |
115 | * Test suite for the {@link TmfAnalysisRequirement#getValueLevel} method. | |
116 | */ | |
117 | @Test | |
118 | public void testGetValueLevel() { | |
119 | fRequirement = new TmfAnalysisRequirement(TYPE_A); | |
120 | fRequirement.addValue(VALUE_A, ValuePriorityLevel.OPTIONAL); | |
121 | ||
122 | /* Try to get the level of a value */ | |
123 | assertEquals(ValuePriorityLevel.OPTIONAL, fRequirement.getValueLevel(VALUE_A)); | |
124 | ||
125 | /* Try to get the level of a value that doesn't exist */ | |
126 | assertNull(fRequirement.getValueLevel(VALUE_B)); | |
127 | } | |
128 | ||
129 | /** | |
130 | * Test suite for the {@link TmfAnalysisRequirement#merge} method with the | |
131 | * parameter value MANDATORY. | |
132 | */ | |
133 | @Test | |
134 | public void testMergeMandatory() { | |
135 | initMergeRequirements(TYPE_A, TYPE_A); | |
136 | ||
137 | assertTrue(fRequirement.merge(fSubRequirement, ValuePriorityLevel.MANDATORY)); | |
138 | ||
139 | assertEquals(fRequirement.getValues().size(), 6); | |
140 | ||
141 | assertEquals(ValuePriorityLevel.MANDATORY, fRequirement.getValueLevel(VALUE_A)); | |
142 | assertEquals(ValuePriorityLevel.MANDATORY, fRequirement.getValueLevel(VALUE_B)); | |
143 | ||
144 | assertEquals(ValuePriorityLevel.MANDATORY, fRequirement.getValueLevel(VALUE_C)); | |
145 | assertEquals(ValuePriorityLevel.OPTIONAL, fRequirement.getValueLevel(VALUE_D)); | |
146 | ||
147 | assertEquals(ValuePriorityLevel.MANDATORY, fRequirement.getValueLevel(VALUE_E)); | |
148 | assertEquals(ValuePriorityLevel.OPTIONAL, fRequirement.getValueLevel(VALUE_F)); | |
149 | ||
150 | Set<String> information = fRequirement.getInformation(); | |
151 | ||
152 | assertEquals(3, information.size()); | |
153 | ||
154 | assertTrue(information.contains(INFO_A)); | |
155 | assertTrue(information.contains(INFO_B)); | |
156 | assertTrue(information.contains(INFO_C)); | |
157 | } | |
158 | ||
159 | /** | |
160 | * Test suite for the {@link TmfAnalysisRequirement#merge} method with the | |
161 | * parameter value OPTIONAL. | |
162 | */ | |
163 | @Test | |
164 | public void testMergeOptional() { | |
165 | initMergeRequirements(TYPE_A, TYPE_A); | |
166 | ||
167 | assertTrue(fRequirement.merge(fSubRequirement, ValuePriorityLevel.OPTIONAL)); | |
168 | ||
169 | assertEquals(6, fRequirement.getValues().size()); | |
170 | ||
171 | assertEquals(ValuePriorityLevel.MANDATORY, fRequirement.getValueLevel(VALUE_A)); | |
172 | assertEquals(ValuePriorityLevel.MANDATORY, fRequirement.getValueLevel(VALUE_B)); | |
173 | ||
174 | assertEquals(ValuePriorityLevel.OPTIONAL, fRequirement.getValueLevel(VALUE_C)); | |
175 | assertEquals(ValuePriorityLevel.OPTIONAL, fRequirement.getValueLevel(VALUE_D)); | |
176 | ||
177 | assertEquals(ValuePriorityLevel.OPTIONAL, fRequirement.getValueLevel(VALUE_E)); | |
178 | assertEquals(ValuePriorityLevel.OPTIONAL, fRequirement.getValueLevel(VALUE_F)); | |
179 | ||
180 | Set<String> information = fRequirement.getInformation(); | |
181 | ||
182 | assertEquals(3, information.size()); | |
183 | ||
184 | assertTrue(information.contains(INFO_A)); | |
185 | assertTrue(information.contains(INFO_B)); | |
186 | assertTrue(information.contains(INFO_C)); | |
187 | } | |
188 | ||
189 | /** | |
190 | * Test suite for the {@link TmfAnalysisRequirement#merge} method with | |
191 | * different requirement types. | |
192 | */ | |
193 | @Test | |
194 | public void testMergeDifferentTypes() { | |
195 | initMergeRequirements(TYPE_A, TYPE_B); | |
196 | ||
197 | assertFalse(fRequirement.merge(fSubRequirement, ValuePriorityLevel.OPTIONAL)); | |
198 | } | |
199 | ||
200 | /** | |
201 | * Test suite for the {@link TmfAnalysisRequirement#isSameType} method. | |
202 | */ | |
203 | @Test | |
204 | public void testIsSameRequirementType() { | |
205 | fRequirement = new TmfAnalysisRequirement(TYPE_A); | |
206 | ||
207 | assertTrue(fRequirement.isSameType(new TmfAnalysisRequirement(TYPE_A))); | |
208 | assertFalse(fRequirement.isSameType(new TmfAnalysisRequirement(TYPE_B))); | |
209 | } | |
210 | ||
211 | /** | |
212 | * Initialize the requirement and sub-requirement for the merge tests. | |
213 | * | |
214 | * @param typeA | |
215 | * The type of the first requirement | |
216 | * @param typeB | |
217 | * The type of the second requirement | |
218 | */ | |
219 | private void initMergeRequirements(String typeA, String typeB) { | |
220 | fRequirement = new TmfAnalysisRequirement(typeA); | |
221 | fRequirement.addValue(VALUE_A, ValuePriorityLevel.MANDATORY); | |
222 | fRequirement.addValue(VALUE_B, ValuePriorityLevel.MANDATORY); | |
223 | ||
224 | fRequirement.addValue(VALUE_C, ValuePriorityLevel.OPTIONAL); | |
225 | fRequirement.addValue(VALUE_D, ValuePriorityLevel.OPTIONAL); | |
226 | ||
227 | fRequirement.addInformation(INFO_A); | |
228 | fRequirement.addInformation(INFO_B); | |
229 | ||
230 | /* This sub-requirement will be merged into requirement */ | |
231 | fSubRequirement = new TmfAnalysisRequirement(typeB); | |
232 | fSubRequirement.addValue(VALUE_A, ValuePriorityLevel.MANDATORY); | |
233 | fSubRequirement.addValue(VALUE_B, ValuePriorityLevel.OPTIONAL); | |
234 | ||
235 | fSubRequirement.addValue(VALUE_C, ValuePriorityLevel.MANDATORY); | |
236 | fSubRequirement.addValue(VALUE_D, ValuePriorityLevel.OPTIONAL); | |
237 | ||
238 | fSubRequirement.addValue(VALUE_E, ValuePriorityLevel.MANDATORY); | |
239 | fSubRequirement.addValue(VALUE_F, ValuePriorityLevel.OPTIONAL); | |
240 | ||
241 | fSubRequirement.addInformation(INFO_B); | |
242 | fSubRequirement.addInformation(INFO_C); | |
243 | } | |
244 | } |