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 import java.lang.reflect.Field;
31
32 import jdk.jfr.internal.Options;
33 import jdk.test.lib.process.OutputAnalyzer;
34 import jdk.test.lib.process.ProcessTools;
35 import sun.misc.Unsafe;
36
37 /**
38 * @test
39 * @key jfr
40 *
41 * @library /lib /
42 *
43 * @run main/timeout=900 jdk.jfr.startupargs.TestMemoryOptions
44 */
45 public class TestMemoryOptions {
46
47 public enum Unit {
48 b('b'), k('k'), m('m'), g('g');
49
50 private char unit;
51
52 Unit(char unit) {
53 this.unit = unit;
54 }
55
56 char getUnit() {
57 return unit;
58 }
59 };
60
61 static class Option implements Comparable<Option> {
62 static final long MIN_GLOBAL_BUFFER_COUNT = 2;
63 static final long DEFAULT_GLOBAL_BUFFER_COUNT = 20;
64 static final long MIN_GLOBAL_BUFFER_SIZE = 64 * 1024;
65 static long DEFAULT_GLOBAL_BUFFER_SIZE = 524288;
66 static final long MIN_MEMORY_SIZE = 1024 * 1024;
67 static final long DEFAULT_MEMORY_SIZE = DEFAULT_GLOBAL_BUFFER_COUNT * DEFAULT_GLOBAL_BUFFER_SIZE;
68 static final long MIN_THREAD_BUFFER_SIZE = 4 * 1024;
69 static long DEFAULT_THREAD_BUFFER_SIZE;
70 static final long PAGE_SIZE;
71 static final long UNDEFINED = -1;
72
73 static {
74 try {
75 Field theUnsafeRefLocation = Unsafe.class.getDeclaredField("theUnsafe");
76 theUnsafeRefLocation.setAccessible(true);
77 PAGE_SIZE = ((Unsafe)theUnsafeRefLocation.get(null)).pageSize();
78 }
79 catch(Exception ex) {
80 throw new RuntimeException(ex);
81 }
82 if (PAGE_SIZE == MIN_THREAD_BUFFER_SIZE) {
83 DEFAULT_THREAD_BUFFER_SIZE = PAGE_SIZE * 2;
84 } else {
85 DEFAULT_THREAD_BUFFER_SIZE = PAGE_SIZE;
86 }
87 if (PAGE_SIZE > DEFAULT_GLOBAL_BUFFER_SIZE) {
88 DEFAULT_GLOBAL_BUFFER_SIZE = PAGE_SIZE;
89 }
90 }
91
92 final private long min;
93 final private long max;
94 final private String paramName;
95
96 private long input;
97 private Unit inputUnit;
98 private long result;
99 private Unit resultUnit;
100
101 private long getValueAsUnit(long value, Unit unit) {
102 switch (unit) {
103 case b:
104 return value;
105 case k:
106 return value / 1024;
107 case m:
108 return value / (1024 * 1024);
109 case g:
110 return value / (1024 * 1024 * 1024);
111 }
112 return value;
113 }
114
115 private long getRawValue(long value, Unit unit) {
116 switch (unit) {
117 case b:
118 return value;
119 case k:
120 return value * 1024;
121 case m:
122 return value * (1024 * 1024);
123 case g:
124 return value * (1024 * 1024 * 1024);
125 }
126 return value;
127 }
128
129 private long parseValue(String valueString, char unit) {
130 if (Character.isLetter(unit)) {
131 unit = Character.toLowerCase(unit);
132 return getRawValue(Long.parseLong(valueString.substring(0, valueString.length() - 1), 10),
133 Unit.valueOf(String.valueOf(unit)));
134 }
135 // does not have a unit, default is bytes
136 return Long.parseLong(valueString.substring(0, valueString.length()), 10);
137 }
138
139 public Option(String minString, String maxString, String paramName) {
140 if (minString == null) {
141 this.min = UNDEFINED;
142 } else {
143 char unit = minString.charAt(minString.length() - 1);
144 this.min = parseValue(minString, unit);
145 }
146 if (maxString == null) {
147 this.max = UNDEFINED;
148 } else {
149 char unit = maxString.charAt(maxString.length() - 1);
150 this.max = parseValue(maxString, unit);
151 }
152 this.input = UNDEFINED;
153 this.result = UNDEFINED;
154 this.paramName = paramName;
155 }
156
157 private Option(long value, char unit) {
158 this.resultUnit = Unit.valueOf(String.valueOf(unit));
159 this.result = getRawValue(value, this.resultUnit);
160 this.min = UNDEFINED;
161 this.max = UNDEFINED;
162 this.paramName = "";
163 }
164
165 public void setInput(long value, char unit) {
166 this.inputUnit = Unit.valueOf(String.valueOf(unit));
167 this.input = getRawValue(value, this.inputUnit);
168 }
169
170 public long getInput() {
171 return input;
172 }
173
174 public void setResult(long value, char unit) {
175 this.resultUnit = Unit.valueOf(String.valueOf(unit));
176 this.result = getRawValue(value, this.resultUnit);
177 }
178
179 public long getResult() {
180 return result;
181 }
182
183 public long getResultAs(Unit unit) {
184 return getValueAsUnit(this.result, unit);
185 }
186
187 public String getOptionParamName() {
188 return paramName;
189 }
190
191 public String getOptionParamString() {
192 if (input == UNDEFINED) {
193 return null;
194 }
195 char unit = inputUnit.getUnit();
196 String unitString = Character.compare(unit, 'b') == 0 ? "" : String.valueOf(unit);
197 return getOptionParamName() + "=" + Long.toString(getValueAsUnit(input, inputUnit)) + unitString;
198 }
199
200 public boolean predictedToStartVM() {
201 if (input == UNDEFINED) {
202 // option not set
203 return true;
204 }
205 if (input >= 0) {
206 if (min != UNDEFINED) {
207 if (max != UNDEFINED) {
208 return input >= min && input <= max;
209 }
210 return input >= min;
211 }
212 if (max != UNDEFINED) {
213 if (min != UNDEFINED) {
214 return input <= max && input >= min;
215 }
216 }
217 return true;
218 }
219 return false;
220 }
221
222 public boolean isSet() {
223 return input != UNDEFINED;
224 }
225
226 public boolean validate() throws IllegalArgumentException {
227 // a result memory options should be page aligned
228 if (getResult() > PAGE_SIZE) {
229 if (getResult() % PAGE_SIZE != 0) {
230 throw new IllegalArgumentException("Result value: "
231 + getResult() + " for option " + getOptionParamName() + " is not aligned to page size " + PAGE_SIZE);
232 }
233 }
234 // if min is defined, the result value should be gteq
235 if (min != UNDEFINED) {
236 if (getResult() < min) {
237 throw new IllegalArgumentException("Result value: "
238 + getResult() + " for option " + getOptionParamName() + " is less than min: " + min);
239 }
240 }
241 // if max is defined, the result values should be lteq
242 if (max != UNDEFINED) {
243 if (getResult() > max) {
244 throw new IllegalArgumentException("Result value: "
245 + getResult() + " for option " + getOptionParamName() + " is greater than max: " + max);
246 }
247 }
248 return true;
249 }
250
251 @Override
252 public int compareTo(Option obj) {
253 if (getResult() == obj.getResult()) {
254 return 0;
255 }
256 return getResult() > obj.getResult() ? 1 : -1;
257 }
258
259 @Override
260 public boolean equals(Object obj) {
261 if (obj == null) {
262 return false;
263 }
264 if (!Option.class.isAssignableFrom(obj.getClass())) {
265 return false;
266 }
267 final Option other = (Option) obj;
268
269 return getResult() == other.getResult();
270 }
271
272 @Override
273 public int hashCode() {
274 long hash = 3;
275 hash = 53 * hash * getResult();
276 return (int)hash;
277 }
278
279 @Override
280 public String toString() {
281 return Long.toString(getResult());
282 }
283
284 public Option multiply(Option rhsFactor) {
285 return new Option(getResult() * rhsFactor.getResult(), 'b');
286 }
287
288 public Option divide(Option rhsDivisor) {
289 long divisor = rhsDivisor.getResult();
290 if (divisor == 0) {
291 return new Option(0, 'b');
292 }
293 return new Option(getResult() / divisor, 'b');
294 }
295
296 boolean isLessThanOrEqual(Option rhs) {
297 return getResult() <= rhs.getResult();
298 }
299
300 boolean isGreaterThanOrEqual(Option rhs) {
301 return getResult() >= rhs.getResult();
302 }
303 }
304
305 private static class TestCase {
306 private static final int MEMORYSIZE = 0;
307 private static final int GLOBALBUFFERSIZE = 1;
308 private static final int GLOBALBUFFERCOUNT = 2;
309 private static final int THREADBUFFERSIZE = 3;
310
311 final private List<Option> optionList = new ArrayList<Option>();
312 final private String testName;
313
314 public TestCase(String testName, boolean runTest) {
315 this.testName = testName;
316 Option memorySize = new Option(Long.toString(Option.MIN_MEMORY_SIZE), null, "memorysize");
317 optionList.add(memorySize);
318
319 Option globalBufferSize = new Option(Long.toString(Option.MIN_GLOBAL_BUFFER_SIZE),
320 null, "globalbuffersize");
321 optionList.add(globalBufferSize);
322
323 Option globalBufferCount = new Option(Long.toString(Option.MIN_GLOBAL_BUFFER_COUNT), null, "numglobalbuffers");
324 optionList.add(globalBufferCount);
325
326 Option threadBufferSize = new Option(Long.toString(Option.MIN_THREAD_BUFFER_SIZE), null, "threadbuffersize");
327 optionList.add(threadBufferSize);
328
329 if (runTest) {
330 populateResults();
331 validateNodes();
332 validateEdges();
333 }
334 }
335
336 public String getTestString() {
337 String optionString = "-XX:FlightRecorderOptions=";
338 for (Option o : optionList) {
339 String optionParamString = o.getOptionParamString();
340 if (optionParamString == null) {
341 continue;
342 }
343 optionString = optionString.concat(optionParamString);
344 optionString = optionString.concat(",");
345 }
346 if (optionString.equals("-XX:FlightRecorderOptions=")) {
347 return null;
348 }
349 // strip last ","
350 optionString = optionString.substring(0, optionString.length() - 1);
351 return optionString;
352 }
353
354 public String getTestName() {
355 return this.testName;
356 }
357
358 private void setInputForIndex(int index, long size, char unit) {
359 optionList.get(index).setInput(size, unit);
360 }
361
362 private void setResultForIndex(int index, long size, char unit) {
363 optionList.get(index).setResult(size, unit);
364 }
365
366 public void setMemorySizeTestParam(long size, char unit) {
367 setInputForIndex(MEMORYSIZE, size, unit);
368 }
369
370 public void setMemorySizeTestResult(long size, char unit) {
371 setResultForIndex(MEMORYSIZE, size, unit);
372 }
373
374 public void setGlobalBufferSizeTestParam(long size, char unit) {
375 setInputForIndex(GLOBALBUFFERSIZE, size, unit);
376 }
377
378 public void setGlobalBufferSizeTestResult(long size, char unit) {
379 setResultForIndex(GLOBALBUFFERSIZE, size, unit);
380 }
381
382 public void setGlobalBufferCountTestParam(long size, char unit) {
383 setInputForIndex(GLOBALBUFFERCOUNT, size, unit);
384 }
385
386 public void setGlobalBufferCountTestResult(long size, char unit) {
387 setResultForIndex(GLOBALBUFFERCOUNT, size, unit);
388 }
389
390 public void setThreadBufferSizeTestParam(long size, char unit) {
391 setInputForIndex(THREADBUFFERSIZE, size, unit);
392 }
393
394 public void setThreadBufferSizeTestResult(long size, char unit) {
395 setResultForIndex(THREADBUFFERSIZE, size, unit);
396 }
397
398 public void validateNodes() {
399 for (Option o : optionList) {
400 o.validate();
401 }
402 }
403
404 public void validateEdges() {
405 final Option memorySize = optionList.get(MEMORYSIZE);
406 final Option globalBufferSize = optionList.get(GLOBALBUFFERSIZE);
407 final Option globalBufferCount = optionList.get(GLOBALBUFFERCOUNT);
408 final Option threadBufferSize = optionList.get(THREADBUFFERSIZE);
409
410 if (!memorySize.divide(globalBufferCount).equals(globalBufferSize)) {
411 throw new IllegalArgumentException(getTestName() + " failure: " + memorySize.getOptionParamName() + " (" + memorySize.getResult() + ") / " +
412 globalBufferCount.getOptionParamName() + " (" + globalBufferCount.getResult() +
413 ") (" + memorySize.divide(globalBufferCount).getResult() + ") != " +
414 globalBufferSize.getOptionParamName() + " (" + globalBufferSize.getResult() + ")");
415 }
416
417 if (!globalBufferSize.multiply(globalBufferCount).equals(memorySize)) {
418 throw new IllegalArgumentException(getTestName() + " failure: " + globalBufferSize.getOptionParamName() + ": " +
419 globalBufferSize.getResult() +
420 " * " + globalBufferCount.getOptionParamName() + ": " + globalBufferCount.getResult() +
421 " != " + memorySize.getOptionParamName() + ": " + memorySize.getResult());
422 }
423
424 if (!threadBufferSize.isLessThanOrEqual(globalBufferSize)) {
425 throw new IllegalArgumentException(getTestName() + " failure: " + threadBufferSize.getOptionParamName() + ": " + threadBufferSize.getResult() +
426 " is larger than " + globalBufferSize.getOptionParamName() + ": " + globalBufferSize.getResult());
427 }
428 }
429
430 public void print() {
431 System.out.println("Printing information for testcase : " + getTestName());
432 for (Option o : optionList) {
433 System.out.println("Parameter name: " + o.getOptionParamName());
434 System.out.println("Parameter test value : " + o.getOptionParamString() != null ? o.getOptionParamString() : "not enabled for input testing");
435 String inputString = o.getInput() == Option.UNDEFINED ? "N/A" : Long.toString(o.getInput());
436 System.out.println("Input value: " + inputString);
437 System.out.println("Predicted to start VM: " + (o.predictedToStartVM() ? "true" : "false"));
438 }
439 }
440
441 private void populateResults() {
442 optionList.get(MEMORYSIZE).setResult(Options.getMemorySize(), 'b');
443 optionList.get(GLOBALBUFFERSIZE).setResult(Options.getGlobalBufferSize(), 'b');
444 optionList.get(GLOBALBUFFERCOUNT).setResult(Options.getGlobalBufferCount(), 'b');
445 optionList.get(THREADBUFFERSIZE).setResult(Options.getThreadBufferSize(), 'b');
446 }
447
448 public boolean predictedToStartVM() {
449 // check each individual option
450 for (Option o : optionList) {
451 if (!o.predictedToStartVM()) {
452 return false;
453 }
454 }
455
456 // check known invalid combinations that will not allow the VM to start
457
458 // GLOBALBUFFERSIZE * GLOBALBUFFERCOUNT == MEMORYSIZE
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 (optionList.get(MEMORYSIZE).getInput() != calculatedMemorySize) {
463 return false;
464 }
465 }
466 // GLOBALBUFFERSIZE * GLOBALBUFFERCOUNT >= MIN_MEMORY_SIZE
467 if (optionList.get(GLOBALBUFFERSIZE).isSet() && optionList.get(GLOBALBUFFERCOUNT).isSet()
468 && !optionList.get(MEMORYSIZE).isSet()) {
469 long calculatedMemorySize = optionList.get(GLOBALBUFFERSIZE).getInput() * optionList.get(GLOBALBUFFERCOUNT).getInput();
470 if (Option.MIN_MEMORY_SIZE > calculatedMemorySize) {
471 return false;
472 }
473 }
474 // GLOBALBUFFERSIZE >= THREADBUFFERSIZE
475 if (optionList.get(GLOBALBUFFERSIZE).isSet() && optionList.get(THREADBUFFERSIZE).isSet()) {
476 if (optionList.get(GLOBALBUFFERSIZE).getInput() < optionList.get(THREADBUFFERSIZE).getInput()) {
477 return false;
478 }
479 }
480 return true;
481 }
482 }
483
484 public static class SUT {
485 public static void main(String[] args) {
486 TestCase tc = new TestCase(args[0], true);
487 }
488 }
489
490 private static class Driver {
491 private static void launchTestVM(TestCase tc) throws Exception {
492 final String flightRecorderOptions = tc.getTestString();
493 ProcessBuilder pb;
494 if (flightRecorderOptions != null) {
495 pb = ProcessTools.createJavaProcessBuilder(true,
496 flightRecorderOptions,
497 "-XX:StartFlightRecording",
498 SUT.class.getName(),
499 tc.getTestName());
500 } else {
501 // default, no FlightRecorderOptions passed
502 pb = ProcessTools.createJavaProcessBuilder(true,
503 "-XX:StartFlightRecording",
504 SUT.class.getName(),
505 tc.getTestName());
506 }
507
508 System.out.println("Driver launching SUT with string: " + flightRecorderOptions != null ? flightRecorderOptions : "default");
509 System.out.println("SUT VM " + (tc.predictedToStartVM() ? "is" : "is not") + " expected to start");
510 tc.print();
511
512 OutputAnalyzer out = ProcessTools.executeProcess(pb);
513
514 if (tc.predictedToStartVM()) {
515 out.shouldHaveExitValue(0);
516 } else {
517 out.shouldContain("Failure when starting JFR");
518 out.shouldHaveExitValue(1);
519 }
520 }
521
522 public static void runTestCase(TestCase tc) throws Exception {
523 launchTestVM(tc);
524 }
525 }
526
527 static private List<TestCase> testCases = new ArrayList<TestCase>();
528
529 static {
530 // positive example-based tests
531 TestCase tc = new TestCase("DefaultOptionsPositive", false);
532 // defaults, no options explicitly set
533 testCases.add(tc);
534
535 // explicit defaults passed as parameters
536 tc = new TestCase("MemorySizePositive", false);
537 tc.setMemorySizeTestParam(10, 'm');
538 testCases.add(tc);
539
540 tc = new TestCase("GlobalBufferSizePositive", false);
541 tc.setGlobalBufferSizeTestParam(512, 'k');
542 testCases.add(tc);
543
544 tc = new TestCase("BufferCountPositive", false);
545 tc.setGlobalBufferCountTestParam(20, 'b');
546 testCases.add(tc);
547
548 tc = new TestCase("ThreadBufferSizePositive", false);
549 tc.setThreadBufferSizeTestParam(Option.DEFAULT_THREAD_BUFFER_SIZE, 'b');
550 testCases.add(tc);
551
552 // negative example-based tests, each individual option below minimum size
553 tc = new TestCase("MemorySizeBelowMinNegative", false);
554 tc.setMemorySizeTestParam(Option.MIN_MEMORY_SIZE - 1, 'b');
555 testCases.add(tc);
556
557 tc = new TestCase("GlobalBufferSizeBelowMinNegative", false);
558 tc.setGlobalBufferSizeTestParam(Option.MIN_GLOBAL_BUFFER_SIZE - 1, 'b');
559 testCases.add(tc);
560
561 tc = new TestCase("BufferCountBelowMinNegative", false);
562 tc.setGlobalBufferCountTestParam(Option.MIN_GLOBAL_BUFFER_COUNT - 1, 'b');
563 testCases.add(tc);
564
565 tc = new TestCase("ThreadBufferSizeBelowMinNegative", false);
566 tc.setThreadBufferSizeTestParam(Option.MIN_THREAD_BUFFER_SIZE - 1, 'b');
567 testCases.add(tc);
568
569 // Memory size permutations
570 // a few single memorysize option for deduction
571 tc = new TestCase("MemorySizeValue1Positive", false);
572 tc.setMemorySizeTestParam(48128, 'k'); // 47mb
573 testCases.add(tc);
574
575 tc = new TestCase("MemorySizeValue2Positive", false);
576 tc.setMemorySizeTestParam(17391, 'k'); // 17808384 bytes
577 testCases.add(tc);
578
579 tc = new TestCase("MemorySizeValue3Positive", false);
580 tc.setMemorySizeTestParam(Option.MIN_MEMORY_SIZE + 17, 'b');
581 testCases.add(tc);
582
583 // positive example-based-tests, memory size combined with other options
584 tc = new TestCase("MemorySizeGlobalBufferSizePositive", false);
585 tc.setMemorySizeTestParam(14680064, 'b'); // 14mb
586 tc.setGlobalBufferSizeTestParam(720, 'k');
587 testCases.add(tc);
588
589 tc = new TestCase("MemorySizeGlobalBufferCountPositive", false);
590 tc.setMemorySizeTestParam(14674581, 'b'); // 14mb - 5483 bytes
591 tc.setGlobalBufferCountTestParam(17, 'b');
592 testCases.add(tc);
593
594 tc = new TestCase("MemorySizeThreadBufferSizePositive", false);
595 tc.setMemorySizeTestParam(14586853, 'b'); // 14mb - 93211 bytes
596 tc.setThreadBufferSizeTestParam(Option.DEFAULT_THREAD_BUFFER_SIZE, 'b');
597 testCases.add(tc);
598
599 tc = new TestCase("MemorySizeGlobalBufferSizeBufferCountPositive", false);
600 tc.setMemorySizeTestParam(12240, 'k');
601 tc.setGlobalBufferSizeTestParam(720, 'k'); // 720 k * 17 == 12240 k
602 tc.setGlobalBufferCountTestParam(17, 'b');
603 testCases.add(tc);
604
605 tc = new TestCase("MemorySizeGlobalBufferSizeBufferCountThreadBufferSizePositive", false);
606 tc.setMemorySizeTestParam(12240, 'k');
607 tc.setGlobalBufferSizeTestParam(720, 'k'); // 720 k * 17 == 12240 k
608 tc.setGlobalBufferCountTestParam(17, 'b');
609 tc.setThreadBufferSizeTestParam(600, 'k');
610 testCases.add(tc);
611
612 // negative example-based test, create an ambiguous situtation
613 tc = new TestCase("MemorySizeGlobalBufferSizeBufferCountAmbiguousNegative", false);
614 tc.setMemorySizeTestParam(12240, 'k');
615 tc.setGlobalBufferSizeTestParam(720, 'k'); // 720 k * 19 != 12240 k
616 tc.setGlobalBufferCountTestParam(19, 'b');
617 testCases.add(tc);
618
619 // Global buffer size permutations
620 tc = new TestCase("GlobalBufferSizeBufferCountPositive", false);
621 tc.setGlobalBufferSizeTestParam(917, 'k');
622 tc.setGlobalBufferCountTestParam(31, 'b');
623 testCases.add(tc);
624
625 tc = new TestCase("GlobalBufferSizeBufferCountThreadBufferSizePositive", false);
626 tc.setGlobalBufferSizeTestParam(917, 'k');
627 tc.setGlobalBufferCountTestParam(31, 'b');
628 tc.setThreadBufferSizeTestParam(760832, 'b'); // 743 k
629 testCases.add(tc);
630
631 // negative example-based test, let thread buffer size > global buffer size
632 tc = new TestCase("GlobalBufferSizeLessThanThreadBufferSizeNegative", false);
633 tc.setGlobalBufferSizeTestParam(917, 'k');
634 tc.setThreadBufferSizeTestParam(1317, 'k');
635 testCases.add(tc);
636
637 // explicitly specifying global buffer size and global buffer count must be gteq min memorysize
638 tc = new TestCase("GlobalBufferSizeTimesGlobalBufferCountLessThanMinMemorySizeNegative", false);
639 tc.setGlobalBufferSizeTestParam(67857, 'b');
640 tc.setGlobalBufferCountTestParam(3, 'b');
641 testCases.add(tc);
642
643 // absolute minimum size
644 tc = new TestCase("GlobalBufferSizeTimesGlobalBufferCountEqualToMinMemorySizePositive", false);
645 tc.setGlobalBufferSizeTestParam(64, 'k');
646 tc.setGlobalBufferCountTestParam(16, 'b');
647 testCases.add(tc);
648 }
649
650 public static void main(String[] args) throws Exception {
651 System.out.println("Testing " + testCases.size() + " number of testcases");
652 for (TestCase tc : testCases) {
653 Driver.runTestCase(tc);
654 }
655 }
656 }