DotFileTest.java revision 3294:9adfb22ff08f 
1/*
2 * Copyright (c) 2014, 2015, 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 8003562
27 * @summary Basic tests for jdeps -dotoutput option
28 * @modules java.management
29 *          jdk.jdeps/com.sun.tools.jdeps
30 * @build Test p.Foo p.Bar
31 * @run main DotFileTest
32 */
33
34import java.io.File;
35import java.io.IOException;
36import java.io.PrintWriter;
37import java.io.StringWriter;
38import java.nio.file.DirectoryStream;
39import java.nio.file.Files;
40import java.nio.file.Path;
41import java.nio.file.Paths;
42import java.util.*;
43import java.util.regex.*;
44
45public class DotFileTest {
46    public static void main(String... args) throws Exception {
47        int errors = 0;
48        errors += new DotFileTest().run();
49        if (errors > 0)
50            throw new Exception(errors + " errors found");
51    }
52
53    final Path dir;
54    final Path dotoutput;
55    DotFileTest() {
56        this.dir = Paths.get(System.getProperty("test.classes", "."));
57        this.dotoutput = dir.resolve("dots");
58    }
59
60    int run() throws IOException {
61        File testDir = dir.toFile();
62        // test a .class file
63        test(new File(testDir, "Test.class"),
64             new String[] {"java.lang", "p"},
65             new String[] {"compact1", "not found"});
66        // test a directory
67        test(new File(testDir, "p"),
68             new String[] {"java.lang", "java.util", "java.lang.management", "javax.crypto"},
69             new String[] {"compact1", "compact1", "compact3", "compact1"},
70             new String[] {"-classpath", testDir.getPath()});
71        // test class-level dependency output
72        test(new File(testDir, "Test.class"),
73             new String[] {"java.lang.Object", "java.lang.String", "p.Foo", "p.Bar"},
74             new String[] {"compact1", "compact1", "not found", "not found"},
75             new String[] {"-verbose:class"});
76        // test -filter:none option
77        test(new File(testDir, "p"),
78             new String[] {"java.lang", "java.util", "java.lang.management", "javax.crypto", "p"},
79             new String[] {"compact1", "compact1", "compact3", "compact1", "p"},
80             new String[] {"-classpath", testDir.getPath(), "-verbose:package", "-filter:none"});
81        // test -filter:archive option
82        test(new File(testDir, "p"),
83             new String[] {"java.lang", "java.util", "java.lang.management", "javax.crypto"},
84             new String[] {"compact1", "compact1", "compact3", "compact1"},
85             new String[] {"-classpath", testDir.getPath(), "-verbose:package", "-filter:archive"});
86        // test -p option
87        test(new File(testDir, "Test.class"),
88             new String[] {"p.Foo", "p.Bar"},
89             new String[] {"not found", "not found"},
90             new String[] {"-verbose:class", "-p", "p"});
91        // test -e option
92        test(new File(testDir, "Test.class"),
93             new String[] {"p.Foo", "p.Bar"},
94             new String[] {"not found", "not found"},
95             new String[] {"-verbose:class", "-e", "p\\..*"});
96        test(new File(testDir, "Test.class"),
97             new String[] {"java.lang"},
98             new String[] {"compact1"},
99             new String[] {"-verbose:package", "-e", "java\\.lang\\..*"});
100        // test -classpath options
101        test(new File(testDir, "Test.class"),
102             new String[] {"java.lang.Object", "java.lang.String", "p.Foo", "p.Bar"},
103             new String[] {"compact1", "compact1", testDir.getName(), testDir.getName()},
104             new String[] {"-v", "-classpath", testDir.getPath()});
105
106        testSummary(new File(testDir, "Test.class"),
107             new String[] {"java.base", testDir.getName()},
108             new String[] {"compact1", ""},
109             new String[] {"-classpath", testDir.getPath()});
110        testSummary(new File(testDir, "Test.class"),
111             new String[] {"java.lang", "p"},
112             new String[] {"compact1", testDir.getName()},
113             new String[] {"-v", "-classpath", testDir.getPath()});
114        return errors;
115    }
116
117    void test(File file, String[] expect, String[] profiles) throws IOException {
118        test(file, expect, profiles, new String[0]);
119    }
120
121    void test(File file, String[] expect, String[] profiles, String[] options)
122        throws IOException
123    {
124        Path dotfile = dotoutput.resolve(file.toPath().getFileName().toString() + ".dot");
125
126        List<String> args = new ArrayList<>(Arrays.asList(options));
127        args.add("-dotoutput");
128        args.add(dotoutput.toString());
129        if (file != null) {
130            args.add(file.getPath());
131        }
132
133        Map<String,String> result = jdeps(args, dotfile);
134        checkResult("dependencies", expect, result.keySet());
135
136        // with -P option
137        List<String> argsWithDashP = new ArrayList<>();
138        argsWithDashP.add("-dotoutput");
139        argsWithDashP.add(dotoutput.toString());
140        argsWithDashP.add("-P");
141        argsWithDashP.addAll(args);
142
143        result = jdeps(argsWithDashP, dotfile);
144        checkResult("profiles", expect, profiles, result);
145    }
146
147    void testSummary(File file, String[] expect, String[] profiles, String[] options)
148        throws IOException
149    {
150        Path dotfile = dotoutput.resolve("summary.dot");
151
152        List<String> args = new ArrayList<>(Arrays.asList(options));
153        args.add("-dotoutput");
154        args.add(dotoutput.toString());
155        if (file != null) {
156            args.add(file.getPath());
157        }
158
159        Map<String,String> result = jdeps(args, dotfile);
160        checkResult("dependencies", expect, result.keySet());
161
162        // with -P option
163        List<String> argsWithDashP = new ArrayList<>();
164        argsWithDashP.add("-dotoutput");
165        argsWithDashP.add(dotoutput.toString());
166        argsWithDashP.add("-P");
167        argsWithDashP.addAll(args);
168
169        result = jdeps(argsWithDashP, dotfile);
170        checkResult("profiles", expect, profiles, result);
171    }
172
173    Map<String,String> jdeps(List<String> args, Path dotfile) throws IOException {
174        if (Files.exists(dotoutput)) {
175            try (DirectoryStream<Path> stream = Files.newDirectoryStream(dotoutput)) {
176                for (Path p : stream) {
177                    Files.delete(p);
178                }
179            }
180            Files.delete(dotoutput);
181        }
182        // invoke jdeps
183        StringWriter sw = new StringWriter();
184        PrintWriter pw = new PrintWriter(sw);
185        System.err.println("jdeps " + args);
186        int rc = com.sun.tools.jdeps.Main.run(args.toArray(new String[0]), pw);
187        pw.close();
188        String out = sw.toString();
189        if (!out.isEmpty())
190            System.err.println(out);
191        if (rc != 0)
192            throw new Error("jdeps failed: rc=" + rc);
193
194        // check output files
195        if (Files.notExists(dotfile)) {
196            throw new RuntimeException(dotfile + " doesn't exist");
197        }
198        return parse(dotfile);
199    }
200    private static Pattern pattern = Pattern.compile("(.*) -> +([^ ]*) (.*)");
201    private Map<String,String> parse(Path outfile) throws IOException {
202        Map<String,String> result = new LinkedHashMap<>();
203        for (String line : Files.readAllLines(outfile)) {
204            line = line.replace('"', ' ').replace(';', ' ');
205            Matcher pm = pattern.matcher(line);
206            if (pm.find()) {
207                String origin = pm.group(1).trim();
208                String target = pm.group(2).trim();
209                String module = pm.group(3).replace('(', ' ').replace(')', ' ').trim();
210                result.put(target, module);
211            }
212        }
213        return result;
214    }
215
216    void checkResult(String label, String[] expect, Collection<String> found) {
217        List<String> list = Arrays.asList(expect);
218        if (!isEqual(list, found))
219            error("Unexpected " + label + " found: '" + found + "', expected: '" + list + "'");
220    }
221
222    void checkResult(String label, String[] expect, String[] profiles, Map<String,String> result) {
223        if (expect.length != profiles.length)
224            error("Invalid expected names and profiles");
225
226        // check the dependencies
227        checkResult(label, expect, result.keySet());
228        // check profile information
229        checkResult(label, profiles, result.values());
230        for (int i=0; i < expect.length; i++) {
231            String profile = result.get(expect[i]);
232            if (!profile.equals(profiles[i]))
233                error("Unexpected profile: '" + profile + "', expected: '" + profiles[i] + "'");
234        }
235    }
236
237    boolean isEqual(List<String> expected, Collection<String> found) {
238        if (expected.size() != found.size())
239            return false;
240
241        List<String> list = new ArrayList<>(found);
242        list.removeAll(expected);
243        return list.isEmpty();
244    }
245
246    void error(String msg) {
247        System.err.println("Error: " + msg);
248        errors++;
249    }
250
251    int errors;
252}
253