1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
|
/*******************************************************************************
* Copyright (c) 2008, 2009 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.pde.api.tools.builder.tests.tags;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import junit.framework.Test;
import junit.framework.TestSuite;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.jdt.core.tests.junit.extension.TestCase;
import org.eclipse.pde.api.tools.builder.tests.ApiBuilderTest;
import org.eclipse.pde.api.tools.builder.tests.ApiProblem;
import org.eclipse.pde.api.tools.builder.tests.ApiTestingEnvironment;
import org.eclipse.pde.api.tools.model.tests.TestSuiteHelper;
/**
* Tests the builder to make sure it correctly finds and reports
* unsupported tag usage.
*
* @since 1.0
*/
public abstract class TagTest extends ApiBuilderTest {
protected static IPath WORKSPACE_PATH = new Path("tagproject/src/a/b/c");
protected static IPath WORKSPACE_PATH_DEFAULT = new Path("tagproject/src");
/**
* Constructor
*/
public TagTest(String name) {
super(name);
}
/**
* Sets the message arguments we are expecting for the given test, the number of times denoted
* by count
* @param tagname
* @param context
* @param count
*/
protected void setExpectedMessageArgs(String tagname, String context, int count) {
String[][] args = new String[count][];
for(int i = 0; i < count; i++) {
args[i] = new String[] {tagname, context};
}
setExpectedMessageArgs(args);
}
/**
* @return all of the child test classes of this class
*/
private static Class[] getAllTestClasses() {
Class[] classes = new Class[] {
InvalidClassTagTests.class,
ValidClassTagTests.class,
InvalidInterfaceTagTests.class,
ValidInterfaceTagTests.class,
InvalidFieldTagTests.class,
ValidFieldTagTests.class,
InvalidMethodTagTests.class,
ValidMethodTagTests.class,
InvalidEnumTagTests.class,
InvalidAnnotationTagTests.class,
InvalidDuplicateTagsTests.class
};
return classes;
}
/**
* Collects tests from the getAllTestClasses() method into the given suite
* @param suite
*/
private static void collectTests(TestSuite suite) {
// Hack to load all classes before computing their suite of test cases
// this allow to reset test cases subsets while running all Builder tests...
Class[] classes = getAllTestClasses();
// Reset forgotten subsets of tests
TestCase.TESTS_PREFIX = null;
TestCase.TESTS_NAMES = null;
TestCase.TESTS_NUMBERS = null;
TestCase.TESTS_RANGE = null;
TestCase.RUN_ONLY_ID = null;
/* tests */
for (int i = 0, length = classes.length; i < length; i++) {
Class clazz = classes[i];
Method suiteMethod;
try {
suiteMethod = clazz.getDeclaredMethod("suite", new Class[0]);
} catch (NoSuchMethodException e) {
e.printStackTrace();
continue;
}
Object test;
try {
test = suiteMethod.invoke(null, new Object[0]);
} catch (IllegalAccessException e) {
e.printStackTrace();
continue;
} catch (InvocationTargetException e) {
e.printStackTrace();
continue;
}
suite.addTest((Test) test);
}
}
/**
* @return the tests for this class
*/
public static Test suite() {
TestSuite suite = new TestSuite(TagTest.class.getName());
collectTests(suite);
return suite;
}
/* (non-Javadoc)
* @see org.eclipse.pde.api.tools.builder.tests.ApiBuilderTests#setBuilderOptions()
*/
protected void setBuilderOptions() {
//only care about unsupported tags
enableUnsupportedTagOptions(true);
//disable the rest
enableBaselineOptions(false);
enableCompatibilityOptions(false);
enableLeakOptions(false);
enableSinceTagOptions(false);
enableUsageOptions(false);
enableVersionNumberOptions(false);
}
/**
* Returns an array composed only of the specified number of {@link #PROBLEM_ID}
* @param problemcount
* @return an array of {@link #PROBLEM_ID} of the specified size, or an empty array if the specified
* size is < 1
*/
protected int[] getDefaultProblemSet(int problemcount) {
if(problemcount < 1) {
return new int[0];
}
int[] array = new int[problemcount];
int defaultproblem = getDefaultProblemId();
for(int i = 0; i < problemcount; i++) {
array[i] = defaultproblem;
}
return array;
}
/* (non-Javadoc)
* @see org.eclipse.pde.api.tools.builder.tests.ApiBuilderTests#getTestSourcePath()
*/
protected IPath getTestSourcePath() {
return new Path("tags");
}
/* (non-Javadoc)
* @see org.eclipse.pde.api.tools.builder.tests.ApiBuilderTests#getTestingProjectName()
*/
protected String getTestingProjectName() {
return "tagproject";
}
/**
* Deploys a build test for API Javadoc tags using the given source file,
* looking for problems specified from {@link #getExpectedProblemIds()()}
* @param sourcename
* @param incremental if an incremental build should take place
* @param usedefault if the default package should be used or not
*/
protected void deployTagTest(String sourcename, boolean incremental, boolean usedefault) {
try {
IPath path = WORKSPACE_PATH.append(sourcename);
if(usedefault) {
path = WORKSPACE_PATH_DEFAULT.append(sourcename);
}
createWorkspaceFile(path, TestSuiteHelper.getPluginDirectoryPath().append(TEST_SOURCE_ROOT).append(getTestSourcePath()).append(sourcename));
if(incremental) {
incrementalBuild();
}
else {
fullBuild();
}
expectingNoJDTProblemsFor(path);
ApiProblem[] problems = getEnv().getProblemsFor(path, null);
assertProblems(problems);
}
catch(Exception e) {
fail(e.getMessage());
}
}
/* (non-Javadoc)
* @see org.eclipse.pde.api.tools.builder.tests.ApiBuilderTest#setUp()
*/
@Override
protected void setUp() throws Exception {
ApiTestingEnvironment env = getEnv();
if (env != null) {
env.setRevert(true);
env.setRevertSourcePath(null);
}
super.setUp();
IProject project = getEnv().getWorkspace().getRoot().getProject(getTestingProjectName());
if (!project.exists()) {
// populate the workspace with initial plug-ins/projects
createExistingProjects("tagprojects", true, true, false);
}
}
/* (non-Javadoc)
* @see org.eclipse.pde.api.tools.builder.tests.ApiBuilderTest#tearDown()
*/
@Override
protected void tearDown() throws Exception {
super.tearDown();
ApiTestingEnvironment env = getEnv();
if (env != null) {
env.setRevert(false);
}
}
}
|
