langtools/test/tools/javac/modules/MOptionTest.java
changeset 36778 e04318f39f92
parent 36526 3b41f1c69604
child 37758 3ecf9b414e05
equal deleted inserted replaced
36777:28d33fb9097f 36778:e04318f39f92
    27  * @summary implement javac -m option
    27  * @summary implement javac -m option
    28  * @library /tools/lib
    28  * @library /tools/lib
    29  * @modules
    29  * @modules
    30  *      jdk.compiler/com.sun.tools.javac.api
    30  *      jdk.compiler/com.sun.tools.javac.api
    31  *      jdk.compiler/com.sun.tools.javac.main
    31  *      jdk.compiler/com.sun.tools.javac.main
    32  *      jdk.jdeps/com.sun.tools.javap
    32  * @build toolbox.ToolBox toolbox.JavacTask ModuleTestBase
    33  * @build ToolBox ModuleTestBase
       
    34  * @run main MOptionTest
    33  * @run main MOptionTest
    35  */
    34  */
    36 
    35 
    37 import java.nio.file.Files;
    36 import java.nio.file.Files;
    38 import java.nio.file.Path;
    37 import java.nio.file.Path;
    39 import java.nio.file.attribute.FileTime;
    38 import java.nio.file.attribute.FileTime;
    40 
    39 
    41 import com.sun.source.util.JavacTask;
    40 import toolbox.JavacTask;
       
    41 import toolbox.Task;
       
    42 import toolbox.ToolBox;
    42 
    43 
    43 public class MOptionTest extends ModuleTestBase {
    44 public class MOptionTest extends ModuleTestBase {
    44     public static void main(String... args) throws Exception {
    45     public static void main(String... args) throws Exception {
    45         new MOptionTest().runTests();
    46         new MOptionTest().runTests();
    46     }
    47     }
    54 
    55 
    55         tb.writeJavaFiles(m1,
    56         tb.writeJavaFiles(m1,
    56                 "module m1 {}",
    57                 "module m1 {}",
    57                 "package test; public class Test {}");
    58                 "package test; public class Test {}");
    58 
    59 
    59         tb.new JavacTask()
    60         new JavacTask(tb)
    60                 .options("-m", "m1", "-modulesourcepath", src.toString(), "-d", build.toString())
    61                 .options("-m", "m1", "-modulesourcepath", src.toString(), "-d", build.toString())
    61                 .run(ToolBox.Expect.SUCCESS)
    62                 .run(Task.Expect.SUCCESS)
    62                 .writeAll();
    63                 .writeAll();
    63 
    64 
    64         Path moduleInfoClass = build.resolve("m1/module-info.class");
    65         Path moduleInfoClass = build.resolve("m1/module-info.class");
    65         Path testTestClass = build.resolve("m1/test/Test.class");
    66         Path testTestClass = build.resolve("m1/test/Test.class");
    66 
    67 
    77             throw new AssertionError("Classfiles too old!");
    78             throw new AssertionError("Classfiles too old!");
    78         }
    79         }
    79 
    80 
    80         Thread.sleep(2000); //timestamps
    81         Thread.sleep(2000); //timestamps
    81 
    82 
    82         tb.new JavacTask()
    83         new JavacTask(tb)
    83                 .options("-m", "m1", "-modulesourcepath", src.toString(), "-d", build.toString())
    84                 .options("-m", "m1", "-modulesourcepath", src.toString(), "-d", build.toString())
    84                 .run(ToolBox.Expect.SUCCESS)
    85                 .run(Task.Expect.SUCCESS)
    85                 .writeAll();
    86                 .writeAll();
    86 
    87 
    87         if (!moduleInfoTimeStamp.equals(Files.getLastModifiedTime(moduleInfoClass))) {
    88         if (!moduleInfoTimeStamp.equals(Files.getLastModifiedTime(moduleInfoClass))) {
    88             throw new AssertionError("Classfile update!");
    89             throw new AssertionError("Classfile update!");
    89         }
    90         }
    94 
    95 
    95         Thread.sleep(2000); //timestamps
    96         Thread.sleep(2000); //timestamps
    96 
    97 
    97         Files.setLastModifiedTime(testTest, FileTime.fromMillis(System.currentTimeMillis()));
    98         Files.setLastModifiedTime(testTest, FileTime.fromMillis(System.currentTimeMillis()));
    98 
    99 
    99         tb.new JavacTask()
   100         new JavacTask(tb)
   100                 .options("-m", "m1", "-modulesourcepath", src.toString(), "-d", build.toString())
   101                 .options("-m", "m1", "-modulesourcepath", src.toString(), "-d", build.toString())
   101                 .run(ToolBox.Expect.SUCCESS)
   102                 .run(Task.Expect.SUCCESS)
   102                 .writeAll();
   103                 .writeAll();
   103 
   104 
   104         if (!moduleInfoTimeStamp.equals(Files.getLastModifiedTime(moduleInfoClass))) {
   105         if (!moduleInfoTimeStamp.equals(Files.getLastModifiedTime(moduleInfoClass))) {
   105             throw new AssertionError("Classfile update!");
   106             throw new AssertionError("Classfile update!");
   106         }
   107         }
   119 
   120 
   120         tb.writeJavaFiles(m1,
   121         tb.writeJavaFiles(m1,
   121                 "module m1 {}",
   122                 "module m1 {}",
   122                 "package test; public class Test {}");
   123                 "package test; public class Test {}");
   123 
   124 
   124         String log = tb.new JavacTask()
   125         String log = new JavacTask(tb)
   125                 .options("-XDrawDiagnostics",
   126                 .options("-XDrawDiagnostics",
   126                     "-m", "m1",
   127                     "-m", "m1",
   127                     "-modulesourcepath", src.toString())
   128                     "-modulesourcepath", src.toString())
   128                 .run(ToolBox.Expect.FAIL)
   129                 .run(Task.Expect.FAIL)
   129                 .writeAll()
   130                 .writeAll()
   130                 .getOutput(ToolBox.OutputKind.DIRECT);
   131                 .getOutput(Task.OutputKind.DIRECT);
   131 
   132 
   132         if (!log.contains("- compiler.err.output.dir.must.be.specified.with.dash.m.option"))
   133         if (!log.contains("- compiler.err.output.dir.must.be.specified.with.dash.m.option"))
   133             throw new Exception("expected output not found");
   134             throw new Exception("expected output not found");
   134     }
   135     }
   135 
   136 
   142 
   143 
   143         tb.writeJavaFiles(m1,
   144         tb.writeJavaFiles(m1,
   144                 "module m1 {}",
   145                 "module m1 {}",
   145                 "package test; public class Test {}");
   146                 "package test; public class Test {}");
   146 
   147 
   147         String log = tb.new JavacTask()
   148         String log = new JavacTask(tb)
   148                 .options("-XDrawDiagnostics",
   149                 .options("-XDrawDiagnostics",
   149                         "-m", "m1",
   150                         "-m", "m1",
   150                         "-d", build.toString())
   151                         "-d", build.toString())
   151                 .run(ToolBox.Expect.FAIL)
   152                 .run(Task.Expect.FAIL)
   152                 .writeAll()
   153                 .writeAll()
   153                 .getOutput(ToolBox.OutputKind.DIRECT);
   154                 .getOutput(Task.OutputKind.DIRECT);
   154 
   155 
   155         if (!log.contains("- compiler.err.modulesourcepath.must.be.specified.with.dash.m.option"))
   156         if (!log.contains("- compiler.err.modulesourcepath.must.be.specified.with.dash.m.option"))
   156             throw new Exception("expected output not found");
   157             throw new Exception("expected output not found");
   157     }
   158     }
   158 
   159 
   170 
   171 
   171         tb.writeJavaFiles(m2,
   172         tb.writeJavaFiles(m2,
   172                 "module m2 {}",
   173                 "module m2 {}",
   173                 "package p2; public class C2 {}");
   174                 "package p2; public class C2 {}");
   174 
   175 
   175         tb.new JavacTask()
   176         new JavacTask(tb)
   176                 .options("-m", "m1,m2", "-modulesourcepath", src.toString(), "-d", build.toString())
   177                 .options("-m", "m1,m2", "-modulesourcepath", src.toString(), "-d", build.toString())
   177                 .run(ToolBox.Expect.SUCCESS)
   178                 .run(Task.Expect.SUCCESS)
   178                 .writeAll();
   179                 .writeAll();
   179 
   180 
   180         Path m1ModuleInfoClass = build.resolve("m1/module-info.class");
   181         Path m1ModuleInfoClass = build.resolve("m1/module-info.class");
   181         Path classC1 = build.resolve("m1/p1/C1.class");
   182         Path classC1 = build.resolve("m1/p1/C1.class");
   182 
   183 
   211             throw new AssertionError("Classfiles too old!");
   212             throw new AssertionError("Classfiles too old!");
   212         }
   213         }
   213 
   214 
   214         Thread.sleep(2000); //timestamps
   215         Thread.sleep(2000); //timestamps
   215 
   216 
   216         tb.new JavacTask()
   217         new JavacTask(tb)
   217                 .options("-m", "m1,m2", "-modulesourcepath", src.toString(), "-d", build.toString())
   218                 .options("-m", "m1,m2", "-modulesourcepath", src.toString(), "-d", build.toString())
   218                 .run(ToolBox.Expect.SUCCESS)
   219                 .run(Task.Expect.SUCCESS)
   219                 .writeAll();
   220                 .writeAll();
   220 
   221 
   221         if (!m1ModuleInfoTimeStamp.equals(Files.getLastModifiedTime(m1ModuleInfoClass))) {
   222         if (!m1ModuleInfoTimeStamp.equals(Files.getLastModifiedTime(m1ModuleInfoClass))) {
   222             throw new AssertionError("Classfile update!");
   223             throw new AssertionError("Classfile update!");
   223         }
   224         }
   237         Thread.sleep(2000); //timestamps
   238         Thread.sleep(2000); //timestamps
   238 
   239 
   239         Files.setLastModifiedTime(C1Source, FileTime.fromMillis(System.currentTimeMillis()));
   240         Files.setLastModifiedTime(C1Source, FileTime.fromMillis(System.currentTimeMillis()));
   240         Files.setLastModifiedTime(C2Source, FileTime.fromMillis(System.currentTimeMillis()));
   241         Files.setLastModifiedTime(C2Source, FileTime.fromMillis(System.currentTimeMillis()));
   241 
   242 
   242         tb.new JavacTask()
   243         new JavacTask(tb)
   243                 .options("-m", "m1,m2", "-modulesourcepath", src.toString(), "-d", build.toString())
   244                 .options("-m", "m1,m2", "-modulesourcepath", src.toString(), "-d", build.toString())
   244                 .run(ToolBox.Expect.SUCCESS)
   245                 .run(Task.Expect.SUCCESS)
   245                 .writeAll();
   246                 .writeAll();
   246 
   247 
   247         if (!m1ModuleInfoTimeStamp.equals(Files.getLastModifiedTime(m1ModuleInfoClass))) {
   248         if (!m1ModuleInfoTimeStamp.equals(Files.getLastModifiedTime(m1ModuleInfoClass))) {
   248             throw new AssertionError("Classfile update!");
   249             throw new AssertionError("Classfile update!");
   249         }
   250         }