001: /*
002: * Created on 18.08.2004
003: */
004: package test.net.sourceforge.pmd.dfa;
005:
006: import static org.junit.Assert.assertTrue;
007: import net.sourceforge.pmd.PMD;
008: import net.sourceforge.pmd.ast.ASTMethodDeclarator;
009: import net.sourceforge.pmd.dfa.IDataFlowNode;
010:
011: import org.junit.Test;
012:
013: import test.net.sourceforge.pmd.testframework.ParserTst;
014:
015: import java.util.List;
016:
017: public class AcceptanceTest extends ParserTst {
018:
019: @Test
020: public void testbook() throws Throwable {
021: getOrderedNodes(ASTMethodDeclarator.class, FOO);
022: }
023:
024: private static final String FOO = "class Foo {" + PMD.EOL
025: + " void bar() {" + PMD.EOL + " int x = 2;" + PMD.EOL
026: + " }" + PMD.EOL + "}";
027:
028: @Test
029: public void testLabelledBreakLockup() throws Throwable {
030: getOrderedNodes(ASTMethodDeclarator.class,
031: LABELLED_BREAK_LOCKUP);
032: }
033:
034: private static final String LABELLED_BREAK_LOCKUP = "class Foo {"
035: + PMD.EOL + " void bar(int x) {" + PMD.EOL
036: + " here: if (x>2) {" + PMD.EOL + " break here;"
037: + PMD.EOL + " }" + PMD.EOL + " }" + PMD.EOL + "}";
038:
039: private boolean check(int[][] array, List methodNodes) {
040: for (int i = 0; i < methodNodes.size(); i++) {
041: ASTMethodDeclarator decl = (ASTMethodDeclarator) methodNodes
042: .get(i);
043: IDataFlowNode inode = decl.getDataFlowNode();
044: for (int j = 0; j < inode.getChildren().size(); j++) {
045: IDataFlowNode child = inode.getChildren().get(j);
046: if (array[i][j] != child.getIndex() - 1) {
047: return false;
048: }
049: }
050: }
051: return true;
052: }
053:
054: @Test
055: public void test_1() throws Throwable {
056: assertTrue(check(TEST1_NODES, getOrderedNodes(
057: ASTMethodDeclarator.class, TEST1)));
058: }
059:
060: @Test
061: public void test_2() throws Throwable {
062: assertTrue(check(TEST2_NODES, getOrderedNodes(
063: ASTMethodDeclarator.class, TEST2)));
064: }
065:
066: @Test
067: public void test_3() throws Throwable {
068: assertTrue(check(TEST3_NODES, getOrderedNodes(
069: ASTMethodDeclarator.class, TEST3)));
070: }
071:
072: @Test
073: public void test_4() throws Throwable {
074: assertTrue(check(TEST4_NODES, getOrderedNodes(
075: ASTMethodDeclarator.class, TEST4)));
076: }
077:
078: @Test
079: public void test_6() throws Throwable {
080: assertTrue(check(TEST5_NODES, getOrderedNodes(
081: ASTMethodDeclarator.class, TEST6)));
082: }
083:
084: @Test
085: public void test_7() throws Throwable {
086: assertTrue(check(TEST5_NODES, getOrderedNodes(
087: ASTMethodDeclarator.class, TEST7)));
088: }
089:
090: @Test
091: public void test_8() throws Throwable {
092: assertTrue(check(TEST8_NODES, getOrderedNodes(
093: ASTMethodDeclarator.class, TEST8)));
094: }
095:
096: @Test
097: public void test_9() throws Throwable {
098: assertTrue(check(TEST5_NODES, getOrderedNodes(
099: ASTMethodDeclarator.class, TEST9)));
100: }
101:
102: @Test
103: public void test_10() throws Throwable {
104: assertTrue(check(TEST8_NODES, getOrderedNodes(
105: ASTMethodDeclarator.class, TEST10)));
106: }
107:
108: @Test
109: public void test_11() throws Throwable {
110: assertTrue(check(TEST8_NODES, getOrderedNodes(
111: ASTMethodDeclarator.class, TEST11)));
112: }
113:
114: @Test
115: public void test_12() throws Throwable {
116: assertTrue(check(TEST12_NODES, getOrderedNodes(
117: ASTMethodDeclarator.class, TEST12)));
118: }
119:
120: @Test
121: public void test_13() throws Throwable {
122: assertTrue(check(TEST13_NODES, getOrderedNodes(
123: ASTMethodDeclarator.class, TEST13)));
124: }
125:
126: @Test
127: public void test_14() throws Throwable {
128: assertTrue(check(TEST14_NODES, getOrderedNodes(
129: ASTMethodDeclarator.class, TEST14)));
130: }
131:
132: @Test
133: public void test_15() throws Throwable {
134: assertTrue(check(TEST15_NODES, getOrderedNodes(
135: ASTMethodDeclarator.class, TEST15)));
136: }
137:
138: @Test
139: public void test_16() throws Throwable {
140: assertTrue(check(TEST16_NODES, getOrderedNodes(
141: ASTMethodDeclarator.class, TEST16)));
142: }
143:
144: @Test
145: public void test_17() throws Throwable {
146: assertTrue(check(TEST17_NODES, getOrderedNodes(
147: ASTMethodDeclarator.class, TEST17)));
148: }
149:
150: @Test
151: public void test_18() throws Throwable {
152: assertTrue(check(TEST18_NODES, getOrderedNodes(
153: ASTMethodDeclarator.class, TEST18)));
154: }
155:
156: @Test
157: public void test_19() throws Throwable {
158: assertTrue(check(TEST19_NODES, getOrderedNodes(
159: ASTMethodDeclarator.class, TEST19)));
160: }
161:
162: @Test
163: public void test_20() throws Throwable {
164: assertTrue(check(TEST20_NODES, getOrderedNodes(
165: ASTMethodDeclarator.class, TEST20)));
166: }
167:
168: @Test
169: public void test_21() throws Throwable {
170: assertTrue(check(TEST21_NODES, getOrderedNodes(
171: ASTMethodDeclarator.class, TEST21)));
172: }
173:
174: @Test
175: public void test_22() throws Throwable {
176: assertTrue(check(TEST22_NODES, getOrderedNodes(
177: ASTMethodDeclarator.class, TEST22)));
178: }
179:
180: @Test
181: public void test_23() throws Throwable {
182: assertTrue(check(TEST23_NODES, getOrderedNodes(
183: ASTMethodDeclarator.class, TEST23)));
184: }
185:
186: @Test
187: public void test_24() throws Throwable {
188: assertTrue(check(TEST24_NODES, getOrderedNodes(
189: ASTMethodDeclarator.class, TEST24)));
190: }
191:
192: @Test
193: public void test_25() throws Throwable {
194: assertTrue(check(TEST25_NODES, getOrderedNodes(
195: ASTMethodDeclarator.class, TEST25)));
196: }
197:
198: @Test
199: public void test_26() throws Throwable {
200: assertTrue(check(TEST26_NODES, getOrderedNodes(
201: ASTMethodDeclarator.class, TEST26)));
202: }
203:
204: @Test
205: public void test_27() throws Throwable {
206: assertTrue(check(TEST27_NODES, getOrderedNodes(
207: ASTMethodDeclarator.class, TEST27)));
208: }
209:
210: @Test
211: public void test_28() throws Throwable {
212: assertTrue(check(TEST28_NODES, getOrderedNodes(
213: ASTMethodDeclarator.class, TEST28)));
214: }
215:
216: @Test
217: public void test_29() throws Throwable {
218: assertTrue(check(TEST29_NODES, getOrderedNodes(
219: ASTMethodDeclarator.class, TEST29)));
220: }
221:
222: @Test
223: public void test_30() throws Throwable {
224: assertTrue(check(TEST30_NODES, getOrderedNodes(
225: ASTMethodDeclarator.class, TEST30)));
226: }
227:
228: // first dimension: the index of a node
229: // second dimension: the indices of the children
230: private static final int[][] TEST1_NODES = { { 1 }, { 2 }, { 3 },
231: { 4, 6 }, { 5 }, { 6 }, {} };
232:
233: private static final String TEST1 = "class Foo {" + PMD.EOL
234: + " void test_1() {" + PMD.EOL + " int x = 0;" + PMD.EOL
235: + " if (x == 0) {" + PMD.EOL + " x++;" + PMD.EOL
236: + " x = 0;" + PMD.EOL + " }" + PMD.EOL + " }" + PMD.EOL
237: + " }";
238:
239: private static final int[][] TEST2_NODES = { { 1 }, { 2 }, { 3 },
240: { 5, 7 }, { 3 }, { 6 }, { 4 }, {} };
241:
242: private static final String TEST2 = "class Foo {" + PMD.EOL
243: + " public void test_2() {" + PMD.EOL
244: + " for (int i = 0; i < 1; i++) {" + PMD.EOL + " i++;"
245: + PMD.EOL + " i = 8;" + PMD.EOL + " }" + PMD.EOL + " }"
246: + PMD.EOL + " }";
247:
248: private static final int[][] TEST3_NODES = { { 1 }, { 2 }, { 3 },
249: { 4, 5 }, { 3 }, {} };
250:
251: private static final String TEST3 = "public class Foo {" + PMD.EOL
252: + " public void test_3() {" + PMD.EOL
253: + " for (int i = 0; i < 1; i++) {" + PMD.EOL + " }"
254: + PMD.EOL + " }" + PMD.EOL + " }";
255:
256: private static final int[][] TEST4_NODES = { { 1 }, { 2 }, { 3 },
257: {} };
258:
259: private static final String TEST4 = "public class Foo {" + PMD.EOL
260: + " public void test_4() {" + PMD.EOL + " for (; ;) {"
261: + PMD.EOL + " }" + PMD.EOL + " }" + PMD.EOL + " }";
262:
263: private static final int[][] TEST5_NODES = { { 1 }, { 2 }, { 3 },
264: { 4 }, {} };
265:
266: private static final String TEST6 = "public class Foo {" + PMD.EOL
267: + " public void test_6() {" + PMD.EOL
268: + " for (int i = 0; ;) {" + PMD.EOL + " }" + PMD.EOL
269: + " }" + PMD.EOL + " }";
270:
271: private static final String TEST7 = "public class Foo {" + PMD.EOL
272: + " public void test_7() {" + PMD.EOL
273: + " for (int i = 0; i < 0;) {" + PMD.EOL + " }" + PMD.EOL
274: + " }" + PMD.EOL + " }";
275:
276: private static final int[][] TEST8_NODES = { { 1 }, { 2 }, { 3 },
277: { 4, 5 }, { 3 }, {} };
278:
279: public static final String TEST8 = "public class Foo {" + PMD.EOL
280: + " public void test_8() {" + PMD.EOL
281: + " for (int i = 0; ; i++) {" + PMD.EOL + " }" + PMD.EOL
282: + " }" + PMD.EOL + " }";
283:
284: public static final String TEST9 = "public class Foo {" + PMD.EOL
285: + " public void test_9() {" + PMD.EOL + " int i = 0;"
286: + PMD.EOL + " for (; i < 0;) {" + PMD.EOL + " }"
287: + PMD.EOL + " }" + PMD.EOL + " }";
288:
289: public static final String TEST10 = "public class Foo {" + PMD.EOL
290: + " public void test_10() {" + PMD.EOL + " int i = 0;"
291: + PMD.EOL + " for (; i < 0; i++) {" + PMD.EOL + " }"
292: + PMD.EOL + " }" + PMD.EOL + " }";
293:
294: public static final String TEST11 = "public class Foo {" + PMD.EOL
295: + " public void test_11() {" + PMD.EOL + " int i = 0;"
296: + PMD.EOL + " for (; ; i++) {" + PMD.EOL + " }" + PMD.EOL
297: + " }" + PMD.EOL + " }";
298:
299: private static final int[][] TEST12_NODES = { { 1 }, { 2 }, { 3 },
300: { 4, 5 }, { 3 }, {} };
301: public static final String TEST12 = "public class Foo {" + PMD.EOL
302: + " public void test_12() {" + PMD.EOL + " for (; ;) {"
303: + PMD.EOL + " int i = 0;" + PMD.EOL + " }" + PMD.EOL
304: + " }" + PMD.EOL + " }";
305:
306: private static final int[][] TEST13_NODES = { { 1 }, { 2 }, { 3 },
307: { 5, 9 }, { 3 }, { 6 }, { 7, 8 }, { 8 }, { 4 }, {} };
308: public static final String TEST13 = "public class Foo {" + PMD.EOL
309: + " public void test_13() {" + PMD.EOL
310: + " for (int i = 0; i < 0; i++) {" + PMD.EOL + " i = 9;"
311: + PMD.EOL + " if (i < 8) {" + PMD.EOL + " i = 7;"
312: + PMD.EOL + " }" + PMD.EOL + " i = 6;" + PMD.EOL
313: + " }" + PMD.EOL + " }" + PMD.EOL + " }";
314:
315: private static final int[][] TEST14_NODES = { { 1 }, { 2 }, { 3 },
316: { 5, 8 }, { 3 }, { 6 }, { 7, 4 }, { 4 }, {} };
317: public static final String TEST14 = "public class Foo {" + PMD.EOL
318: + " public void test_14() {" + PMD.EOL
319: + " for (int i = 0; i < 0; i++) {" + PMD.EOL + " i = 9;"
320: + PMD.EOL + " if (i < 8) {" + PMD.EOL + " i = 7;"
321: + PMD.EOL + " }" + PMD.EOL + " }" + PMD.EOL + " }"
322: + PMD.EOL + " }";
323:
324: private static final int[][] TEST15_NODES = { { 1 }, { 2 }, { 3 },
325: { 5, 7 }, { 3 }, { 6, 4 }, { 4 }, {} };
326: public static final String TEST15 = "public class Foo {" + PMD.EOL
327: + " public void test_15() {" + PMD.EOL
328: + " for (int i = 0; i < 0; i++) {" + PMD.EOL
329: + " if (i < 8) {" + PMD.EOL + " i = 7;" + PMD.EOL
330: + " }" + PMD.EOL + " }" + PMD.EOL + " }" + PMD.EOL
331: + " }";
332:
333: private static final int[][] TEST16_NODES = { { 1 }, { 2 }, { 3 },
334: { 5, 8 }, { 3 }, { 6, 7 }, { 4 }, { 4 }, {} };
335: public static final String TEST16 = "public class Foo {" + PMD.EOL
336: + " public void test_16() {" + PMD.EOL
337: + " for (int i = 0; i < 0; i++) {" + PMD.EOL
338: + " if (i < 8) {" + PMD.EOL + " i = 7;" + PMD.EOL
339: + " } else {" + PMD.EOL + " i = 6;" + PMD.EOL + " }"
340: + PMD.EOL + " }" + PMD.EOL + " }" + PMD.EOL + " }";
341:
342: private static final int[][] TEST17_NODES = { { 1 }, { 2 }, { 3 },
343: { 5, 10 }, { 3 }, { 6, 7 }, { 4 }, { 8, 9 }, { 4 }, { 4 },
344: {} };
345: public static final String TEST17 = "public class Foo {" + PMD.EOL
346: + " public void test_17() {" + PMD.EOL
347: + " for (int i = 0; i < 0; i++) {" + PMD.EOL
348: + " if (i < 6) {" + PMD.EOL + " i = 7;" + PMD.EOL
349: + " } else if (i > 8) {" + PMD.EOL + " i = 9;"
350: + PMD.EOL + " } else {" + PMD.EOL + " i = 10;"
351: + PMD.EOL + " }" + PMD.EOL + " }" + PMD.EOL + " }"
352: + PMD.EOL + " }";
353:
354: private static final int[][] TEST18_NODES = { { 1 }, { 2 }, { 3 },
355: { 5, 9 }, { 3 }, { 6 }, { 8, 4 }, { 6 }, { 7 }, {} };
356: public static final String TEST18 = "public class Foo {" + PMD.EOL
357: + " public void test_18() {" + PMD.EOL
358: + " for (int i = 0; i < 0; i++) {" + PMD.EOL
359: + " for (int j = 0; j < 0; j++) {" + PMD.EOL + " j++;"
360: + PMD.EOL + " }" + PMD.EOL + " }" + PMD.EOL + " }"
361: + PMD.EOL + " }";
362:
363: private static final int[][] TEST19_NODES = { { 1 }, { 2 }, { 3 },
364: { 4, 5 }, { 10 }, { 6, 7 }, { 10 }, { 8, 9 }, { 10 },
365: { 10 }, {} };
366: public static final String TEST19 = "public class Foo {" + PMD.EOL
367: + " public void test_19() {" + PMD.EOL + " int i = 0;"
368: + PMD.EOL + " if (i == 1) {" + PMD.EOL + " i = 2;"
369: + PMD.EOL + " } else if (i == 3) {" + PMD.EOL
370: + " i = 4;" + PMD.EOL + " } else if (i == 5) {"
371: + PMD.EOL + " i = 6;" + PMD.EOL + " } else {" + PMD.EOL
372: + " i = 7;" + PMD.EOL + " }" + PMD.EOL + " }" + PMD.EOL
373: + " }";
374:
375: private static final int[][] TEST20_NODES = { { 1 }, { 2 }, { 3 },
376: { 4, 6 }, { 5, 7 }, { 7 }, { 7 }, {} };
377: public static final String TEST20 = "public class Foo {" + PMD.EOL
378: + " public void test_20() {" + PMD.EOL + " int i = 0;"
379: + PMD.EOL + " if (i == 1) {" + PMD.EOL
380: + " if (i == 2) {" + PMD.EOL + " i = 3;" + PMD.EOL
381: + " }" + PMD.EOL + " } else {" + PMD.EOL + " i = 7;"
382: + PMD.EOL + " }" + PMD.EOL + " }" + PMD.EOL + " }";
383:
384: private static final int[][] TEST21_NODES = { { 1 }, { 2 }, { 3 },
385: { 4, 9 }, { 5 }, { 7, 8 }, { 5 }, { 6 }, { 11 },
386: { 10, 11 }, { 11 }, {} };
387: public static final String TEST21 = "public class Foo {" + PMD.EOL
388: + " public void test_21() {" + PMD.EOL + " int i = 0;"
389: + PMD.EOL + " if (i == 1) {" + PMD.EOL
390: + " for (i = 3; i < 4; i++) {" + PMD.EOL + " i = 5;"
391: + PMD.EOL + " }" + PMD.EOL + " i++;" + PMD.EOL
392: + " } else if (i < 6) {" + PMD.EOL + " i = 7;" + PMD.EOL
393: + " }" + PMD.EOL + " }" + PMD.EOL + " }";
394:
395: private static final int[][] TEST22_NODES = { { 1 }, { 2 }, { 3 },
396: { 4, 8 }, { 5 }, { 7, 9 }, { 5 }, { 6 }, { 9 }, {} };
397: public static final String TEST22 = "public class Foo {" + PMD.EOL
398: + " public void test_22() {" + PMD.EOL + " int i = 0;"
399: + PMD.EOL + " if (i == 1) {" + PMD.EOL
400: + " for (i = 3; i < 4; i++) {" + PMD.EOL + " i = 5;"
401: + PMD.EOL + " }" + PMD.EOL + " } else {" + PMD.EOL
402: + " i = 7;" + PMD.EOL + " }" + PMD.EOL + " }" + PMD.EOL
403: + " }";
404:
405: private static final int[][] TEST23_NODES = { { 1 }, { 2 }, { 3 },
406: { 4, 8 }, { 5 }, { 7, 10 }, { 5 }, { 6 }, { 9, 10 },
407: { 10 }, {} };
408: public static final String TEST23 = "public class Foo {" + PMD.EOL
409: + " public void test_23() {" + PMD.EOL + " int i = 0;"
410: + PMD.EOL + " if (i == 1) {" + PMD.EOL
411: + " for (i = 3; i < 4; i++) {" + PMD.EOL + " i = 5;"
412: + PMD.EOL + " }" + PMD.EOL + " } else if (i < 6) {"
413: + PMD.EOL + " i = 7;" + PMD.EOL + " }" + PMD.EOL + " }"
414: + PMD.EOL + " }";
415:
416: private static final int[][] TEST24_NODES = { { 1 }, { 2 }, { 3 },
417: { 4, 9 }, { 5 }, { 7, 11 }, { 5 }, { 8, 6 }, { 6 },
418: { 10, 11 }, { 11 }, {} };
419: public static final String TEST24 = "public class Foo {" + PMD.EOL
420: + " public void test_24() {" + PMD.EOL + " int x = 0;"
421: + PMD.EOL + " if (x > 2) {" + PMD.EOL
422: + " for (int i = 0; i < 1; i++) {" + PMD.EOL
423: + " if (x > 3) {" + PMD.EOL + " x++;" + PMD.EOL
424: + " }" + PMD.EOL + " }" + PMD.EOL
425: + " } else if (x > 4) {" + PMD.EOL + " x++;" + PMD.EOL
426: + " }" + PMD.EOL + " }" + PMD.EOL + " }";
427:
428: private static final int[][] TEST25_NODES = { { 1 }, { 2 }, { 3 },
429: { 4, 5 }, { 5 }, {} };
430: public static final String TEST25 = "public class Foo {" + PMD.EOL
431: + " public void test_25() {" + PMD.EOL + " int x = 0;"
432: + PMD.EOL + " switch (x) {" + PMD.EOL + " default:"
433: + PMD.EOL + " x = 9;" + PMD.EOL + " }" + PMD.EOL + " }"
434: + PMD.EOL + " }";
435:
436: private static final int[][] TEST26_NODES = { { 1 }, { 2 }, { 3 },
437: { 4 }, { 5, 6 }, { 6 }, { 7 }, { 8, 3 }, { 9 }, {} };
438: public static final String TEST26 = "public class Foo {" + PMD.EOL
439: + " public void test_26() {" + PMD.EOL + " int x = 0;"
440: + PMD.EOL + " do {" + PMD.EOL + " if (x > 0) {"
441: + PMD.EOL + " x++;" + PMD.EOL + " }" + PMD.EOL
442: + " x++;" + PMD.EOL + " } while (x < 9);" + PMD.EOL
443: + " x++;" + PMD.EOL + " }" + PMD.EOL + " }";
444:
445: private static final int[][] TEST27_NODES = { { 1 }, { 2 }, { 3 },
446: { 5, 9 }, { 3 }, { 6 }, { 7 }, { 8 }, { 6, 4 }, {} };
447: public static final String TEST27 = "public class Foo {" + PMD.EOL
448: + " public void test_27() {" + PMD.EOL
449: + " for (int i = 0; i < 36; i++) {" + PMD.EOL
450: + " int x = 0;" + PMD.EOL + " do {" + PMD.EOL
451: + " x++;" + PMD.EOL + " } while (x < 9);" + PMD.EOL
452: + " }" + PMD.EOL + " }" + PMD.EOL + " }";
453:
454: private static final int[][] TEST28_NODES = { { 1 }, { 2 }, { 3 },
455: { 5, 14 }, { 3 }, { 6 }, { 7 }, { 8, 12 }, { 9 },
456: { 10, 12 }, { 11 }, { 12 }, { 13 }, { 6, 4 }, {} };
457: public static final String TEST28 = "public class Foo {" + PMD.EOL
458: + " private void test_28() {" + PMD.EOL
459: + " for (int i = 0; i < 36; i++) {" + PMD.EOL
460: + " int x = 0;" + PMD.EOL + " do {" + PMD.EOL
461: + " if (x > 0) {" + PMD.EOL + " x++;" + PMD.EOL
462: + " switch (i) {" + PMD.EOL + " case 0:" + PMD.EOL
463: + " x = 0;" + PMD.EOL + " break;" + PMD.EOL
464: + " }" + PMD.EOL + " }" + PMD.EOL + " x++;"
465: + PMD.EOL + " } while (x < 9);" + PMD.EOL + " }"
466: + PMD.EOL + " }" + PMD.EOL + " }";
467:
468: private static final int[][] TEST29_NODES = { { 1 }, { 2 },
469: { 3, 4, 5 }, { 6 }, { 6 }, { 6 }, {}
470:
471: };
472: public static final String TEST29 = "public class Foo {" + PMD.EOL
473: + " private void test_29() {" + PMD.EOL + " switch(x) {"
474: + PMD.EOL + " case 1:" + PMD.EOL + " break; "
475: + PMD.EOL + " default: " + PMD.EOL + " break;"
476: + PMD.EOL + " case 2:" + PMD.EOL + " break;" + PMD.EOL
477: + " }" + PMD.EOL + " }" + PMD.EOL + "}";
478:
479: private static final int[][] TEST30_NODES = { { 1 }, { 2 }, { 3 },
480: { 4, 7 }, { 5, 6 }, { 4 }, { 3 }, {} };
481: public static final String TEST30 = "public class Foo {" + PMD.EOL
482: + " private void test_30() {" + PMD.EOL + " int x = 0;"
483: + PMD.EOL + " while (true) {" + PMD.EOL
484: + " while (x>0) {" + PMD.EOL + " x++;" + PMD.EOL
485: + " }" + PMD.EOL + " continue;" + PMD.EOL + " }"
486: + PMD.EOL + " }" + PMD.EOL + "}";
487:
488: public static junit.framework.Test suite() {
489: return new junit.framework.JUnit4TestAdapter(
490: AcceptanceTest.class);
491: }
492: }
|