1 /*

     2  * Copyright (c) 2016, 2018, 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.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 package jdk.jfr.startupargs;

    27 

    28 import java.util.List;

    29 import java.util.ArrayList;

    30 

    31 import jdk.jfr.internal.Options;

    32 import jdk.test.lib.process.OutputAnalyzer;

    33 import jdk.test.lib.process.ProcessTools;

    34 import jdk.internal.misc.Unsafe;

    35 

    36 /*

    37  * @test

    38  * @key jfr

    39  * @library /test/lib

    40  * @modules jdk.jfr/jdk.jfr.internal

    41  *                 java.base/jdk.internal.misc

    42  * @run main/timeout=900 jdk.jfr.startupargs.TestMemoryOptions

    43  */

    44 public class TestMemoryOptions {

    45 

    46     public enum Unit {

    47         b('b'), k('k'), m('m'), g('g');

    48 

    49         private char unit;

    50 

    51         Unit(char unit) {

    52             this.unit = unit;

    53         }

    54 

    55         char getUnit() {

    56             return unit;

    57         }

    58     };

    59 

    60     static class Option implements Comparable<Option> {

    61         static final long MIN_GLOBAL_BUFFER_COUNT = 2;

    62         static final long DEFAULT_GLOBAL_BUFFER_COUNT = 20;

    63         static final long MIN_GLOBAL_BUFFER_SIZE = 64 * 1024;

    64         static long DEFAULT_GLOBAL_BUFFER_SIZE = 524288;

    65         static final long MIN_MEMORY_SIZE = 1024 * 1024;

    66         static final long DEFAULT_MEMORY_SIZE = DEFAULT_GLOBAL_BUFFER_COUNT * DEFAULT_GLOBAL_BUFFER_SIZE;

    67         static final long MIN_THREAD_BUFFER_SIZE = 4 * 1024;

    68         static long DEFAULT_THREAD_BUFFER_SIZE;

    69         static final long PAGE_SIZE;

    70         static final long UNDEFINED = -1;

    71 

    72         static {

    73             PAGE_SIZE = Unsafe.getUnsafe().pageSize();

    74             if (PAGE_SIZE == MIN_THREAD_BUFFER_SIZE) {

    75                 DEFAULT_THREAD_BUFFER_SIZE = PAGE_SIZE * 2;

    76             } else {

    77                 DEFAULT_THREAD_BUFFER_SIZE = PAGE_SIZE;

    78             }

    79             if (PAGE_SIZE > DEFAULT_GLOBAL_BUFFER_SIZE) {

    80                 DEFAULT_GLOBAL_BUFFER_SIZE = PAGE_SIZE;

    81             }

    82         }

    83 

    84         final private long min;

    85         final private long max;

    86         final private String paramName;

    87 

    88         private long input;

    89         private Unit inputUnit;

    90         private long result;

    91         private Unit resultUnit;

    92 

    93         private long getValueAsUnit(long value, Unit unit) {

    94             switch (unit) {

    95                 case b:

    96                     return value;

    97                 case k:

    98                     return value / 1024;

    99                 case m:

   100                     return value / (1024 * 1024);

   101                 case g:

   102                     return value / (1024 * 1024 * 1024);

   103             }

   104             return value;

   105         }

   106 

   107         private long getRawValue(long value, Unit unit) {

   108             switch (unit) {

   109                 case b:

   110                     return value;

   111                 case k:

   112                     return value * 1024;

   113                 case m:

   114                     return value * (1024 * 1024);

   115                 case g:

   116                     return value * (1024 * 1024 * 1024);

   117             }

   118             return value;

   119         }

   120 

   121         private long parseValue(String valueString, char unit) {

   122             if (Character.isLetter(unit)) {

   123                 unit = Character.toLowerCase(unit);

   124                 return getRawValue(Long.parseLong(valueString.substring(0, valueString.length() - 1), 10),

   125                                                   Unit.valueOf(String.valueOf(unit)));

   126             }

   127             // does not have a unit, default is bytes

   128             return Long.parseLong(valueString.substring(0, valueString.length()), 10);

   129         }

   130 

   131         public Option(String minString, String maxString, String paramName) {

   132             if (minString == null) {

   133                 this.min = UNDEFINED;

   134             } else {

   135                 char unit = minString.charAt(minString.length() - 1);

   136                 this.min = parseValue(minString, unit);

   137             }

   138             if (maxString == null) {

   139                 this.max = UNDEFINED;

   140             } else {

   141                 char unit = maxString.charAt(maxString.length() - 1);

   142                 this.max = parseValue(maxString, unit);

   143             }

   144             this.input = UNDEFINED;

   145             this.result = UNDEFINED;

   146             this.paramName = paramName;

   147         }

   148 

   149         private Option(long value, char unit) {

   150             this.resultUnit = Unit.valueOf(String.valueOf(unit));

   151             this.result = getRawValue(value, this.resultUnit);

   152             this.min = UNDEFINED;

   153             this.max = UNDEFINED;

   154             this.paramName = "";

   155         }

   156 

   157         public void setInput(long value, char unit) {

   158             this.inputUnit = Unit.valueOf(String.valueOf(unit));

   159             this.input = getRawValue(value, this.inputUnit);

   160         }

   161 

   162         public long getInput() {

   163             return input;

   164         }

   165 

   166         public void setResult(long value, char unit) {

   167             this.resultUnit = Unit.valueOf(String.valueOf(unit));

   168             this.result = getRawValue(value, this.resultUnit);

   169         }

   170 

   171         public long getResult() {

   172             return result;

   173         }

   174 

   175         public long getResultAs(Unit unit) {

   176             return getValueAsUnit(this.result, unit);

   177         }

   178 

   179         public String getOptionParamName() {

   180             return paramName;

   181         }

   182 

   183         public String getOptionParamString() {

   184             if (input == UNDEFINED) {

   185                 return null;

   186             }

   187             char unit = inputUnit.getUnit();

   188             String unitString = Character.compare(unit, 'b') == 0 ? "" : String.valueOf(unit);

   189             return getOptionParamName() + "=" + Long.toString(getValueAsUnit(input, inputUnit)) + unitString;

   190         }

   191 

   192         public boolean predictedToStartVM() {

   193             if (input == UNDEFINED) {

   194                 // option not set

   195                 return true;

   196             }

   197             if (input >= 0) {

   198                 if (min != UNDEFINED) {

   199                     if (max != UNDEFINED) {

   200                         return input >= min && input <= max;

   201                     }

   202                     return input >= min;

   203                 }

   204                 if (max != UNDEFINED) {

   205                     if (min != UNDEFINED) {

   206                         return input <= max && input >= min;

   207                     }

   208                 }

   209                 return true;

   210             }

   211             return false;

   212         }

   213 

   214         public boolean isSet() {

   215             return input != UNDEFINED;

   216         }

   217 

   218         public boolean validate() throws IllegalArgumentException {

   219             // a result memory options should be page aligned

   220             if (getResult() > PAGE_SIZE) {

   221                 if (getResult() % PAGE_SIZE != 0) {

   222                     throw new IllegalArgumentException("Result value: "

   223                     + getResult() + " for option " + getOptionParamName() + " is not aligned to page size " + PAGE_SIZE);

   224                 }

   225             }

   226             // if min is defined, the result value should be gteq

   227             if (min != UNDEFINED) {

   228                 if (getResult() < min) {

   229                     throw new IllegalArgumentException("Result value: "

   230                     + getResult() + " for option " + getOptionParamName() + " is less than min: " + min);

   231                 }

   232             }

   233             // if max is defined, the result values should be lteq

   234             if (max != UNDEFINED) {

   235                 if (getResult() > max) {

   236                     throw new IllegalArgumentException("Result value: "

   237                     + getResult() + " for option " + getOptionParamName() + " is greater than max: " + max);

   238                 }

   239             }

   240             return true;

   241         }

   242 

   243         @Override

   244         public int compareTo(Option obj) {

   245             if (getResult() == obj.getResult()) {

   246                 return 0;

   247             }

   248             return getResult() > obj.getResult() ? 1 : -1;

   249         }

   250 

   251         @Override

   252         public boolean equals(Object obj) {

   253             if (obj == null) {

   254                 return false;

   255             }

   256             if (!Option.class.isAssignableFrom(obj.getClass())) {

   257                 return false;

   258             }

   259             final Option other = (Option) obj;

   260 

   261             return getResult() == other.getResult();

   262         }

   263 

   264         @Override

   265         public int hashCode() {

   266             long hash = 3;

   267             hash = 53 * hash * getResult();

   268             return (int)hash;

   269         }

   270 

   271         @Override

   272         public String toString() {

   273             return Long.toString(getResult());

   274         }

   275 

   276         public Option multiply(Option rhsFactor) {

   277             return new Option(getResult() * rhsFactor.getResult(), 'b');

   278         }

   279 

   280         public Option divide(Option rhsDivisor) {

   281             long divisor = rhsDivisor.getResult();

   282             if (divisor == 0) {

   283                 return new Option(0, 'b');

   284             }

   285             return new Option(getResult() / divisor, 'b');

   286         }

   287 

   288         boolean isLessThanOrEqual(Option rhs) {

   289             return getResult() <= rhs.getResult();

   290         }

   291 

   292         boolean isGreaterThanOrEqual(Option rhs) {

   293             return getResult() >= rhs.getResult();

   294         }

   295     }

   296 

   297     private static class TestCase {

   298         private static final int MEMORYSIZE = 0;

   299         private static final int GLOBALBUFFERSIZE = 1;

   300         private static final int GLOBALBUFFERCOUNT = 2;

   301         private static final int THREADBUFFERSIZE = 3;

   302 

   303         final private List<Option> optionList = new ArrayList<Option>();

   304         final private String testName;

   305 

   306         public TestCase(String testName, boolean runTest) {

   307             this.testName = testName;

   308             Option memorySize = new Option(Long.toString(Option.MIN_MEMORY_SIZE), null, "memorysize");

   309             optionList.add(memorySize);

   310 

   311             Option globalBufferSize = new Option(Long.toString(Option.MIN_GLOBAL_BUFFER_SIZE),

   312                                                  null, "globalbuffersize");

   313             optionList.add(globalBufferSize);

   314 

   315             Option globalBufferCount = new Option(Long.toString(Option.MIN_GLOBAL_BUFFER_COUNT), null, "numglobalbuffers");

   316             optionList.add(globalBufferCount);

   317 

   318             Option threadBufferSize = new Option(Long.toString(Option.MIN_THREAD_BUFFER_SIZE), null, "threadbuffersize");

   319             optionList.add(threadBufferSize);

   320 

   321             if (runTest) {

   322                 populateResults();

   323                 validateNodes();

   324                 validateEdges();

   325             }

   326         }

   327 

   328         public String getTestString() {

   329             String optionString = "-XX:FlightRecorderOptions=";

   330             for (Option o : optionList) {

   331                 String optionParamString = o.getOptionParamString();

   332                 if (optionParamString == null) {

   333                     continue;

   334                 }

   335                 optionString = optionString.concat(optionParamString);

   336                 optionString = optionString.concat(",");

   337             }

   338             if (optionString.equals("-XX:FlightRecorderOptions=")) {

   339                 return null;

   340             }

   341             // strip last ","

   342             optionString = optionString.substring(0, optionString.length() - 1);

   343             return optionString;

   344         }

   345 

   346         public String getTestName() {

   347             return this.testName;

   348         }

   349 

   350         private void setInputForIndex(int index, long size, char unit) {

   351             optionList.get(index).setInput(size, unit);

   352         }

   353 

   354         private void setResultForIndex(int index, long size, char unit) {

   355             optionList.get(index).setResult(size, unit);

   356         }

   357 

   358         public void setMemorySizeTestParam(long size, char unit) {

   359             setInputForIndex(MEMORYSIZE, size, unit);

   360         }

   361 

   362         public void setMemorySizeTestResult(long size, char unit) {

   363             setResultForIndex(MEMORYSIZE, size, unit);

   364         }

   365 

   366         public void setGlobalBufferSizeTestParam(long size, char unit) {

   367             setInputForIndex(GLOBALBUFFERSIZE, size, unit);

   368         }

   369 

   370         public void setGlobalBufferSizeTestResult(long size, char unit) {

   371             setResultForIndex(GLOBALBUFFERSIZE, size, unit);

   372         }

   373 

   374         public void setGlobalBufferCountTestParam(long size, char unit) {

   375             setInputForIndex(GLOBALBUFFERCOUNT, size, unit);

   376         }

   377 

   378         public void setGlobalBufferCountTestResult(long size, char unit) {

   379             setResultForIndex(GLOBALBUFFERCOUNT, size, unit);

   380         }

   381 

   382         public void setThreadBufferSizeTestParam(long size, char unit) {

   383             setInputForIndex(THREADBUFFERSIZE, size, unit);

   384         }

   385 

   386         public void setThreadBufferSizeTestResult(long size, char unit) {

   387             setResultForIndex(THREADBUFFERSIZE, size, unit);

   388         }

   389 

   390         public void validateNodes() {

   391             for (Option o : optionList) {

   392                 o.validate();

   393             }

   394         }

   395 

   396         public void validateEdges() {

   397             final Option memorySize = optionList.get(MEMORYSIZE);

   398             final Option globalBufferSize = optionList.get(GLOBALBUFFERSIZE);

   399             final Option globalBufferCount = optionList.get(GLOBALBUFFERCOUNT);

   400             final Option threadBufferSize = optionList.get(THREADBUFFERSIZE);

   401 

   402             if (!memorySize.divide(globalBufferCount).equals(globalBufferSize)) {

   403                 throw new IllegalArgumentException(getTestName() + " failure: " + memorySize.getOptionParamName() + " (" + memorySize.getResult() + ") / " +

   404                                                    globalBufferCount.getOptionParamName() + " (" + globalBufferCount.getResult() +

   405                                                    ") (" + memorySize.divide(globalBufferCount).getResult() + ") != " +

   406                                                    globalBufferSize.getOptionParamName() + " (" + globalBufferSize.getResult() + ")");

   407             }

   408 

   409             if (!globalBufferSize.multiply(globalBufferCount).equals(memorySize)) {

   410                 throw new IllegalArgumentException(getTestName() + " failure: " + globalBufferSize.getOptionParamName() + ": " +

   411                                                    globalBufferSize.getResult() +

   412                                                    " * " + globalBufferCount.getOptionParamName() + ": " + globalBufferCount.getResult() +

   413                                                    " != " + memorySize.getOptionParamName() + ": " + memorySize.getResult());

   414             }

   415 

   416             if (!threadBufferSize.isLessThanOrEqual(globalBufferSize)) {

   417                 throw new IllegalArgumentException(getTestName() + " failure: " + threadBufferSize.getOptionParamName() + ": " + threadBufferSize.getResult() +

   418                                                    " is larger than " + globalBufferSize.getOptionParamName() + ": " + globalBufferSize.getResult());

   419             }

   420         }

   421 

   422         public void print() {

   423             System.out.println("Printing information for testcase : " + getTestName());

   424             for (Option o : optionList) {

   425                 System.out.println("Parameter name: " + o.getOptionParamName());

   426                 System.out.println("Parameter test value : " + o.getOptionParamString() != null ?  o.getOptionParamString() : "not enabled for input testing");

   427                 String inputString = o.getInput() == Option.UNDEFINED ? "N/A" : Long.toString(o.getInput());

   428                 System.out.println("Input value: " + inputString);

   429                 System.out.println("Predicted to start VM: " + (o.predictedToStartVM() ? "true" : "false"));

   430             }

   431         }

   432 

   433         private void populateResults() {

   434             optionList.get(MEMORYSIZE).setResult(Options.getMemorySize(), 'b');

   435             optionList.get(GLOBALBUFFERSIZE).setResult(Options.getGlobalBufferSize(), 'b');

   436             optionList.get(GLOBALBUFFERCOUNT).setResult(Options.getGlobalBufferCount(), 'b');

   437             optionList.get(THREADBUFFERSIZE).setResult(Options.getThreadBufferSize(), 'b');

   438         }

   439 

   440         public boolean predictedToStartVM() {

   441             // check each individual option

   442             for (Option o : optionList) {

   443                 if (!o.predictedToStartVM()) {

   444                     return false;

   445                 }

   446             }

   447 

   448             // check known invalid combinations that will not allow the VM to start

   449 

   450             // GLOBALBUFFERSIZE * GLOBALBUFFERCOUNT == MEMORYSIZE

   451             if (optionList.get(GLOBALBUFFERSIZE).isSet() && optionList.get(GLOBALBUFFERCOUNT).isSet()

   452                && optionList.get(MEMORYSIZE).isSet()) {

   453                long calculatedMemorySize = optionList.get(GLOBALBUFFERSIZE).getInput() * optionList.get(GLOBALBUFFERCOUNT).getInput();

   454                if (optionList.get(MEMORYSIZE).getInput() != calculatedMemorySize) {

   455                    return false;

   456                }

   457             }

   458             // GLOBALBUFFERSIZE * GLOBALBUFFERCOUNT >= MIN_MEMORY_SIZE

   459             if (optionList.get(GLOBALBUFFERSIZE).isSet() && optionList.get(GLOBALBUFFERCOUNT).isSet()

   460                 && !optionList.get(MEMORYSIZE).isSet()) {

   461                 long calculatedMemorySize = optionList.get(GLOBALBUFFERSIZE).getInput() * optionList.get(GLOBALBUFFERCOUNT).getInput();

   462                 if (Option.MIN_MEMORY_SIZE > calculatedMemorySize) {

   463                     return false;

   464                 }

   465             }

   466             // GLOBALBUFFERSIZE >= THREADBUFFERSIZE

   467             if (optionList.get(GLOBALBUFFERSIZE).isSet() && optionList.get(THREADBUFFERSIZE).isSet()) {

   468                 if (optionList.get(GLOBALBUFFERSIZE).getInput() < optionList.get(THREADBUFFERSIZE).getInput()) {

   469                     return false;

   470                 }

   471             }

   472             return true;

   473         }

   474     }

   475 

   476     public static class SUT {

   477         public static void main(String[] args) {

   478             TestCase tc = new TestCase(args[0], true);

   479         }

   480     }

   481 

   482     private static class Driver {

   483         private static void launchTestVM(TestCase tc) throws Exception {

   484             final String flightRecorderOptions = tc.getTestString();

   485             ProcessBuilder pb;

   486             if (flightRecorderOptions != null) {

   487                 pb = ProcessTools.createJavaProcessBuilder(true,

   488                                                            "--add-exports=jdk.jfr/jdk.jfr.internal=ALL-UNNAMED",

   489                                                            "--add-exports=java.base/jdk.internal.misc=ALL-UNNAMED",

   490                                                            flightRecorderOptions,

   491                                                            "-XX:StartFlightRecording",

   492                                                            SUT.class.getName(),

   493                                                            tc.getTestName());

   494             } else {

   495                 // default, no FlightRecorderOptions passed

   496                 pb = ProcessTools.createJavaProcessBuilder(true,

   497                                                            "--add-exports=jdk.jfr/jdk.jfr.internal=ALL-UNNAMED",

   498                                                            "--add-exports=java.base/jdk.internal.misc=ALL-UNNAMED",

   499                                                            "-XX:StartFlightRecording",

   500                                                            SUT.class.getName(),

   501                                                            tc.getTestName());

   502             }

   503 

   504             System.out.println("Driver launching SUT with string: " + flightRecorderOptions != null ? flightRecorderOptions : "default");

   505             System.out.println("SUT VM " + (tc.predictedToStartVM() ? "is" : "is not") + " expected to start");

   506             tc.print();

   507 

   508             OutputAnalyzer out = ProcessTools.executeProcess(pb);

   509 

   510             if (tc.predictedToStartVM()) {

   511                 out.shouldHaveExitValue(0);

   512             } else {

   513                 out.shouldContain("Failure when starting JFR");

   514                 out.shouldHaveExitValue(1);

   515             }

   516         }

   517 

   518         public static void runTestCase(TestCase tc) throws Exception {

   519             launchTestVM(tc);

   520         }

   521     }

   522 

   523     static private List<TestCase> testCases = new ArrayList<TestCase>();

   524 

   525     static {

   526         // positive example-based tests

   527         TestCase tc = new TestCase("DefaultOptionsPositive", false);

   528         // defaults, no options explicitly set

   529         testCases.add(tc);

   530 

   531         // explicit defaults passed as parameters

   532         tc = new TestCase("MemorySizePositive", false);

   533         tc.setMemorySizeTestParam(10, 'm');

   534         testCases.add(tc);

   535 

   536         tc = new TestCase("GlobalBufferSizePositive", false);

   537         tc.setGlobalBufferSizeTestParam(512, 'k');

   538         testCases.add(tc);

   539 

   540         tc = new TestCase("BufferCountPositive", false);

   541         tc.setGlobalBufferCountTestParam(20, 'b');

   542         testCases.add(tc);

   543 

   544         tc = new TestCase("ThreadBufferSizePositive", false);

   545         tc.setThreadBufferSizeTestParam(Option.DEFAULT_THREAD_BUFFER_SIZE, 'b');

   546         testCases.add(tc);

   547 

   548         // negative example-based tests, each individual option below minimum size

   549         tc = new TestCase("MemorySizeBelowMinNegative", false);

   550         tc.setMemorySizeTestParam(Option.MIN_MEMORY_SIZE - 1, 'b');

   551         testCases.add(tc);

   552 

   553         tc = new TestCase("GlobalBufferSizeBelowMinNegative", false);

   554         tc.setGlobalBufferSizeTestParam(Option.MIN_GLOBAL_BUFFER_SIZE - 1, 'b');

   555         testCases.add(tc);

   556 

   557         tc = new TestCase("BufferCountBelowMinNegative", false);

   558         tc.setGlobalBufferCountTestParam(Option.MIN_GLOBAL_BUFFER_COUNT - 1, 'b');

   559         testCases.add(tc);

   560 

   561         tc = new TestCase("ThreadBufferSizeBelowMinNegative", false);

   562         tc.setThreadBufferSizeTestParam(Option.MIN_THREAD_BUFFER_SIZE - 1, 'b');

   563         testCases.add(tc);

   564 

   565         // Memory size permutations

   566         // a few single memorysize option for deduction

   567         tc = new TestCase("MemorySizeValue1Positive", false);

   568         tc.setMemorySizeTestParam(48128, 'k'); // 47mb

   569         testCases.add(tc);

   570 

   571         tc = new TestCase("MemorySizeValue2Positive", false);

   572         tc.setMemorySizeTestParam(17391, 'k'); // 17808384 bytes

   573         testCases.add(tc);

   574 

   575         tc = new TestCase("MemorySizeValue3Positive", false);

   576         tc.setMemorySizeTestParam(Option.MIN_MEMORY_SIZE + 17, 'b');

   577         testCases.add(tc);

   578 

   579         // positive example-based-tests, memory size combined with other options

   580         tc = new TestCase("MemorySizeGlobalBufferSizePositive", false);

   581         tc.setMemorySizeTestParam(14680064, 'b'); // 14mb

   582         tc.setGlobalBufferSizeTestParam(720, 'k');

   583         testCases.add(tc);

   584 

   585         tc = new TestCase("MemorySizeGlobalBufferCountPositive", false);

   586         tc.setMemorySizeTestParam(14674581, 'b'); // 14mb - 5483 bytes

   587         tc.setGlobalBufferCountTestParam(17, 'b');

   588         testCases.add(tc);

   589 

   590         tc = new TestCase("MemorySizeThreadBufferSizePositive", false);

   591         tc.setMemorySizeTestParam(14586853, 'b'); // 14mb - 93211 bytes

   592         tc.setThreadBufferSizeTestParam(Option.DEFAULT_THREAD_BUFFER_SIZE, 'b');

   593         testCases.add(tc);

   594 

   595         tc = new TestCase("MemorySizeGlobalBufferSizeBufferCountPositive", false);

   596         tc.setMemorySizeTestParam(12240, 'k');

   597         tc.setGlobalBufferSizeTestParam(720, 'k'); // 720 k * 17 == 12240 k

   598         tc.setGlobalBufferCountTestParam(17, 'b');

   599         testCases.add(tc);

   600 

   601         tc = new TestCase("MemorySizeGlobalBufferSizeBufferCountThreadBufferSizePositive", false);

   602         tc.setMemorySizeTestParam(12240, 'k');

   603         tc.setGlobalBufferSizeTestParam(720, 'k'); // 720 k * 17 == 12240 k

   604         tc.setGlobalBufferCountTestParam(17, 'b');

   605         tc.setThreadBufferSizeTestParam(600, 'k');

   606         testCases.add(tc);

   607 

   608         // negative example-based test, create an ambiguous situtation

   609         tc = new TestCase("MemorySizeGlobalBufferSizeBufferCountAmbiguousNegative", false);

   610         tc.setMemorySizeTestParam(12240, 'k');

   611         tc.setGlobalBufferSizeTestParam(720, 'k'); // 720 k * 19 != 12240 k

   612         tc.setGlobalBufferCountTestParam(19, 'b');

   613         testCases.add(tc);

   614 

   615         // Global buffer size permutations

   616         tc = new TestCase("GlobalBufferSizeBufferCountPositive", false);

   617         tc.setGlobalBufferSizeTestParam(917, 'k');

   618         tc.setGlobalBufferCountTestParam(31, 'b');

   619         testCases.add(tc);

   620 

   621         tc = new TestCase("GlobalBufferSizeBufferCountThreadBufferSizePositive", false);

   622         tc.setGlobalBufferSizeTestParam(917, 'k');

   623         tc.setGlobalBufferCountTestParam(31, 'b');

   624         tc.setThreadBufferSizeTestParam(760832, 'b'); // 743 k

   625         testCases.add(tc);

   626 

   627         // negative example-based test, let thread buffer size > global buffer size

   628         tc = new TestCase("GlobalBufferSizeLessThanThreadBufferSizeNegative", false);

   629         tc.setGlobalBufferSizeTestParam(917, 'k');

   630         tc.setThreadBufferSizeTestParam(1317, 'k');

   631         testCases.add(tc);

   632 

   633         // explicitly specifying global buffer size and global buffer count must be gteq min memorysize

   634         tc = new TestCase("GlobalBufferSizeTimesGlobalBufferCountLessThanMinMemorySizeNegative", false);

   635         tc.setGlobalBufferSizeTestParam(67857, 'b');

   636         tc.setGlobalBufferCountTestParam(3, 'b');

   637         testCases.add(tc);

   638 

   639         // absolute minimum size

   640         tc = new TestCase("GlobalBufferSizeTimesGlobalBufferCountEqualToMinMemorySizePositive", false);

   641         tc.setGlobalBufferSizeTestParam(64, 'k');

   642         tc.setGlobalBufferCountTestParam(16, 'b');

   643         testCases.add(tc);

   644     }

   645 

   646     public static void main(String[] args) throws Exception {

   647         System.out.println("Testing " + testCases.size() + " number of testcases");

   648         for (TestCase tc : testCases) {

   649             Driver.runTestCase(tc);

   650         }

   651     }

   652 }