FilterOptions.java revision 3595:81692f730015 
1/*
2 * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24/**
25 * @test
26 * @bug 8159305
27 * @summary Tests elements filtering options
28 * @modules
29 *      jdk.javadoc/jdk.javadoc.internal.api
30 *      jdk.javadoc/jdk.javadoc.internal.doclets.standard
31 *      jdk.javadoc/jdk.javadoc.internal.tool
32 *      jdk.compiler/com.sun.tools.javac.api
33 *      jdk.compiler/com.sun.tools.javac.main
34 * @library /tools/lib
35 * @build toolbox.ToolBox toolbox.TestRunner
36 * @run main FilterOptions
37 */
38
39import java.io.IOException;
40import java.nio.file.Path;
41import java.nio.file.Paths;
42
43import toolbox.*;
44
45public class FilterOptions extends ModuleTestBase {
46
47    private static final String NL = System.getProperty("line.separator");
48    private static final String INDENT = "    ";
49
50    // the sources are shared, so create it once
51    private final String src;
52
53    public static void main(String... args) throws Exception {
54        new FilterOptions().runTests();
55    }
56
57    FilterOptions() throws IOException {
58        this.src = createSources(Paths.get(".").resolve("src"));
59    }
60
61    @Test
62    public void testDefault(Path base) throws Exception {
63        execTask("-modulesourcepath", src, "--module", "m1");
64
65        checkModulesSpecified("m1");
66        checkModulesIncluded("m1");
67        checkPackagesIncluded("pub");
68        checkTypesIncluded("pub.A", "pub.A.ProtectedNested", "pub.A.PublicNested");
69    }
70
71    @Test
72    public void testModuleModeApi(Path base) throws Exception {
73        execTask("-modulesourcepath", src,
74                "--module", "m1", "--show-module-contents:api");
75
76        checkModuleMode("API");
77    }
78
79    @Test
80    public void testModuleModeAll(Path base) throws Exception {
81        execTask("-modulesourcepath", src,
82                "--module", "m1", "--show-module-contents:all");
83
84        checkModuleMode("ALL");
85    }
86
87    @Test
88    public void testShowPackagesExported(Path base)  throws Exception {
89        execTask("-modulesourcepath", src,
90                "--module", "m1",
91                "--show-packages:exported"); // default
92
93        checkModulesSpecified("m1");
94        checkModulesIncluded("m1");
95        checkPackagesIncluded("pub");
96        checkTypesIncluded("pub.A", "pub.A.ProtectedNested", "pub.A.PublicNested");
97    }
98
99    @Test
100    public void testShowPackagesAll(Path base) throws Exception {
101        execTask("-modulesourcepath", src,
102                "--module", "m1",
103                "--show-packages:all");
104        checkModulesSpecified("m1");
105        checkModulesIncluded("m1");
106        checkPackagesIncluded("pub", "pro");
107
108        checkTypesIncluded("pub.A", "pub.A.ProtectedNested", "pub.A.PublicNested",
109                           "pro.A", "pro.A.ProtectedNested", "pro.A.PublicNested");
110    }
111
112    @Test
113    public void testShowTypesPrivate(Path base) throws Exception {
114        execTask("-modulesourcepath", src,
115                "--module", "m1",
116                "--show-types:private");
117
118        checkModulesSpecified("m1");
119        checkModulesIncluded("m1");
120        checkPackagesIncluded("pub");
121
122        checkTypesIncluded("pub.A", "pub.A.PrivateNested", "pub.A.Nested", "pub.A.ProtectedNested",
123                           "pub.A.PublicNested",
124                           "pub.B", "pub.B.PrivateNested", "pub.B.Nested", "pub.B.ProtectedNested",
125                           "pub.B.PublicNested");
126
127    }
128
129    @Test
130    public void testShowTypesPackage(Path base) throws Exception {
131        execTask("-modulesourcepath", src,
132                "--module", "m1",
133                "--show-types:package");
134
135        checkModulesSpecified("m1");
136        checkModulesIncluded("m1");
137        checkPackagesIncluded("pub");
138
139        checkTypesIncluded("pub.A", "pub.A.Nested", "pub.A.ProtectedNested", "pub.A.PublicNested",
140                           "pub.B", "pub.B.Nested", "pub.B.ProtectedNested", "pub.B.PublicNested");
141
142        checkTypesNotIncluded(".*private.*");
143    }
144
145    @Test
146    public void testShowTypesProtected(Path base) throws Exception {
147        execTask("-modulesourcepath", src,
148                "--module", "m1",
149                "--show-types:protected");
150
151        checkModulesSpecified("m1");
152        checkModulesIncluded("m1");
153        checkPackagesIncluded("pub");
154
155        checkTypesIncluded("pub.A", "pub.A.ProtectedNested", "pub.A.PublicNested");
156
157        checkTypesNotIncluded("pub.A.Nested", "pub.A.PrivateNested", "pub.B.Nested",
158                              "pub.B.PrivateNested", "pub.B.ProtectedNested",
159                              "pub.B.PublicNested");
160    }
161
162    @Test
163    public void testShowTypesPublic(Path base) throws Exception {
164        execTask("-modulesourcepath", src,
165                "--module", "m1",
166                "--show-types:public");
167
168        checkModulesSpecified("m1");
169        checkModulesIncluded("m1");
170        checkPackagesIncluded("pub");
171
172        checkTypesIncluded("pub.A", "pub.A.PublicNested");
173        checkTypesNotIncluded("pub.A.Nested",
174                              "pub.A.ProtectedNested", "pub.A.PrivateNested",
175                              "pub.B.Nested", "pub.B.ProtectedNested", "pub.B.PrivateNested",
176                              "pub.B.PublicNested");
177    }
178
179    @Test
180    public void testShowMembersPrivate(Path base) throws Exception {
181        execTask("-modulesourcepath", src,
182                "--module", "m1",
183                "--show-members:private");
184
185        checkMembers(Visibility.PRIVATE);
186    }
187
188    @Test
189    public void testShowMembersPackage(Path base) throws Exception {
190        execTask("-modulesourcepath", src,
191                "--module", "m1",
192                "--show-members:package");
193
194        checkMembers(Visibility.PACKAGE);
195    }
196
197    @Test
198    public void testShowMembersProtected(Path base) throws Exception {
199        execTask("-modulesourcepath", src,
200                "--module", "m1",
201                "--show-members:protected");
202
203        checkMembers(Visibility.PROTECTED);
204    }
205
206    @Test
207    public void testShowMembersPublic(Path base) throws Exception {
208        execTask("-modulesourcepath", src,
209                "--module", "m1",
210                "--show-members:public");
211
212        checkMembers(Visibility.PUBLIC);
213    }
214
215    @Test
216    public void testLegacyPublic(Path base) throws Exception {
217        execTask("-modulesourcepath", src,
218                "--module", "m1",
219                "-public");
220
221        checkModuleMode("API");
222        checkModulesSpecified("m1");
223        checkModulesIncluded("m1");
224        checkPackagesIncluded("pub");
225        checkTypesIncluded("pub.A", "pub.A.PublicNested");
226
227        checkMembers(Visibility.PUBLIC);
228    }
229
230    @Test
231    public void testLegacyDefault(Path base) throws Exception {
232        execTask("-modulesourcepath", src,
233                "--module", "m1");
234
235        checkModuleMode("API");
236        checkModulesSpecified("m1");
237        checkModulesIncluded("m1");
238        checkPackagesIncluded("pub");
239        checkTypesIncluded("pub.A", "pub.A.ProtectedNested", "pub.A.PublicNested");
240
241        checkMembers(Visibility.PROTECTED);
242    }
243
244    @Test
245    public void testLegacyProtected(Path base) throws Exception {
246        execTask("-modulesourcepath", src,
247                "--module", "m1",
248                "-protected");
249
250        checkModuleMode("API");
251        checkModulesSpecified("m1");
252        checkModulesIncluded("m1");
253        checkPackagesIncluded("pub");
254        checkTypesIncluded("pub.A", "pub.A.ProtectedNested", "pub.A.PublicNested");
255
256        checkMembers(Visibility.PROTECTED);
257    }
258
259    @Test
260    public void testLegacyPackage(Path base) throws Exception {
261        execTask("-modulesourcepath", src,
262                "--module", "m1",
263                "-package");
264
265        checkModuleMode("ALL");
266        checkModulesSpecified("m1");
267        checkModulesIncluded("m1");
268        checkPackagesIncluded("pub");
269        checkPackagesIncluded("pro");
270        checkTypesIncluded("pub.B", "pub.B.Nested", "pub.B.ProtectedNested", "pub.B.PublicNested",
271                           "pub.A", "pub.A.Nested", "pub.A.ProtectedNested", "pub.A.PublicNested",
272                           "pro.B", "pro.B.Nested", "pro.B.ProtectedNested", "pro.B.PublicNested",
273                           "pro.A", "pro.A.Nested", "pro.A.ProtectedNested", "pro.A.PublicNested");
274
275        checkMembers(Visibility.PACKAGE);
276    }
277
278    @Test
279    public void testLegacyPrivate(Path base) throws Exception {
280        execTask("-modulesourcepath", src,
281                "--module", "m1",
282                "-private");
283
284        checkModuleMode("ALL");
285        checkModulesSpecified("m1");
286        checkModulesIncluded("m1");
287        checkPackagesIncluded("pub");
288        checkPackagesIncluded("pro");
289        checkTypesIncluded("pub.B", "pub.B.PrivateNested", "pub.B.Nested", "pub.B.ProtectedNested",
290                           "pub.B.PublicNested",
291                           "pub.A", "pub.A.PrivateNested", "pub.A.Nested", "pub.A.ProtectedNested",
292                           "pub.A.PublicNested",
293                           "pro.B", "pro.B.PrivateNested", "pro.B.Nested", "pro.B.ProtectedNested",
294                           "pro.B.PublicNested",
295                           "pro.A", "pro.A.PrivateNested", "pro.A.Nested", "pro.A.ProtectedNested",
296                           "pro.A.PublicNested");
297
298        checkMembers(Visibility.PRIVATE);
299    }
300
301    private static enum Visibility {
302        PRIVATE, PACKAGE, PROTECTED, PUBLIC;
303    }
304
305    void checkMembers(Visibility v) throws Exception {
306        checkMembersPresence(v);
307        checkMembersAbsence(v);
308    }
309
310    void checkMembersPresence(Visibility v) throws Exception {
311        switch (v) {
312            case PRIVATE:
313                checkMembersSelected("pub.A.privateFieldA",
314                                     "pub.A.PublicNested.privateFieldPublicNested",
315                                     "pub.A.ProtectedNested.privateFieldProtectedNested");
316
317            case PACKAGE:
318                checkMembersSelected("pub.A.FieldA",
319                                     "pub.A.PublicNested.FieldPublicNested",
320                                     "pub.A.ProtectedNested.FieldProtectedNested");
321
322            case PROTECTED:
323                checkMembersSelected("pub.A.<init>",
324                                     "pub.A.protectedFieldA",
325                                     "pub.A.PublicNested.protectedFieldPublicNested",
326                                     "pub.A.ProtectedNested.<init>",
327                                     "pub.A.ProtectedNested.protectedFieldProtectedNested",
328                                     "pub.A.ProtectedNested.publicFieldProtectedNested");
329
330            case PUBLIC:
331                checkMembersSelected("pub.A.publicFieldA",
332                                     "pub.A.PublicNested.<init>",
333                                     "pub.A.PublicNested.publicFieldPublicNested");
334
335                break;
336        }
337    }
338
339    void checkMembersAbsence(Visibility v) throws Exception {
340        switch (v) {
341            case PUBLIC:
342                checkMembersNotSelected("pub.A.protectedFieldA",
343                                        "pub.A.PublicNested.protectedFieldPublicNested",
344                                        "pub.A.ProtectedNested.<init>",
345                                        "pub.A.ProtectedNested.protectedFieldProtectedNested");
346
347            case PROTECTED:
348                checkMembersNotSelected("pub.A.FieldA",
349                                        "pub.A.PublicNested.FieldPublicNested",
350                                        "pub.A.ProtectedNested.FieldProtectedNested");
351
352            case PACKAGE:
353                checkMembersNotSelected("pub.A.privateFieldA",
354                                        "pub.A.PublicNested.privateFieldPublicNested",
355                                        "pub.A.ProtectedNested.privateFieldProtectedNested");
356
357            case PRIVATE:
358                break;
359        }
360    }
361
362    String createSources(Path src) throws IOException {
363        ModuleBuilder mb1 = new ModuleBuilder(tb, "m1");
364        mb1.comment("The first module.")
365                .classes(createClass("pub", "A", true))
366                .classes(createClass("pub", "B", false))
367                .classes(createClass("pro", "A", true))
368                .classes(createClass("pro", "B", false))
369                .exports("pub")
370                .write(src);
371        return src.toString();
372    }
373
374    String createClass(String pkg, String name, boolean isPublic) {
375        StringBuilder sb = new StringBuilder("package ")
376                .append(pkg)
377                .append("; ")
378                .append(NL);
379        sb.append(" /** Klass ")
380                .append(name)
381                .append(" */")
382                .append(NL);
383        sb.append(isPublic ? "public " : " ")
384                .append("class ")
385                .append(name)
386                .append(" {")
387                .append(NL);
388
389        sb.append(createMembers(INDENT, name));
390        sb.append(createNestedClass(INDENT, "PublicNested", name, "public"));
391        sb.append(createNestedClass(INDENT, "ProtectedNested", name, "protected"));
392        sb.append(createNestedClass(INDENT, "Nested", name, ""));
393        sb.append(createNestedClass(INDENT, "PrivateNested", name, "private"));
394
395        return sb.append("}").toString();
396    }
397
398    StringBuilder createNestedClass(String indent, String name, String enclosing, String visibility) {
399        return new StringBuilder()
400                .append(indent).append(" /** Klass ").append(name).append(" */").append(NL)
401                .append(indent).append(visibility).append(" class ").append(name).append(" {").append(NL)
402                .append(createMembers(indent + INDENT, name)).append(indent).append("}").append(NL);
403    }
404
405    StringBuilder createMembers(String indent, String enclosing) {
406        return new StringBuilder()
407                .append(indent).append(createMember(enclosing, "public"))
408                .append(indent).append(createMember(enclosing, "protected"))
409                .append(indent).append(createMember(enclosing, ""))
410                .append(indent).append(createMember(enclosing, "private"))
411                .append(NL);
412    }
413
414    StringBuilder createMember(String enclosingClass, String visibility) {
415        return new StringBuilder()
416                .append("/** a ")
417                .append(visibility)
418                .append("Field in ")
419                .append(enclosingClass)
420                .append(" */ ")
421                .append(visibility)
422                .append(" String ")
423                .append(visibility)
424                .append("Field")
425                .append(enclosingClass)
426                .append(";")
427                .append(NL);
428    }
429}
430