1 /*
   2  * Copyright (c) 2016, 2018, Red Hat, Inc. All rights reserved.
   3  *
   4  * This code is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU General Public License version 2 only, as
   6  * published by the Free Software Foundation.
   7  *
   8  * This code is distributed in the hope that it will be useful, but WITHOUT
   9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  11  * version 2 for more details (a copy is included in the LICENSE file that
  12  * accompanied this code).
  13  *
  14  * You should have received a copy of the GNU General Public License version
  15  * 2 along with this work; if not, write to the Free Software Foundation,
  16  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  17  *
  18  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  19  * or visit www.oracle.com if you need additional information or have any
  20  * questions.
  21  *
  22  */
  23 
  24 /*
  25  * @test TestRegionSizeArgs
  26  * @summary Test that Shenandoah region size args are checked
  27  * @key gc
  28  * @requires vm.gc.Shenandoah
  29  * @library /test/lib
  30  * @modules java.base/jdk.internal.misc
  31  *          java.management
  32  * @run driver TestRegionSizeArgs
  33  */
  34 
  35 import jdk.test.lib.process.ProcessTools;
  36 import jdk.test.lib.process.OutputAnalyzer;
  37 
  38 public class TestRegionSizeArgs {
  39     public static void main(String[] args) throws Exception {
  40         testInvalidRegionSizes();
  41         testMinRegionSize();
  42         testMaxRegionSize();
  43     }
  44 
  45     private static void testInvalidRegionSizes() throws Exception {
  46 
  47         {
  48             ProcessBuilder pb = ProcessTools.createJavaProcessBuilder("-XX:+UnlockExperimentalVMOptions",
  49                     "-XX:+UseShenandoahGC",
  50                     "-Xms2m",
  51                     "-Xmx1g",
  52                     "-version");
  53             OutputAnalyzer output = new OutputAnalyzer(pb.start());
  54             output.shouldMatch("Initial heap size");
  55             output.shouldHaveExitValue(1);
  56         }
  57 
  58         {
  59             ProcessBuilder pb = ProcessTools.createJavaProcessBuilder("-XX:+UnlockExperimentalVMOptions",
  60                     "-XX:+UseShenandoahGC",
  61                     "-Xms4m",
  62                     "-Xmx1g",
  63                     "-version");
  64             OutputAnalyzer output = new OutputAnalyzer(pb.start());
  65             output.shouldHaveExitValue(0);
  66         }
  67 
  68         {
  69             ProcessBuilder pb = ProcessTools.createJavaProcessBuilder("-XX:+UnlockExperimentalVMOptions",
  70                     "-XX:+UseShenandoahGC",
  71                     "-Xms8m",
  72                     "-Xmx1g",
  73                     "-version");
  74             OutputAnalyzer output = new OutputAnalyzer(pb.start());
  75             output.shouldHaveExitValue(0);
  76         }
  77 
  78         {
  79             ProcessBuilder pb = ProcessTools.createJavaProcessBuilder("-XX:+UnlockExperimentalVMOptions",
  80                     "-XX:+UseShenandoahGC",
  81                     "-Xms100m",
  82                     "-Xmx1g",
  83                     "-XX:ShenandoahHeapRegionSize=200m",
  84                     "-version");
  85             OutputAnalyzer output = new OutputAnalyzer(pb.start());
  86             output.shouldMatch("Invalid -XX:ShenandoahHeapRegionSize option");
  87             output.shouldHaveExitValue(1);
  88         }
  89 
  90         {
  91             ProcessBuilder pb = ProcessTools.createJavaProcessBuilder("-XX:+UnlockExperimentalVMOptions",
  92                     "-XX:+UseShenandoahGC",
  93                     "-Xms100m",
  94                     "-Xmx1g",
  95                     "-XX:ShenandoahHeapRegionSize=11m",
  96                     "-version");
  97             OutputAnalyzer output = new OutputAnalyzer(pb.start());
  98             output.shouldMatch("Invalid -XX:ShenandoahHeapRegionSize option");
  99             output.shouldHaveExitValue(1);
 100         }
 101 
 102         {
 103             ProcessBuilder pb = ProcessTools.createJavaProcessBuilder("-XX:+UnlockExperimentalVMOptions",
 104                     "-XX:+UseShenandoahGC",
 105                     "-Xms100m",
 106                     "-Xmx1g",
 107                     "-XX:ShenandoahHeapRegionSize=9m",
 108                     "-version");
 109             OutputAnalyzer output = new OutputAnalyzer(pb.start());
 110             output.shouldHaveExitValue(0);
 111         }
 112 
 113         {
 114             ProcessBuilder pb = ProcessTools.createJavaProcessBuilder("-XX:+UnlockExperimentalVMOptions",
 115                     "-XX:+UseShenandoahGC",
 116                     "-Xms100m",
 117                     "-Xmx1g",
 118                     "-XX:ShenandoahHeapRegionSize=255K",
 119                     "-version");
 120             OutputAnalyzer output = new OutputAnalyzer(pb.start());
 121             output.shouldMatch("Invalid -XX:ShenandoahHeapRegionSize option");
 122             output.shouldHaveExitValue(1);
 123         }
 124 
 125         {
 126             ProcessBuilder pb = ProcessTools.createJavaProcessBuilder("-XX:+UnlockExperimentalVMOptions",
 127                     "-XX:+UseShenandoahGC",
 128                     "-Xms100m",
 129                     "-Xmx1g",
 130                     "-XX:ShenandoahHeapRegionSize=260K",
 131                     "-version");
 132             OutputAnalyzer output = new OutputAnalyzer(pb.start());
 133             output.shouldHaveExitValue(0);
 134         }
 135 
 136         {
 137             ProcessBuilder pb = ProcessTools.createJavaProcessBuilder("-XX:+UnlockExperimentalVMOptions",
 138                     "-XX:+UseShenandoahGC",
 139                     "-Xms1g",
 140                     "-Xmx1g",
 141                     "-XX:ShenandoahHeapRegionSize=32M",
 142                     "-version");
 143             OutputAnalyzer output = new OutputAnalyzer(pb.start());
 144             output.shouldHaveExitValue(0);
 145         }
 146 
 147         {
 148             ProcessBuilder pb = ProcessTools.createJavaProcessBuilder("-XX:+UnlockExperimentalVMOptions",
 149                     "-XX:+UseShenandoahGC",
 150                     "-Xms1g",
 151                     "-Xmx1g",
 152                     "-XX:ShenandoahHeapRegionSize=64M",
 153                     "-version");
 154             OutputAnalyzer output = new OutputAnalyzer(pb.start());
 155             output.shouldMatch("Invalid -XX:ShenandoahHeapRegionSize option");
 156             output.shouldHaveExitValue(1);
 157         }
 158 
 159         {
 160             ProcessBuilder pb = ProcessTools.createJavaProcessBuilder("-XX:+UnlockExperimentalVMOptions",
 161                     "-XX:+UseShenandoahGC",
 162                     "-Xms1g",
 163                     "-Xmx1g",
 164                     "-XX:ShenandoahHeapRegionSize=256K",
 165                     "-version");
 166             OutputAnalyzer output = new OutputAnalyzer(pb.start());
 167             output.shouldHaveExitValue(0);
 168         }
 169 
 170         {
 171             ProcessBuilder pb = ProcessTools.createJavaProcessBuilder("-XX:+UnlockExperimentalVMOptions",
 172                     "-XX:+UseShenandoahGC",
 173                     "-Xms1g",
 174                     "-Xmx1g",
 175                     "-XX:ShenandoahHeapRegionSize=128K",
 176                     "-version");
 177             OutputAnalyzer output = new OutputAnalyzer(pb.start());
 178             output.shouldMatch("Invalid -XX:ShenandoahHeapRegionSize option");
 179             output.shouldHaveExitValue(1);
 180         }
 181     }
 182 
 183     private static void testMinRegionSize() throws Exception {
 184 
 185         {
 186             ProcessBuilder pb = ProcessTools.createJavaProcessBuilder("-XX:+UnlockExperimentalVMOptions",
 187                     "-XX:+UseShenandoahGC",
 188                     "-Xms100m",
 189                     "-Xmx1g",
 190                     "-XX:ShenandoahMinRegionSize=255K",
 191                     "-version");
 192             OutputAnalyzer output = new OutputAnalyzer(pb.start());
 193             output.shouldMatch("Invalid -XX:ShenandoahMinRegionSize option");
 194             output.shouldHaveExitValue(1);
 195         }
 196 
 197         {
 198             ProcessBuilder pb = ProcessTools.createJavaProcessBuilder("-XX:+UnlockExperimentalVMOptions",
 199                     "-XX:+UseShenandoahGC",
 200                     "-Xms100m",
 201                     "-Xmx1g",
 202                     "-XX:ShenandoahMinRegionSize=1M",
 203                     "-XX:ShenandoahMaxRegionSize=260K",
 204                     "-version");
 205             OutputAnalyzer output = new OutputAnalyzer(pb.start());
 206             output.shouldMatch("Invalid -XX:ShenandoahMinRegionSize or -XX:ShenandoahMaxRegionSize");
 207             output.shouldHaveExitValue(1);
 208         }
 209         {
 210             ProcessBuilder pb = ProcessTools.createJavaProcessBuilder("-XX:+UnlockExperimentalVMOptions",
 211                     "-XX:+UseShenandoahGC",
 212                     "-Xms100m",
 213                     "-Xmx1g",
 214                     "-XX:ShenandoahMinRegionSize=200m",
 215                     "-version");
 216             OutputAnalyzer output = new OutputAnalyzer(pb.start());
 217             output.shouldMatch("Invalid -XX:ShenandoahMinRegionSize option");
 218             output.shouldHaveExitValue(1);
 219         }
 220 
 221         {
 222             ProcessBuilder pb = ProcessTools.createJavaProcessBuilder("-XX:+UnlockExperimentalVMOptions",
 223                     "-XX:+UseShenandoahGC",
 224                     "-Xms100m",
 225                     "-Xmx1g",
 226                     "-XX:ShenandoahMinRegionSize=11m",
 227                     "-version");
 228             OutputAnalyzer output = new OutputAnalyzer(pb.start());
 229             output.shouldMatch("Invalid -XX:ShenandoahMinRegionSize option");
 230             output.shouldHaveExitValue(1);
 231         }
 232 
 233         {
 234             ProcessBuilder pb = ProcessTools.createJavaProcessBuilder("-XX:+UnlockExperimentalVMOptions",
 235                     "-XX:+UseShenandoahGC",
 236                     "-Xms100m",
 237                     "-Xmx1g",
 238                     "-XX:ShenandoahMinRegionSize=9m",
 239                     "-version");
 240             OutputAnalyzer output = new OutputAnalyzer(pb.start());
 241             output.shouldHaveExitValue(0);
 242         }
 243 
 244     }
 245 
 246     private static void testMaxRegionSize() throws Exception {
 247 
 248         {
 249             ProcessBuilder pb = ProcessTools.createJavaProcessBuilder("-XX:+UnlockExperimentalVMOptions",
 250                     "-XX:+UseShenandoahGC",
 251                     "-Xms100m",
 252                     "-Xmx1g",
 253                     "-XX:ShenandoahMaxRegionSize=255K",
 254                     "-version");
 255             OutputAnalyzer output = new OutputAnalyzer(pb.start());
 256             output.shouldMatch("Invalid -XX:ShenandoahMaxRegionSize option");
 257             output.shouldHaveExitValue(1);
 258         }
 259 
 260         {
 261             ProcessBuilder pb = ProcessTools.createJavaProcessBuilder("-XX:+UnlockExperimentalVMOptions",
 262                     "-XX:+UseShenandoahGC",
 263                     "-Xms100m",
 264                     "-Xmx1g",
 265                     "-XX:ShenandoahMinRegionSize=1M",
 266                     "-XX:ShenandoahMaxRegionSize=260K",
 267                     "-version");
 268             OutputAnalyzer output = new OutputAnalyzer(pb.start());
 269             output.shouldMatch("Invalid -XX:ShenandoahMinRegionSize or -XX:ShenandoahMaxRegionSize");
 270             output.shouldHaveExitValue(1);
 271         }
 272     }
 273 }