001: /*
002: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
003: *
004: * Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.
005: *
006: * The contents of this file are subject to the terms of either the GNU
007: * General Public License Version 2 only ("GPL") or the Common
008: * Development and Distribution License("CDDL") (collectively, the
009: * "License"). You may not use this file except in compliance with the
010: * License. You can obtain a copy of the License at
011: * http://www.netbeans.org/cddl-gplv2.html
012: * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
013: * specific language governing permissions and limitations under the
014: * License. When distributing the software, include this License Header
015: * Notice in each file and include the License file at
016: * nbbuild/licenses/CDDL-GPL-2-CP. Sun designates this
017: * particular file as subject to the "Classpath" exception as provided
018: * by Sun in the GPL Version 2 section of the License file that
019: * accompanied this code. If applicable, add the following below the
020: * License Header, with the fields enclosed by brackets [] replaced by
021: * your own identifying information:
022: * "Portions Copyrighted [year] [name of copyright owner]"
023: *
024: * Contributor(s):
025: *
026: * The Original Software is NetBeans. The Initial Developer of the Original
027: * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun
028: * Microsystems, Inc. All Rights Reserved.
029: *
030: * If you wish your version of this file to be governed by only the CDDL
031: * or only the GPL Version 2, indicate your decision by adding
032: * "[Contributor] elects to include this software in this distribution
033: * under the [CDDL or GPL Version 2] license." If you do not indicate a
034: * single choice of license, a recipient has the option to distribute
035: * your version of this file under either the CDDL, the GPL Version 2 or
036: * to extend the choice of license to its licensees as provided above.
037: * However, if you add GPL Version 2 code and therefore, elected the GPL
038: * Version 2 license, then the option applies only if the new code is
039: * made subject to such option by the copyright holder.
040: */
041:
042: package org.netbeans.spi.project.support.ant;
043:
044: import org.netbeans.api.project.FileOwnerQuery;
045: import org.netbeans.api.project.Project;
046: import org.netbeans.api.project.ProjectManager;
047: import org.netbeans.api.project.ProjectUtils;
048: import org.netbeans.api.project.TestUtil;
049: import org.netbeans.junit.NbTestCase;
050: import org.netbeans.api.project.SourceGroup;
051: import org.netbeans.api.project.Sources;
052: import org.openide.filesystems.FileObject;
053: import org.openide.filesystems.FileUtil;
054: import org.openide.util.test.MockChangeListener;
055: import org.openide.util.test.MockLookup;
056: import org.openide.util.test.MockPropertyChangeListener;
057:
058: /**
059: * Test functionality of SourcesHelper.
060: * @author Jesse Glick
061: */
062: public final class SourcesHelperTest extends NbTestCase {
063:
064: public SourcesHelperTest(String name) {
065: super (name);
066: }
067:
068: private FileObject scratch;
069: private FileObject maindir;
070: private FileObject projdir;
071: private FileObject src1dir;
072: private FileObject src2dir;
073: private FileObject src3dir;
074: private FileObject src4dir;
075: private FileObject builddir;
076: private FileObject extdir;
077: private FileObject ext2dir;
078: private AntProjectHelper h;
079: private Project project;
080: private SourcesHelper sh;
081: private FileObject proj2dir;
082: private FileObject proj2src1dir;
083: private FileObject proj2src2dir;
084: private AntProjectHelper h2;
085: private Project project2;
086: private SourcesHelper sh2;
087:
088: protected void setUp() throws Exception {
089: super .setUp();
090: MockLookup.setInstances(AntBasedTestUtil
091: .testAntBasedProjectType());
092: scratch = TestUtil.makeScratchDir(this );
093: scratch.createData("otherfile");
094: maindir = scratch.createFolder("dir");
095: maindir.createData("readme");
096: projdir = maindir.createFolder("projdir");
097: projdir.createData("projfile");
098: src1dir = projdir.createFolder("src1");
099: src1dir.createData("src1file");
100: src2dir = scratch.createFolder("src2");
101: src2dir.createData("src2file");
102: src3dir = scratch.createFolder("src3");
103: src3dir.createData("src3file");
104: src4dir = scratch.createFolder("src4");
105: src4dir.createData("src4file");
106: builddir = scratch.createFolder("build");
107: builddir.createData("buildfile");
108: extdir = scratch.createFolder("external");
109: extdir.createData("extFile");
110: h = ProjectGenerator.createProject(projdir, "test");
111: project = ProjectManager.getDefault().findProject(projdir);
112: assertNotNull("have a project", project);
113: EditableProperties p = h
114: .getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH);
115: p.setProperty("src1.dir", "src1");
116: p.setProperty("src2.dir", "../../src2");
117: p.setProperty("src2a.dir", "../../src2"); // same path as src2.dir
118: p.setProperty("src3.dir", FileUtil.toFile(src3dir)
119: .getAbsolutePath());
120: p.setProperty("src4.dir", "..");
121: p.setProperty("src5.dir", "../../nonesuch");
122: p.setProperty("build.dir", "../../build");
123: p.setProperty("ext.file", "../../external/extFile");
124: h.putProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH, p);
125: ProjectManager.getDefault().saveProject(project);
126: sh = new SourcesHelper(h, h.getStandardPropertyEvaluator());
127: sh.addPrincipalSourceRoot("${src1.dir}", "Sources #1", null,
128: null); // inside proj dir
129: sh.addPrincipalSourceRoot("${src2.dir}", "Sources #2", null,
130: null); // outside (rel path)
131: sh.addPrincipalSourceRoot("${src2a.dir}", "Sources #2a", null,
132: null); // redundant
133: sh.addPrincipalSourceRoot("${src3.dir}", "Sources #3", null,
134: null); // outside (abs path)
135: sh.addPrincipalSourceRoot("${src4.dir}", "The Whole Shebang",
136: null, null); // above proj dir
137: sh.addPrincipalSourceRoot("${src5.dir}", "None such", null,
138: null); // does not exist on disk
139: sh.addNonSourceRoot("${build.dir}");
140: sh.addOwnedFile("${ext.file}");
141: sh.addTypedSourceRoot("${src1.dir}", "java", "Packages #1",
142: null, null);
143: sh.addTypedSourceRoot("${src3.dir}", "java", "Packages #3",
144: null, null);
145: sh.addTypedSourceRoot("${src5.dir}", "java", "No Packages",
146: null, null);
147: sh.addTypedSourceRoot("${src2.dir}", "docroot", "Documents #2",
148: null, null);
149: sh.addTypedSourceRoot("${src2a.dir}", "docroot",
150: "Documents #2a", null, null); // redundant
151: // Separate project that has includes its project directory implicitly only.
152: // Also hardcodes paths rather than using properties.
153: proj2dir = scratch.createFolder("proj2dir");
154: proj2dir.createData("proj2file");
155: proj2src1dir = proj2dir.createFolder("src1");
156: proj2src1dir.createData("proj2src1file");
157: proj2src2dir = proj2dir.createFolder("src2");
158: proj2src2dir.createData("proj2src2file");
159: ext2dir = scratch.createFolder("external2");
160: FileObject ext2File = ext2dir.createData("ext2File");
161: h2 = ProjectGenerator.createProject(proj2dir, "test");
162: project2 = ProjectManager.getDefault().findProject(proj2dir);
163: assertNotNull("have a project2", project2);
164: sh2 = new SourcesHelper(h2, h2.getStandardPropertyEvaluator());
165: sh2.addPrincipalSourceRoot("src1", "Sources #1", null, null);
166: sh2.addPrincipalSourceRoot("src2", "Sources #2", null, null);
167: sh2.addNonSourceRoot("build");
168: sh2.addOwnedFile(FileUtil.toFile(ext2File).getAbsolutePath());
169: sh2.addTypedSourceRoot("src1", "java", "Packages #1", null,
170: null);
171: sh2.addTypedSourceRoot("src2", "java", "Packages #2", null,
172: null);
173: }
174:
175: public void testSourcesBasic() throws Exception {
176: Sources s = sh.createSources();
177: // XXX test that ISE is thrown if we try to add more dirs now
178: SourceGroup[] groups = s.getSourceGroups(Sources.TYPE_GENERIC);
179: assertEquals("should have maindir plus src2dir plus src3dir",
180: 3, groups.length);
181: assertEquals("group #1 is src2dir", src2dir, groups[0]
182: .getRootFolder());
183: assertEquals("right display name for src2dir", "Sources #2",
184: groups[0].getDisplayName());
185: assertEquals("group #2 is src3dir", src3dir, groups[1]
186: .getRootFolder());
187: assertEquals("right display name for src3dir", "Sources #3",
188: groups[1].getDisplayName());
189: assertEquals("group #3 is maindir", maindir, groups[2]
190: .getRootFolder());
191: assertEquals("right display name for maindir",
192: "The Whole Shebang", groups[2].getDisplayName());
193: // Now the typed source roots.
194: groups = s.getSourceGroups("java");
195: assertEquals("should have src1dir plus src3dir", 2,
196: groups.length);
197: assertEquals("group #1 is src1dir", src1dir, groups[0]
198: .getRootFolder());
199: assertEquals("right display name for src1dir", "Packages #1",
200: groups[0].getDisplayName());
201: assertEquals("group #2 is src3dir", src3dir, groups[1]
202: .getRootFolder());
203: assertEquals("right display name for src3dir", "Packages #3",
204: groups[1].getDisplayName());
205: groups = s.getSourceGroups("docroot");
206: assertEquals("should have just src2dir", 1, groups.length);
207: assertEquals("group #1 is src2dir", src2dir, groups[0]
208: .getRootFolder());
209: assertEquals("right display name for src2dir", "Documents #2",
210: groups[0].getDisplayName());
211: groups = s.getSourceGroups("unknown");
212: assertEquals("should not have any unknown dirs", 0,
213: groups.length);
214: // Test the simpler project type.
215: s = sh2.createSources();
216: groups = s.getSourceGroups(Sources.TYPE_GENERIC);
217: assertEquals("should have just proj2dir", 1, groups.length);
218: assertEquals("group #1 is proj2dir", proj2dir, groups[0]
219: .getRootFolder());
220: assertEquals("right display name for proj2dir", ProjectUtils
221: .getInformation(project2).getDisplayName(), groups[0]
222: .getDisplayName());
223: groups = s.getSourceGroups("java");
224: assertEquals("should have proj2src1dir plus proj2src2dir", 2,
225: groups.length);
226: assertEquals("group #1 is proj2src1dir group", proj2src1dir,
227: groups[0].getRootFolder());
228: assertEquals("right display name for src1dir", "Packages #1",
229: groups[0].getDisplayName());
230: assertEquals("group #2 is proj2src2dir group", proj2src2dir,
231: groups[1].getRootFolder());
232: assertEquals("right display name for proj2src2dir",
233: "Packages #2", groups[1].getDisplayName());
234: // XXX test also icons
235: }
236:
237: public void testExternalRootRegistration() throws Exception {
238: FileObject f = maindir.getFileObject("readme");
239: assertEquals("readme not yet registered", null, FileOwnerQuery
240: .getOwner(f));
241: f = projdir.getFileObject("projfile");
242: assertEquals("projfile initially OK", project, FileOwnerQuery
243: .getOwner(f));
244: sh
245: .registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
246: f = maindir.getFileObject("readme");
247: assertEquals("readme now registered", project, FileOwnerQuery
248: .getOwner(f));
249: f = projdir.getFileObject("projfile");
250: assertEquals("projfile still OK", project, FileOwnerQuery
251: .getOwner(f));
252: f = src1dir.getFileObject("src1file");
253: assertEquals("src1file registered", project, FileOwnerQuery
254: .getOwner(f));
255: f = src2dir.getFileObject("src2file");
256: assertEquals("src2file registered", project, FileOwnerQuery
257: .getOwner(f));
258: f = src3dir.getFileObject("src3file");
259: assertEquals("src3file registered", project, FileOwnerQuery
260: .getOwner(f));
261: f = builddir.getFileObject("buildfile");
262: assertEquals("buildfile registered", project, FileOwnerQuery
263: .getOwner(f));
264: f = extdir.getFileObject("extFile");
265: assertEquals("extfile registered", project, FileOwnerQuery
266: .getOwner(f));
267: assertEquals("extdir not registered", null, FileOwnerQuery
268: .getOwner(extdir));
269: f = scratch.getFileObject("otherfile");
270: assertEquals("otherfile not registered", null, FileOwnerQuery
271: .getOwner(f));
272: // Test the simpler project type.
273: sh2
274: .registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
275: f = proj2dir.getFileObject("proj2file");
276: assertEquals("proj2file of course OK", project2, FileOwnerQuery
277: .getOwner(f));
278: f = proj2src1dir.getFileObject("proj2src1file");
279: assertEquals("proj2src1file registered", project2,
280: FileOwnerQuery.getOwner(f));
281: f = proj2src2dir.getFileObject("proj2src2file");
282: assertEquals("proj2src2file registered", project2,
283: FileOwnerQuery.getOwner(f));
284: f = ext2dir.getFileObject("ext2File");
285: assertEquals("ext2File registered", project2, FileOwnerQuery
286: .getOwner(f));
287: assertEquals("ext2dir not registered", null, FileOwnerQuery
288: .getOwner(ext2dir));
289: }
290:
291: public void testSourceLocationChanges() throws Exception {
292: Sources s = sh.createSources();
293: SourceGroup[] groups = s.getSourceGroups(Sources.TYPE_GENERIC);
294: assertEquals("should have maindir plus src2dir plus src3dir",
295: 3, groups.length);
296: assertEquals("group #1 is src2dir", src2dir, groups[0]
297: .getRootFolder());
298: assertEquals("group #2 is src3dir", src3dir, groups[1]
299: .getRootFolder());
300: assertEquals("group #3 is maindir", maindir, groups[2]
301: .getRootFolder());
302: groups = s.getSourceGroups("java");
303: assertEquals("should have src1dir plus src3dir", 2,
304: groups.length);
305: assertEquals("group #1 is src1dir", src1dir, groups[0]
306: .getRootFolder());
307: assertEquals("right display name for src1dir", "Packages #1",
308: groups[0].getDisplayName());
309: assertEquals("group #2 is src3dir", src3dir, groups[1]
310: .getRootFolder());
311: // Now change one of them.
312: EditableProperties p = h
313: .getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH);
314: p.setProperty("src1.dir", "../../src4");
315: h.putProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH, p);
316: ProjectManager.getDefault().saveProject(project);
317: groups = s.getSourceGroups(Sources.TYPE_GENERIC);
318: assertEquals(
319: "should have maindir plus src4dir plus src2dir plus src3dir",
320: 4, groups.length);
321: assertEquals("group #1 is src4dir", src4dir, groups[0]
322: .getRootFolder());
323: assertEquals("group #2 is src2dir", src2dir, groups[1]
324: .getRootFolder());
325: assertEquals("group #3 is src3dir", src3dir, groups[2]
326: .getRootFolder());
327: assertEquals("group #4 is maindir", maindir, groups[3]
328: .getRootFolder());
329: groups = s.getSourceGroups("java");
330: assertEquals("should have src4dir plus src3dir", 2,
331: groups.length);
332: assertEquals("group #1 is src4dir", src4dir, groups[0]
333: .getRootFolder());
334: assertEquals("right display name for src4dir", "Packages #1",
335: groups[0].getDisplayName());
336: assertEquals("group #2 is src3dir", src3dir, groups[1]
337: .getRootFolder());
338: }
339:
340: public void testSourceLocationChangesFired() throws Exception {
341: Sources s = sh.createSources();
342: // Listen to changes.
343: MockChangeListener l = new MockChangeListener();
344: s.addChangeListener(l);
345: // Check baseline GENERIC sources.
346: SourceGroup[] groups = s.getSourceGroups(Sources.TYPE_GENERIC);
347: assertEquals("should have maindir plus src2dir plus src3dir",
348: 3, groups.length);
349: assertEquals("group #1 is src2dir", src2dir, groups[0]
350: .getRootFolder());
351: assertEquals("group #2 is src3dir", src3dir, groups[1]
352: .getRootFolder());
353: assertEquals("group #3 is maindir", maindir, groups[2]
354: .getRootFolder());
355: l.assertNoEvents();
356: // Now change one of them to a different dir.
357: EditableProperties p = h
358: .getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH);
359: p.setProperty("src2.dir", "../../src4");
360: p.setProperty("src2a.dir", "nonsense");
361: h.putProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH, p);
362: ProjectManager.getDefault().saveProject(project);
363: l.msg("got change in GENERIC sources").assertEvent();
364: // Check new values.
365: groups = s.getSourceGroups(Sources.TYPE_GENERIC);
366: assertEquals("should have maindir plus src4dir plus src3dir",
367: 3, groups.length);
368: assertEquals("group #1 is src4dir", src4dir, groups[0]
369: .getRootFolder());
370: assertEquals("group #2 is src3dir", src3dir, groups[1]
371: .getRootFolder());
372: assertEquals("group #3 is maindir", maindir, groups[2]
373: .getRootFolder());
374: // Check 'java' type groups also.
375: groups = s.getSourceGroups("java");
376: assertEquals("should have src1dir plus src3dir", 2,
377: groups.length);
378: assertEquals("group #1 is src1dir", src1dir, groups[0]
379: .getRootFolder());
380: assertEquals("group #2 is src3dir", src3dir, groups[1]
381: .getRootFolder());
382: l.assertNoEvents();
383: p = h.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH);
384: p.setProperty("src1.dir", "does-not-exist");
385: h.putProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH, p);
386: ProjectManager.getDefault().saveProject(project);
387: l.msg("got change in java sources").assertEvent();
388: groups = s.getSourceGroups("java");
389: assertEquals("should have just src3dir", 1, groups.length);
390: assertEquals("group #2 is src3dir", src3dir, groups[0]
391: .getRootFolder());
392: l.assertNoEvents();
393: // #47451: should not fire changes for unrelated properties.
394: p = h.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH);
395: p.setProperty("irrelevant", "value");
396: h.putProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH, p);
397: ProjectManager.getDefault().saveProject(project);
398: l.msg("no changes fired from an unrelated property")
399: .assertNoEvents();
400: }
401:
402: public void testExternalRootLocationChanges() throws Exception {
403: FileObject readme = maindir.getFileObject("readme");
404: assertEquals("readme not yet registered", null, FileOwnerQuery
405: .getOwner(readme));
406: sh
407: .registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
408: assertEquals("readme still registered", project, FileOwnerQuery
409: .getOwner(readme));
410: FileObject src4file = src4dir.getFileObject("src4file");
411: assertEquals("src4file not yet owned by anyone", null,
412: FileOwnerQuery.getOwner(src4file));
413: FileObject src2file = src2dir.getFileObject("src2file");
414: assertEquals("src2file owned by the project", project,
415: FileOwnerQuery.getOwner(src2file));
416: // Change things around.
417: EditableProperties p = h
418: .getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH);
419: p.setProperty("src1.dir", "../../src4"); // start to recognize this root
420: p.setProperty("src2.dir", "src2"); // moved from ../../src2
421: p.remove("src2a.dir"); // was also ../../src2
422: h.putProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH, p);
423: ProjectManager.getDefault().saveProject(project);
424: assertEquals("src4file now owned by the project", project,
425: FileOwnerQuery.getOwner(src4file));
426: assertEquals("src2file no longer owned by the project", null,
427: FileOwnerQuery.getOwner(src2file));
428: assertEquals("readme still registered after unrelated changes",
429: project, FileOwnerQuery.getOwner(readme));
430: FileObject otherfile = scratch.getFileObject("otherfile");
431: assertEquals("otherfile still not registered", null,
432: FileOwnerQuery.getOwner(otherfile));
433: }
434:
435: public void testSourceRootDeletion() throws Exception {
436: // Cf. #40845. Need to fire a change if a root is deleted while project is open.
437: Sources s = sh.createSources();
438: SourceGroup[] groups = s.getSourceGroups("java");
439: assertEquals("should have src1dir plus src3dir", 2,
440: groups.length);
441: assertEquals("group #1 is src1dir", src1dir, groups[0]
442: .getRootFolder());
443: assertEquals("group #2 is src3dir", src3dir, groups[1]
444: .getRootFolder());
445: MockChangeListener l = new MockChangeListener();
446: s.addChangeListener(l);
447: src3dir.delete();
448: l.msg("got a change after src3dir deleted").assertEvent();
449: groups = s.getSourceGroups("java");
450: assertEquals("should have just src1dir", 1, groups.length);
451: assertEquals("group #1 is src1dir", src1dir, groups[0]
452: .getRootFolder());
453: src1dir.delete();
454: l.msg("got a change after src1dir deleted").assertEvent();
455: groups = s.getSourceGroups("java");
456: assertEquals("should have no dirs", 0, groups.length);
457: FileObject src5dir = scratch.createFolder("nonesuch");
458: l.msg("got a change after src5dir created").assertEvent();
459: groups = s.getSourceGroups("java");
460: assertEquals("should have src15dir now", 1, groups.length);
461: assertEquals("group #1 is src5dir", src5dir, groups[0]
462: .getRootFolder());
463: }
464:
465: public void testIncludesExcludes() throws Exception {
466: // <editor-fold desc="initial setup">
467: scratch = TestUtil.makeScratchDir(this ); // have our own setup
468: maindir = scratch.createFolder("dir");
469: projdir = maindir.createFolder("proj-dir");
470: src1dir = projdir.createFolder("src1");
471: src2dir = scratch.createFolder("src2");
472: src3dir = projdir.createFolder("src3");
473: src4dir = scratch.createFolder("src4");
474: // </editor-fold>
475: // <editor-fold desc="create files in group #1">
476: FileUtil.createData(src1dir, "com/sun/tools/javac/Main.java");
477: FileUtil
478: .createData(src1dir,
479: "com/sun/tools/internal/ws/processor/model/java/JavaArrayType.java");
480: FileUtil.createData(src1dir, "sun/tools/javac/Main.java");
481: FileUtil.createData(src1dir, "sunw/io/Serializable.java");
482: FileUtil.createData(src1dir, "java/lang/Byte.java");
483: FileUtil.createData(src1dir,
484: "java/text/resources/Messages.properties");
485: FileUtil.createData(src1dir,
486: "java/text/resources/Messages_zh.properties");
487: FileUtil.createData(src1dir,
488: "java/text/resources/Messages_zh_TW.properties");
489: FileUtil.createData(src1dir,
490: "java/text/resources/x_y/z.properties");
491: // </editor-fold>
492: // <editor-fold desc="create files in group #2">
493: FileUtil.createData(src2dir, "java/lang/Class.java");
494: FileUtil.createData(src2dir, "javax/swing/JComponent.java");
495: FileUtil.createData(src2dir, "javax/lang/Foo.java");
496: FileUtil.createData(src2dir,
497: "com/sun/java/swing/plaf/motif/MotifSplitPaneUI.java");
498: FileUtil
499: .createData(src2dir,
500: "com/sun/org/apache/xerces/internal/parsers/AbstractDOMParser.java");
501: FileUtil.createData(src2dir, "org/omg/CORBA/Any.java");
502: FileUtil.createData(src2dir,
503: "javax/swing/doc-files/groupLayout.1.gif");
504: FileUtil.createData(src2dir,
505: "javax/swing/plaf/resources/foo.gif");
506: FileUtil.createData(src2dir, "javax/swing/resources/bar.gif");
507: FileUtil.createData(src2dir, "docs/html/index.html");
508: // </editor-fold>
509: // <editor-fold desc="create files in group #3">
510: FileUtil.createData(src3dir, "java/lang/Class.java");
511: FileUtil.createData(src3dir, "java/util/Compat$Clazz.java");
512: FileUtil.createData(src3dir, "javax/swing/JComponent.java");
513: FileUtil.createData(src3dir,
514: "com/sun/java/swing/plaf/motif/MotifSplitPaneUI.java");
515: FileUtil.createData(src3dir, "README");
516: FileUtil.createData(src3dir, "README.html");
517: FileUtil.createData(src3dir, "whatever.xml");
518: // </editor-fold>
519: // <editor-fold desc="create files in group #4">
520: FileUtil.createData(src4dir, "java/lang/Class.java");
521: // </editor-fold>
522: // <editor-fold desc="other setup #1">
523: h = ProjectGenerator.createProject(projdir, "test");
524: project = ProjectManager.getDefault().findProject(projdir);
525: EditableProperties p = h
526: .getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH);
527: p.setProperty("src1.dir", "src1");
528: p.setProperty("src2.dir", "../../src2");
529: p.setProperty("src3.dir", "src3");
530: p.setProperty("src4.dir", "../../src4");
531: // </editor-fold>
532: // <editor-fold desc="includes & excludes">
533: p
534: .setProperty("src1.excludes",
535: " sun/,sunw\\, **\\internal/** ${undefined} , **/resources/*_*.properties ");
536: p
537: .setProperty("src2.includes",
538: "**/swing/,com/sun/org/apache/,org/omg,docs/html/index.html");
539: p.setProperty("src2.excludes",
540: "**/doc-files/ **/swing/**/resources/");
541: p
542: .setProperty("src3.includes",
543: "javax/swing/,com/sun/java/swing/,README,**/*$*.java,**/*.xml");
544: // </editor-fold>
545: // <editor-fold desc="other setup #2">
546: h.putProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH, p);
547: ProjectManager.getDefault().saveProject(project);
548: sh = new SourcesHelper(h, h.getStandardPropertyEvaluator());
549: sh.addPrincipalSourceRoot("${src1.dir}", "${src1.includes}",
550: "${src1.excludes}", "Sources #1", null, null);
551: sh.addPrincipalSourceRoot("${src2.dir}", "${src2.includes}",
552: "${src2.excludes}", "Sources #2", null, null);
553: sh.addPrincipalSourceRoot("${src3.dir}", "${src3.includes}",
554: null, "Sources #3", null, null);
555: sh.addPrincipalSourceRoot("${src4.dir}", "**", "",
556: "Sources #4", null, null);
557: sh.addTypedSourceRoot("${src1.dir}", "${src1.includes}",
558: "${src1.excludes}", "java", "Packages #1", null, null);
559: sh.addTypedSourceRoot("${src2.dir}", "${src2.includes}",
560: "${src2.excludes}", "java", "Packages #2", null, null);
561: sh.addTypedSourceRoot("${src3.dir}", "${src3.includes}", null,
562: "java", "Packages #3", null, null);
563: sh.addTypedSourceRoot("${src4.dir}", "**", "", "java",
564: "Packages #4", null, null);
565: Sources s = sh.createSources();
566: SourceGroup[] groups = s.getSourceGroups("java");
567: SourceGroup g1 = groups[0];
568: assertEquals("Packages #1", g1.getDisplayName());
569: SourceGroup g2 = groups[1];
570: assertEquals("Packages #2", g2.getDisplayName());
571: SourceGroup g3 = groups[2];
572: assertEquals("Packages #3", g3.getDisplayName());
573: SourceGroup g4 = groups[3];
574: assertEquals("Packages #4", g4.getDisplayName());
575: // </editor-fold>
576: // <editor-fold desc="testing group #1">
577: assertIncluded("not excluded despite sun/ infix", g1,
578: "com/sun/tools/javac/Main.java");
579: assertExcluded("internal infix", g1,
580: "com/sun/tools/internal/ws/processor/model/java/JavaArrayType.java");
581: assertExcluded("the whole folder is suppressed", g1,
582: "com/sun/tools/internal");
583: assertExcluded("sun/ prefix", g1, "sun/tools/javac/Main.java");
584: assertExcluded("the whole folder is suppressed", g1, "sun");
585: assertExcluded("sunw/ prefix even with \\", g1,
586: "sunw/io/Serializable.java");
587: assertExcluded("the whole folder is suppressed", g1, "sunw");
588: assertIncluded("why not?", g1, "java/lang/Byte.java");
589: assertIncluded("no _", g1,
590: "java/text/resources/Messages.properties");
591: assertExcluded("has _", g1,
592: "java/text/resources/Messages_zh.properties");
593: assertExcluded("has _ twice", g1,
594: "java/text/resources/Messages_zh_TW.properties");
595: assertIncluded("* does not match /", g1,
596: "java/text/resources/x_y/z.properties");
597: // </editor-fold>
598: // <editor-fold desc="testing group #2">
599: assertExcluded("not explicitly included", g2,
600: "java/lang/Class.java");
601: assertExcluded("nothing in java.lang.** is", g2, "java/lang");
602: assertExcluded("nothing in java.** is", g2, "java");
603: assertIncluded("explicitly included", g2,
604: "javax/swing/JComponent.java");
605: assertExcluded("but that does not apply to other children", g2,
606: "javax/lang/Foo.java");
607: assertIncluded("also explicitly included", g2,
608: "com/sun/java/swing/plaf/motif/MotifSplitPaneUI.java");
609: assertIncluded("not excluded as internal", g2,
610: "com/sun/org/apache/xerces/internal/parsers/AbstractDOMParser.java");
611: assertExcluded("dir includes do not work without /", g2,
612: "org/omg/CORBA/Any.java");
613: assertExcluded(
614: "dir includes do not work without / even for folder itself",
615: g2, "org/omg");
616: assertExcluded("nothing in org included, in fact", g2, "org");
617: assertExcluded("doc-files excluded", g2,
618: "javax/swing/doc-files/groupLayout.1.gif");
619: assertExcluded("whole doc-files excluded", g2,
620: "javax/swing/doc-files");
621: assertExcluded("resources excluded with intermediate plaf", g2,
622: "javax/swing/plaf/resources/foo.gif");
623: assertExcluded(
624: "whole resources excluded with intermediate plaf", g2,
625: "javax/swing/plaf/resources");
626: assertExcluded("/**/ can match /", g2,
627: "javax/swing/resources/bar.gif");
628: assertExcluded("/**/ can match / on whole dir", g2,
629: "javax/swing/resources");
630: // </editor-fold>
631: // <editor-fold desc="testing group #3">
632: assertExcluded("no reason to include", g3,
633: "java/lang/Class.java");
634: assertExcluded("java.lang not there", g3, "java/lang");
635: assertIncluded("has a $", g3, "java/util/Compat$Clazz.java");
636: assertIncluded("explicitly included", g3,
637: "javax/swing/JComponent.java");
638: assertIncluded("explicitly included", g3,
639: "com/sun/java/swing/plaf/motif/MotifSplitPaneUI.java");
640: assertIncluded("explicitly included", g3, "README");
641: assertExcluded("did not include file w/ ext", g3, "README.html");
642: assertIncluded("**/ can match null prefix", g3, "whatever.xml");
643: // </editor-fold>
644: // <editor-fold desc="testing group #4">
645: assertIncluded("everything included", g4,
646: "java/lang/Class.java");
647: // </editor-fold>
648: // <editor-fold desc="testing external roots">
649: sh
650: .registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
651: FileObject projdir2 = maindir.createFolder("proj-dir2");
652: ProjectGenerator.createProject(projdir2, "test");
653: Project prj2 = ProjectManager.getDefault()
654: .findProject(projdir2);
655: FileObject docfiles = src2dir
656: .getFileObject("javax/swing/doc-files");
657: assertNotNull(docfiles);
658: FileOwnerQuery.markExternalOwner(docfiles, prj2,
659: FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
660: assertOwner(null, g2, "java/lang/Class.java");
661: assertOwner(project, g2, "javax/swing/JComponent.java");
662: assertOwner(project, g2, "javax/swing");
663: assertOwner(null, g2, "javax");
664: assertOwner(project, g2,
665: "com/sun/java/swing/plaf/motif/MotifSplitPaneUI.java");
666: assertOwner(project, g2, "com/sun/java/swing/plaf/motif");
667: assertOwner(project, g2, "com/sun/java/swing/plaf");
668: assertOwner(project, g2, "com/sun/java/swing");
669: assertOwner(null, g2, "com/sun/java");
670: assertOwner(null, g2, "com/sun");
671: assertOwner(null, g2, "com");
672: assertOwner(null, g2, "org/omg/CORBA/Any.java");
673: assertOwner(prj2, g2, "javax/swing/doc-files/groupLayout.1.gif");
674: assertOwner(prj2, g2, "javax/swing/doc-files");
675: assertOwner(project, g2, "com/sun/java/swing");
676: assertOwner(project, g2, "docs/html/index.html");
677: assertOwner(project, g2, "docs/html");
678: assertOwner(null, g2, "docs");
679: p = h.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH);
680: p.setProperty("src2.includes",
681: "com/sun/org/apache/,org/omg,docs/html/index.html");
682: h.putProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH, p);
683: assertOwner(null, g2, "javax/swing/JComponent.java");
684: p = h.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH);
685: p
686: .setProperty("src2.includes",
687: "**/swing/,com/sun/org/apache/,org/omg,docs/html/index.html");
688: h.putProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH, p);
689: assertOwner(project, g2, "javax/swing/JComponent.java");
690: assertOwner(project, g4, "java/lang/Class.java");
691: assertOwner(project, g4, "java/lang");
692: assertOwner(project, g4, "java");
693: assertOwner(project, g4, "");
694: // </editor-fold>
695: // <editor-fold desc="testing change firing">
696: MockPropertyChangeListener l = new MockPropertyChangeListener();
697: g2.addPropertyChangeListener(l);
698: p = h.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH);
699: p.setProperty("src2.excludes", "**/doc-files/");
700: h.putProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH, p);
701: l.assertEvents(SourceGroup.PROP_CONTAINERSHIP);
702: assertExcluded("doc-files still excluded", g2,
703: "javax/swing/doc-files/groupLayout.1.gif");
704: assertIncluded("resources now included", g2,
705: "javax/swing/plaf/resources/foo.gif");
706: p = h.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH);
707: p.setProperty("src2.includes", "**");
708: h.putProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH, p);
709: l.assertEvents(SourceGroup.PROP_CONTAINERSHIP);
710: assertIncluded("may as well be included", g2,
711: "java/lang/Class.java");
712: p = h.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH);
713: p.setProperty("src2.includes", "**/swing/");
714: h.putProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH, p);
715: l.assertEvents(SourceGroup.PROP_CONTAINERSHIP);
716: assertExcluded("excluded again", g2, "java/lang/Class.java");
717: p = h.getProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH);
718: p.setProperty("irrelevant", "value");
719: h.putProperties(AntProjectHelper.PROJECT_PROPERTIES_PATH, p);
720: l.assertEvents();
721: // </editor-fold>
722: // <editor-fold desc="testing misc">
723: try {
724: FileObject f = src2dir
725: .getFileObject("java/lang/Class.java");
726: assertNotNull(f);
727: g1.contains(f);
728: fail("wrong root");
729: } catch (IllegalArgumentException e) {/* good */
730: }
731: SourceGroup[] ggroups = s.getSourceGroups(Sources.TYPE_GENERIC);
732: SourceGroup gg1 = ggroups[0];
733: assertEquals("Sources #2", gg1.getDisplayName());
734: assertIncluded("explicitly included", gg1,
735: "javax/swing/JComponent.java");
736: assertExcluded("but that does not apply to other children",
737: gg1, "javax/lang/Foo.java");
738: // </editor-fold>
739: }
740:
741: private static void assertIncluded(String message, SourceGroup g,
742: String resource) {
743: FileObject f = g.getRootFolder().getFileObject(resource);
744: assertNotNull(resource, f);
745: assertTrue(message, g.contains(f));
746: int slash = resource.lastIndexOf('/');
747: if (slash != -1) {
748: String parent = resource.substring(0, slash);
749: assertIncluded("parent " + parent + " of " + resource
750: + " must also be contained by definition", g,
751: parent);
752: } else if (resource.length() > 0) {
753: assertIncluded(
754: "root folder always contained by definition", g, "");
755: }
756: }
757:
758: private static void assertExcluded(String message, SourceGroup g,
759: String resource) {
760: FileObject f = g.getRootFolder().getFileObject(resource);
761: assertNotNull(resource, f);
762: assertFalse(message, g.contains(f));
763: }
764:
765: private static void assertOwner(Project owner, SourceGroup g,
766: String resource) {
767: FileObject f = g.getRootFolder().getFileObject(resource);
768: assertNotNull(resource, f);
769: assertEquals(owner, FileOwnerQuery.getOwner(f));
770: }
771:
772: }
|