< prev index next >

test/hotspot/jtreg/gc/shenandoah/options/TestModeUnlock.java

Print this page
rev 59823 : 8247751: Shenandoah: options tests should run with smaller heaps
Reviewed-by: XXX


  35 import jdk.test.lib.process.ProcessTools;
  36 import jdk.test.lib.process.OutputAnalyzer;
  37 
  38 public class TestModeUnlock {
  39 
  40     enum Mode {
  41         PRODUCT,
  42         DIAGNOSTIC,
  43         EXPERIMENTAL,
  44     }
  45 
  46     public static void main(String[] args) throws Exception {
  47         testWith("-XX:ShenandoahGCMode=satb",    Mode.PRODUCT);
  48         testWith("-XX:ShenandoahGCMode=iu",      Mode.EXPERIMENTAL);
  49         testWith("-XX:ShenandoahGCMode=passive", Mode.DIAGNOSTIC);
  50     }
  51 
  52     private static void testWith(String h, Mode mode) throws Exception {
  53         {
  54             ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(

  55                     "-XX:-UnlockDiagnosticVMOptions",
  56                     "-XX:-UnlockExperimentalVMOptions",
  57                     "-XX:+UseShenandoahGC",
  58                     h,
  59                     "-version"
  60             );
  61             OutputAnalyzer output = new OutputAnalyzer(pb.start());
  62             switch (mode) {
  63                 case PRODUCT:
  64                     output.shouldHaveExitValue(0);
  65                     break;
  66                 case DIAGNOSTIC:
  67                 case EXPERIMENTAL:
  68                     output.shouldNotHaveExitValue(0);
  69                     break;
  70             }
  71         }
  72 
  73         {
  74             ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(

  75                     "-XX:+UnlockDiagnosticVMOptions",
  76                     "-XX:-UnlockExperimentalVMOptions",
  77                     "-XX:+UseShenandoahGC",
  78                     h,
  79                     "-version"
  80             );
  81             OutputAnalyzer output = new OutputAnalyzer(pb.start());
  82             switch (mode) {
  83                 case PRODUCT:
  84                 case DIAGNOSTIC:
  85                     output.shouldHaveExitValue(0);
  86                     break;
  87                 case EXPERIMENTAL:
  88                     output.shouldNotHaveExitValue(0);
  89                     break;
  90             }
  91         }
  92 
  93         {
  94             ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(

  95                     "-XX:-UnlockDiagnosticVMOptions",
  96                     "-XX:+UnlockExperimentalVMOptions",
  97                     "-XX:+UseShenandoahGC",
  98                     h,
  99                     "-version"
 100             );
 101             OutputAnalyzer output = new OutputAnalyzer(pb.start());
 102             switch (mode) {
 103                 case PRODUCT:
 104                 case EXPERIMENTAL:
 105                     output.shouldHaveExitValue(0);
 106                     break;
 107                 case DIAGNOSTIC:
 108                     output.shouldNotHaveExitValue(0);
 109                     break;
 110             }
 111         }
 112     }
 113 
 114 }


  35 import jdk.test.lib.process.ProcessTools;
  36 import jdk.test.lib.process.OutputAnalyzer;
  37 
  38 public class TestModeUnlock {
  39 
  40     enum Mode {
  41         PRODUCT,
  42         DIAGNOSTIC,
  43         EXPERIMENTAL,
  44     }
  45 
  46     public static void main(String[] args) throws Exception {
  47         testWith("-XX:ShenandoahGCMode=satb",    Mode.PRODUCT);
  48         testWith("-XX:ShenandoahGCMode=iu",      Mode.EXPERIMENTAL);
  49         testWith("-XX:ShenandoahGCMode=passive", Mode.DIAGNOSTIC);
  50     }
  51 
  52     private static void testWith(String h, Mode mode) throws Exception {
  53         {
  54             ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(
  55                     "-Xmx128m",
  56                     "-XX:-UnlockDiagnosticVMOptions",
  57                     "-XX:-UnlockExperimentalVMOptions",
  58                     "-XX:+UseShenandoahGC",
  59                     h,
  60                     "-version"
  61             );
  62             OutputAnalyzer output = new OutputAnalyzer(pb.start());
  63             switch (mode) {
  64                 case PRODUCT:
  65                     output.shouldHaveExitValue(0);
  66                     break;
  67                 case DIAGNOSTIC:
  68                 case EXPERIMENTAL:
  69                     output.shouldNotHaveExitValue(0);
  70                     break;
  71             }
  72         }
  73 
  74         {
  75             ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(
  76                     "-Xmx128m",
  77                     "-XX:+UnlockDiagnosticVMOptions",
  78                     "-XX:-UnlockExperimentalVMOptions",
  79                     "-XX:+UseShenandoahGC",
  80                     h,
  81                     "-version"
  82             );
  83             OutputAnalyzer output = new OutputAnalyzer(pb.start());
  84             switch (mode) {
  85                 case PRODUCT:
  86                 case DIAGNOSTIC:
  87                     output.shouldHaveExitValue(0);
  88                     break;
  89                 case EXPERIMENTAL:
  90                     output.shouldNotHaveExitValue(0);
  91                     break;
  92             }
  93         }
  94 
  95         {
  96             ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(
  97                     "-Xmx128m",
  98                     "-XX:-UnlockDiagnosticVMOptions",
  99                     "-XX:+UnlockExperimentalVMOptions",
 100                     "-XX:+UseShenandoahGC",
 101                     h,
 102                     "-version"
 103             );
 104             OutputAnalyzer output = new OutputAnalyzer(pb.start());
 105             switch (mode) {
 106                 case PRODUCT:
 107                 case EXPERIMENTAL:
 108                     output.shouldHaveExitValue(0);
 109                     break;
 110                 case DIAGNOSTIC:
 111                     output.shouldNotHaveExitValue(0);
 112                     break;
 113             }
 114         }
 115     }
 116 
 117 }
< prev index next >