0001: /**
0002: * Copyright (C) 2001-2004 France Telecom R&D
0003: *
0004: * This library is free software; you can redistribute it and/or
0005: * modify it under the terms of the GNU Lesser General Public
0006: * License as published by the Free Software Foundation; either
0007: * version 2 of the License, or (at your option) any later version.
0008: *
0009: * This library is distributed in the hope that it will be useful,
0010: * but WITHOUT ANY WARRANTY; without even the implied warranty of
0011: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
0012: * Lesser General Public License for more details.
0013: *
0014: * You should have received a copy of the GNU Lesser General Public
0015: * License along with this library; if not, write to the Free Software
0016: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
0017: */package org.objectweb.speedo.stress;
0018:
0019: import org.objectweb.speedo.pobjects.userid.IntUserId;
0020: import org.objectweb.util.monolog.api.BasicLevel;
0021:
0022: import javax.jdo.PersistenceManager;
0023: import javax.jdo.JDOFatalException;
0024:
0025: import junit.framework.TestSuite;
0026: import junit.textui.TestRunner;
0027:
0028: /**
0029: * Stresses the creation function of Speedo.
0030: *
0031: * @author P. Dechamboux
0032: */
0033: public class TestCreation extends StressHelper {
0034: private String CREATION = getLoggerName() + ".creation";
0035: private String STARTID = getLoggerName() + ".startid";
0036:
0037: public TestCreation(String s) {
0038: super (s);
0039: }
0040:
0041: protected String[] getClassNamesToInit() {
0042: return new String[] { IntUserId.class.getName() };
0043: }
0044:
0045: protected String getLoggerName() {
0046: return STRESS_LOG_NAME + ".TestCreation";
0047: }
0048:
0049: public static void main(String[] args) {
0050: TestRunner.run(new TestSuite(TestCreation.class));
0051: }
0052:
0053: class CreationCtx {
0054: int nbc;
0055: int startid;
0056:
0057: public CreationCtx(int _nbc, int _startid) {
0058: this .nbc = _nbc;
0059: this .startid = _startid;
0060: }
0061:
0062: public String toString() {
0063: return "nbCreation = " + nbc + " / startid = " + startid;
0064: }
0065: }
0066:
0067: protected void perform(Task task, int threadId, int txId,
0068: Object ctx, PerformResult res) {
0069: CreationCtx cc = (CreationCtx) ctx;
0070: final int nbCreation = cc.nbc;
0071: final int startId = cc.startid;
0072: PersistenceManager pm = getPM(task, threadId, txId);
0073: try {
0074: res.beginTest();
0075: beginTx(pm, task, threadId, txId);
0076: for (int no = 0; no < nbCreation; no++) {
0077: int oid = (txId * nbCreation) + no + startId;
0078: if (debug) {
0079: logger.log(BasicLevel.DEBUG, "Creating object "
0080: + oid);
0081: }
0082: IntUserId iui = new IntUserId(oid, "Obj No " + oid);
0083: pm.makePersistent(iui);
0084: }
0085: commitTx(pm, task, threadId, txId);
0086: res.endTest();
0087: } catch (JDOFatalException e) {
0088: rollbackOnException(pm, e, res, task, threadId, txId);
0089: } catch (Throwable e) {
0090: stopOnError(pm, e, res, task, threadId, txId);
0091: } finally {
0092: closePM(pm, threadId, txId, task, res);
0093: }
0094: }
0095:
0096: /**
0097: * Tests the creation of a lot of persistent objects, with interactive
0098: * setting of test parameteres (see file userconf/project.properties).
0099: */
0100: public void testInteractive() {
0101: if (interactive) {
0102: perform(Integer.getInteger(THREAD, 10).intValue(), Integer
0103: .getInteger(TX, 100).intValue(), Integer
0104: .getInteger(TIMEOUT, 1000000).intValue(),
0105: new CreationCtx(Integer.getInteger(CREATION, 1000)
0106: .intValue(), Integer.getInteger(STARTID, 0)
0107: .intValue()));
0108: }
0109: }
0110:
0111: /**
0112: * Tests 10 transactions where each of them creates 1 object using 1
0113: * thread.
0114: */
0115: public void testCreationTh1Tx10Cr1() {
0116: if (!interactive) {
0117: perform(1, 10, 1000000, new CreationCtx(1,
0118: getStartId(ID_Th1Tx10Cr1)));
0119: }
0120: }
0121:
0122: /**
0123: * Tests 100 transactions where each of them creates 1 object using 1
0124: * thread.
0125: */
0126: public void testCreationTh1Tx100Cr1() {
0127: if (!interactive) {
0128: perform(1, 100, 1000000, new CreationCtx(1,
0129: getStartId(ID_Th1Tx100Cr1)));
0130: }
0131: }
0132:
0133: /**
0134: * Tests 1.000 transactions where each of them creates 1 object using 1
0135: * thread.
0136: */
0137: public void testCreationTh1Tx1000Cr1() {
0138: if (!interactive) {
0139: perform(1, 1000, 1000000, new CreationCtx(1,
0140: getStartId(ID_Th1Tx1000Cr1)));
0141: }
0142: }
0143:
0144: /**
0145: * Tests 10.000 transactions where each of them creates 1 object using 1
0146: * thread.
0147: */
0148: public void testCreationTh1Tx10000Cr1() {
0149: if (!interactive) {
0150: perform(1, 10000, 1000000, new CreationCtx(1,
0151: getStartId(ID_Th1Tx10000Cr1)));
0152: }
0153: }
0154:
0155: /**
0156: * Tests 10 transactions where each of them creates 10 objects using 1
0157: * thread.
0158: */
0159: public void testCreationTh1Tx10Cr10() {
0160: if (!interactive) {
0161: perform(1, 10, 1000000, new CreationCtx(10,
0162: getStartId(ID_Th1Tx10Cr10)));
0163: }
0164: }
0165:
0166: /**
0167: * Tests 100 transactions where each of them creates 10 objects using 1
0168: * thread.
0169: */
0170: public void testCreationTh1Tx100Cr10() {
0171:
0172: if (!interactive) {
0173: perform(1, 100, 1000000, new CreationCtx(10,
0174: getStartId(ID_Th1Tx100Cr10)));
0175: }
0176: }
0177:
0178: /**
0179: * Tests 1.000 transactions where each of them creates 10 objects using 1
0180: * thread.
0181: */
0182: public void testCreationTh1Tx1000Cr10() {
0183:
0184: if (!interactive) {
0185: perform(1, 1000, 1000000, new CreationCtx(10,
0186: getStartId(ID_Th1Tx1000Cr10)));
0187: }
0188: }
0189:
0190: /**
0191: * Tests 10.000 transactions where each of them creates 10 objects using 1
0192: * thread.
0193: */
0194: public void testCreationTh1Tx10000Cr10() {
0195:
0196: if (!interactive) {
0197: perform(1, 10000, 1000000, new CreationCtx(10,
0198: getStartId(ID_Th1Tx10000Cr10)));
0199: }
0200: }
0201:
0202: /**
0203: * Tests 10 transactions where each of them creates 100 objects using 1
0204: * thread.
0205: */
0206: public void testCreationTh1Tx10Cr100() {
0207:
0208: if (!interactive) {
0209: perform(1, 10, 1000000, new CreationCtx(100,
0210: getStartId(ID_Th1Tx10Cr100)));
0211: }
0212: }
0213:
0214: /**
0215: * Tests 100 transactions where each of them creates 100 objects using 1
0216: * thread.
0217: */
0218: public void testCreationTh1Tx100Cr100() {
0219:
0220: if (!interactive) {
0221: perform(1, 100, 1000000, new CreationCtx(100,
0222: getStartId(ID_Th1Tx100Cr100)));
0223: }
0224: }
0225:
0226: /**
0227: * Tests 1.000 transactions where each of them creates 100 objects using 1
0228: * thread.
0229: */
0230: public void testCreationTh1Tx1000Cr100() {
0231:
0232: if (!interactive) {
0233: perform(1, 1000, 1000000, new CreationCtx(100,
0234: getStartId(ID_Th1Tx1000Cr100)));
0235: }
0236: }
0237:
0238: /**
0239: * Tests 10.000 transactions where each of them creates 100 objects using 1
0240: * thread.
0241: */
0242: public void testCreationTh1Tx10000Cr100() {
0243:
0244: if (!interactive) {
0245: perform(1, 10000, 1000000, new CreationCtx(100,
0246: getStartId(ID_Th1Tx10000Cr100)));
0247: }
0248: }
0249:
0250: /**
0251: * Tests 10 transactions where each of them creates 500 objects using 1
0252: * thread.
0253: */
0254: public void testCreationTh1Tx10Cr500() {
0255:
0256: if (!interactive) {
0257: perform(1, 10, 1000000, new CreationCtx(500,
0258: getStartId(ID_Th1Tx10Cr500)));
0259: }
0260: }
0261:
0262: /**
0263: * Tests 100 transactions where each of them creates 500 objects using 1
0264: * thread.
0265: */
0266: public void testCreationTh1Tx100Cr500() {
0267:
0268: if (!interactive) {
0269: perform(1, 100, 1000000, new CreationCtx(500,
0270: getStartId(ID_Th1Tx100Cr500)));
0271: }
0272: }
0273:
0274: /**
0275: * Tests 1.000 transactions where each of them creates 500 objects using 1
0276: * thread.
0277: */
0278: public void testCreationTh1Tx1000Cr500() {
0279:
0280: if (!interactive) {
0281: perform(1, 1000, 1000000, new CreationCtx(500,
0282: getStartId(ID_Th1Tx1000Cr500)));
0283: }
0284: }
0285:
0286: /**
0287: * Tests 10 transactions where each of them creates 1.000 objects using 1
0288: * thread.
0289: */
0290: public void testCreationTh1Tx10Cr1000() {
0291:
0292: if (!interactive) {
0293: perform(1, 10, 1000000, new CreationCtx(1000,
0294: getStartId(ID_Th1Tx10Cr1000)));
0295: }
0296: }
0297:
0298: /**
0299: * Tests 100 transactions where each of them creates 1.000 objects using 1
0300: * thread.
0301: */
0302: public void testCreationTh1Tx100Cr1000() {
0303:
0304: if (!interactive) {
0305: perform(1, 100, 1000000, new CreationCtx(1000,
0306: getStartId(ID_Th1Tx100Cr1000)));
0307: }
0308: }
0309:
0310: /**
0311: * Tests 1.000 transactions where each of them creates 1.000 objects using
0312: * 1 thread.
0313: */
0314: public void testCreationTh1Tx1000Cr1000() {
0315:
0316: if (!interactive) {
0317: perform(1, 1000, 1000000, new CreationCtx(1000,
0318: getStartId(ID_Th1Tx100Cr1000)));
0319: }
0320: }
0321:
0322: /**
0323: * Tests 10 transactions where each of them creates 2.000 objects using 1
0324: * thread.
0325: */
0326: public void testCreationTh1Tx10Cr2000() {
0327:
0328: if (!interactive) {
0329: perform(1, 10, 1000000, new CreationCtx(2000,
0330: getStartId(ID_Th1Tx10Cr2000)));
0331: }
0332: }
0333:
0334: /**
0335: * Tests 100 transactions where each of them creates 2.000 objects using 1
0336: * thread.
0337: */
0338: public void testCreationTh1Tx100Cr2000() {
0339:
0340: if (!interactive) {
0341: perform(1, 100, 1000000, new CreationCtx(2000,
0342: getStartId(ID_Th1Tx100Cr2000)));
0343: }
0344: }
0345:
0346: /**
0347: * Tests 1.000 transactions where each of them creates 2.000 objects using
0348: * 1 thread.
0349: */
0350: public void testCreationTh1Tx1000Cr2000() {
0351:
0352: if (!interactive) {
0353: perform(1, 1000, 1000000, new CreationCtx(2000,
0354: getStartId(ID_Th1Tx1000Cr2000)));
0355: }
0356: }
0357:
0358: /**
0359: * Tests 10 transactions where each of them creates 10.000 objects using 1
0360: * thread.
0361: */
0362: public void testCreationTh1Tx10Cr10000() {
0363: if (!interactive) {
0364: perform(1, 10, 1000000, new CreationCtx(10000,
0365: getStartId(ID_Th1Tx10Cr10000)));
0366: }
0367: }
0368:
0369: /**
0370: * Tests 100 transactions where each of them creates 10.000 objects using 1
0371: * thread.
0372: */
0373: public void testCreationTh1Tx100Cr10000() {
0374:
0375: if (!interactive) {
0376: perform(1, 100, 1000000, new CreationCtx(10000,
0377: getStartId(ID_Th1Tx100Cr10000)));
0378: }
0379: }
0380:
0381: ///////////////////////////////////////////////////////////////////////////
0382: ///////////////////////////////////////////////////////////////////////////
0383:
0384: /**
0385: * Tests 10 transactions where each of them creates 1 object using 2
0386: * thread.
0387: */
0388: public void testCreationTh2Tx10Cr1() {
0389:
0390: if (!interactive) {
0391: perform(2, 10, 1000000, new CreationCtx(1,
0392: getStartId(ID_Th2Tx10Cr1)));
0393: }
0394: }
0395:
0396: /**
0397: * Tests 100 transactions where each of them creates 1 object using 2
0398: * thread.
0399: */
0400: public void testCreationTh2Tx100Cr1() {
0401:
0402: if (!interactive) {
0403: perform(2, 100, 1000000, new CreationCtx(1,
0404: getStartId(ID_Th2Tx100Cr1)));
0405: }
0406: }
0407:
0408: /**
0409: * Tests 1.000 transactions where each of them creates 1 object using 2
0410: * thread.
0411: */
0412: public void testCreationTh2Tx1000Cr1() {
0413:
0414: if (!interactive) {
0415: perform(2, 1000, 1000000, new CreationCtx(1,
0416: getStartId(ID_Th2Tx1000Cr1)));
0417: }
0418: }
0419:
0420: /**
0421: * Tests 10.000 transactions where each of them creates 1 object using 2
0422: * thread.
0423: */
0424: public void testCreationTh2Tx10000Cr1() {
0425:
0426: if (!interactive) {
0427: perform(2, 10000, 1000000, new CreationCtx(1,
0428: getStartId(ID_Th2Tx10000Cr1)));
0429: }
0430: }
0431:
0432: /**
0433: * Tests 100.000 transactions where each of them creates 1 object using 2
0434: * thread.
0435: */
0436: public void testCreationTh2Tx100000Cr1() {
0437:
0438: if (!interactive) {
0439: perform(2, 100000, 1000000, new CreationCtx(1,
0440: getStartId(ID_Th2Tx100000Cr1)));
0441: }
0442: }
0443:
0444: /**
0445: * Tests 10 transactions where each of them creates 10 objects using 2
0446: * thread.
0447: */
0448: public void testCreationTh2Tx10Cr10() {
0449:
0450: if (!interactive) {
0451: perform(2, 10, 1000000, new CreationCtx(10,
0452: getStartId(ID_Th2Tx10Cr10)));
0453: }
0454: }
0455:
0456: /**
0457: * Tests 100 transactions where each of them creates 10 objects using 2
0458: * thread.
0459: */
0460: public void testCreationTh2Tx100Cr10() {
0461:
0462: if (!interactive) {
0463: perform(2, 100, 1000000, new CreationCtx(10,
0464: getStartId(ID_Th2Tx100Cr10)));
0465: }
0466: }
0467:
0468: /**
0469: * Tests 1.000 transactions where each of them creates 10 objects using 2
0470: * thread.
0471: */
0472: public void testCreationTh2Tx1000Cr10() {
0473:
0474: if (!interactive) {
0475: perform(2, 1000, 1000000, new CreationCtx(10,
0476: getStartId(ID_Th2Tx1000Cr10)));
0477: }
0478: }
0479:
0480: /**
0481: * Tests 10.000 transactions where each of them creates 10 objects using 2
0482: * thread.
0483: */
0484: public void testCreationTh2Tx10000Cr10() {
0485:
0486: if (!interactive) {
0487: perform(2, 10000, 1000000, new CreationCtx(10,
0488: getStartId(ID_Th2Tx10000Cr10)));
0489: }
0490: }
0491:
0492: /**
0493: * Tests 100.000 transactions where each of them creates 10 objects using 2
0494: * thread.
0495: */
0496: public void testCreationTh2Tx100000Cr10() {
0497:
0498: if (!interactive) {
0499: perform(2, 100000, 1000000, new CreationCtx(10,
0500: getStartId(ID_Th2Tx100000Cr10)));
0501: }
0502: }
0503:
0504: /**
0505: * Tests 10 transactions where each of them creates 100 objects using 2
0506: * thread.
0507: */
0508: public void testCreationTh2Tx10Cr100() {
0509:
0510: if (!interactive) {
0511: perform(2, 10, 1000000, new CreationCtx(100,
0512: getStartId(ID_Th2Tx10Cr100)));
0513: }
0514: }
0515:
0516: /**
0517: * Tests 100 transactions where each of them creates 100 objects using 2
0518: * thread.
0519: */
0520: public void testCreationTh2Tx100Cr100() {
0521:
0522: if (!interactive) {
0523: perform(2, 100, 1000000, new CreationCtx(100,
0524: getStartId(ID_Th2Tx100Cr100)));
0525: }
0526: }
0527:
0528: /**
0529: * Tests 1.000 transactions where each of them creates 100 objects using 2
0530: * thread.
0531: */
0532: public void testCreationTh2Tx1000Cr100() {
0533:
0534: if (!interactive) {
0535: perform(2, 1000, 1000000, new CreationCtx(100,
0536: getStartId(ID_Th2Tx1000Cr100)));
0537: }
0538: }
0539:
0540: /**
0541: * Tests 10.000 transactions where each of them creates 100 objects using 2
0542: * thread.
0543: */
0544: public void testCreationTh2Tx10000Cr100() {
0545:
0546: if (!interactive) {
0547: perform(2, 10000, 1000000, new CreationCtx(100,
0548: getStartId(ID_Th2Tx10000Cr100)));
0549: }
0550: }
0551:
0552: /**
0553: * Tests 10 transactions where each of them creates 500 objects using 2
0554: * thread.
0555: */
0556: public void testCreationTh2Tx10Cr500() {
0557:
0558: if (!interactive) {
0559: perform(2, 10, 1000000, new CreationCtx(500,
0560: getStartId(ID_Th2Tx10Cr500)));
0561: }
0562: }
0563:
0564: /**
0565: * Tests 100 transactions where each of them creates 500 objects using 2
0566: * thread.
0567: */
0568: public void testCreationTh2Tx100Cr500() {
0569:
0570: if (!interactive) {
0571: perform(2, 100, 1000000, new CreationCtx(500,
0572: getStartId(ID_Th2Tx100Cr500)));
0573: }
0574: }
0575:
0576: /**
0577: * Tests 1.000 transactions where each of them creates 500 objects using 2
0578: * thread.
0579: */
0580: public void testCreationTh2Tx1000Cr500() {
0581:
0582: if (!interactive) {
0583: perform(2, 1000, 1000000, new CreationCtx(500,
0584: getStartId(ID_Th2Tx1000Cr500)));
0585: }
0586: }
0587:
0588: /**
0589: * Tests 10 transactions where each of them creates 1.000 objects using 2
0590: * thread.
0591: */
0592: public void testCreationTh2Tx10Cr1000() {
0593:
0594: if (!interactive) {
0595: perform(2, 10, 1000000, new CreationCtx(1000,
0596: getStartId(ID_Th2Tx10Cr1000)));
0597: }
0598: }
0599:
0600: /**
0601: * Tests 100 transactions where each of them creates 1.000 objects using 2
0602: * thread.
0603: */
0604: public void testCreationTh2Tx100Cr1000() {
0605:
0606: if (!interactive) {
0607: perform(2, 100, 1000000, new CreationCtx(1000,
0608: getStartId(ID_Th2Tx100Cr1000)));
0609: }
0610: }
0611:
0612: /**
0613: * Tests 1.000 transactions where each of them creates 1.000 objects using
0614: * 1 thread.
0615: */
0616: public void testCreationTh2Tx1000Cr1000() {
0617:
0618: if (!interactive) {
0619: perform(2, 1000, 1000000, new CreationCtx(1000,
0620: getStartId(ID_Th2Tx100Cr1000)));
0621: }
0622: }
0623:
0624: /**
0625: * Tests 10 transactions where each of them creates 2.000 objects using 2
0626: * thread.
0627: */
0628: public void testCreationTh2Tx10Cr2000() {
0629:
0630: if (!interactive) {
0631: perform(2, 10, 1000000, new CreationCtx(2000,
0632: getStartId(ID_Th2Tx10Cr2000)));
0633: }
0634: }
0635:
0636: /**
0637: * Tests 100 transactions where each of them creates 2.000 objects using 2
0638: * thread.
0639: */
0640: public void testCreationTh2Tx100Cr2000() {
0641:
0642: if (!interactive) {
0643: perform(2, 100, 1000000, new CreationCtx(2000,
0644: getStartId(ID_Th2Tx100Cr2000)));
0645: }
0646: }
0647:
0648: /**
0649: * Tests 1.000 transactions where each of them creates 2.000 objects using
0650: * 1 thread.
0651: */
0652: public void testCreationTh2Tx1000Cr2000() {
0653:
0654: if (!interactive) {
0655: perform(2, 1000, 1000000, new CreationCtx(2000,
0656: getStartId(ID_Th2Tx1000Cr2000)));
0657: }
0658: }
0659:
0660: /**
0661: * Tests 10 transactions where each of them creates 10.000 objects using 2
0662: * thread.
0663: */
0664: public void testCreationTh2Tx10Cr10000() {
0665: if (!interactive) {
0666: perform(2, 10, 1000000, new CreationCtx(10000,
0667: getStartId(ID_Th2Tx10Cr10000)));
0668: }
0669: }
0670:
0671: /**
0672: * Tests 100 transactions where each of them creates 10.000 objects using 2
0673: * thread.
0674: */
0675: public void testCreationTh2Tx100Cr10000() {
0676:
0677: if (!interactive) {
0678: perform(2, 100, 1000000, new CreationCtx(10000,
0679: getStartId(ID_Th2Tx100Cr10000)));
0680: }
0681: }
0682:
0683: ///////////////////////////////////////////////////////////////////////////
0684: ///////////////////////////////////////////////////////////////////////////
0685:
0686: /**
0687: * Tests 10 transactions where each of them creates 1 object using 3
0688: * thread.
0689: */
0690: public void testCreationTh3Tx10Cr1() {
0691:
0692: if (!interactive) {
0693: perform(3, 10, 1000000, new CreationCtx(1,
0694: getStartId(ID_Th3Tx10Cr1)));
0695: }
0696: }
0697:
0698: /**
0699: * Tests 100 transactions where each of them creates 1 object using 3
0700: * thread.
0701: */
0702: public void testCreationTh3Tx100Cr1() {
0703:
0704: if (!interactive) {
0705: perform(3, 100, 1000000, new CreationCtx(1,
0706: getStartId(ID_Th3Tx100Cr1)));
0707: }
0708: }
0709:
0710: /**
0711: * Tests 1.000 transactions where each of them creates 1 object using 3
0712: * thread.
0713: */
0714: public void testCreationTh3Tx1000Cr1() {
0715:
0716: if (!interactive) {
0717: perform(3, 1000, 1000000, new CreationCtx(1,
0718: getStartId(ID_Th3Tx1000Cr1)));
0719: }
0720: }
0721:
0722: /**
0723: * Tests 10.000 transactions where each of them creates 1 object using 3
0724: * thread.
0725: */
0726: public void testCreationTh3Tx10000Cr1() {
0727:
0728: if (!interactive) {
0729: perform(3, 10000, 1000000, new CreationCtx(1,
0730: getStartId(ID_Th3Tx10000Cr1)));
0731: }
0732: }
0733:
0734: /**
0735: * Tests 100.000 transactions where each of them creates 1 object using 3
0736: * thread.
0737: */
0738: public void testCreationTh3Tx100000Cr1() {
0739:
0740: if (!interactive) {
0741: perform(3, 100000, 1000000, new CreationCtx(1,
0742: getStartId(ID_Th3Tx100000Cr1)));
0743: }
0744: }
0745:
0746: /**
0747: * Tests 10 transactions where each of them creates 10 objects using 3
0748: * thread.
0749: */
0750: public void testCreationTh3Tx10Cr10() {
0751:
0752: if (!interactive) {
0753: perform(3, 10, 1000000, new CreationCtx(10,
0754: getStartId(ID_Th3Tx10Cr10)));
0755: }
0756: }
0757:
0758: /**
0759: * Tests 100 transactions where each of them creates 10 objects using 3
0760: * thread.
0761: */
0762: public void testCreationTh3Tx100Cr10() {
0763:
0764: if (!interactive) {
0765: perform(3, 100, 1000000, new CreationCtx(10,
0766: getStartId(ID_Th3Tx100Cr10)));
0767: }
0768: }
0769:
0770: /**
0771: * Tests 1.000 transactions where each of them creates 10 objects using 3
0772: * thread.
0773: */
0774: public void testCreationTh3Tx1000Cr10() {
0775:
0776: if (!interactive) {
0777: perform(3, 1000, 1000000, new CreationCtx(10,
0778: getStartId(ID_Th3Tx1000Cr10)));
0779: }
0780: }
0781:
0782: /**
0783: * Tests 10.000 transactions where each of them creates 10 objects using 3
0784: * thread.
0785: */
0786: public void testCreationTh3Tx10000Cr10() {
0787:
0788: if (!interactive) {
0789: perform(3, 10000, 1000000, new CreationCtx(10,
0790: getStartId(ID_Th3Tx10000Cr10)));
0791: }
0792: }
0793:
0794: /**
0795: * Tests 100.000 transactions where each of them creates 10 objects using 3
0796: * thread.
0797: */
0798: public void testCreationTh3Tx100000Cr10() {
0799:
0800: if (!interactive) {
0801: perform(3, 100000, 1000000, new CreationCtx(10,
0802: getStartId(ID_Th3Tx100000Cr10)));
0803: }
0804: }
0805:
0806: /**
0807: * Tests 10 transactions where each of them creates 100 objects using 3
0808: * thread.
0809: */
0810: public void testCreationTh3Tx10Cr100() {
0811:
0812: if (!interactive) {
0813: perform(3, 10, 1000000, new CreationCtx(100,
0814: getStartId(ID_Th3Tx10Cr100)));
0815: }
0816: }
0817:
0818: /**
0819: * Tests 100 transactions where each of them creates 100 objects using 3
0820: * thread.
0821: */
0822: public void testCreationTh3Tx100Cr100() {
0823:
0824: if (!interactive) {
0825: perform(3, 100, 1000000, new CreationCtx(100,
0826: getStartId(ID_Th3Tx100Cr100)));
0827: }
0828: }
0829:
0830: /**
0831: * Tests 1.000 transactions where each of them creates 100 objects using 3
0832: * thread.
0833: */
0834: public void testCreationTh3Tx1000Cr100() {
0835:
0836: if (!interactive) {
0837: perform(3, 1000, 1000000, new CreationCtx(100,
0838: getStartId(ID_Th3Tx1000Cr100)));
0839: }
0840: }
0841:
0842: /**
0843: * Tests 10.000 transactions where each of them creates 100 objects using 3
0844: * thread.
0845: */
0846: public void testCreationTh3Tx10000Cr100() {
0847:
0848: if (!interactive) {
0849: perform(3, 10000, 1000000, new CreationCtx(100,
0850: getStartId(ID_Th3Tx10000Cr100)));
0851: }
0852: }
0853:
0854: /**
0855: * Tests 10 transactions where each of them creates 500 objects using 3
0856: * thread.
0857: */
0858: public void testCreationTh3Tx10Cr500() {
0859:
0860: if (!interactive) {
0861: perform(3, 10, 1000000, new CreationCtx(500,
0862: getStartId(ID_Th3Tx10Cr500)));
0863: }
0864: }
0865:
0866: /**
0867: * Tests 100 transactions where each of them creates 500 objects using 3
0868: * thread.
0869: */
0870: public void testCreationTh3Tx100Cr500() {
0871:
0872: if (!interactive) {
0873: perform(3, 100, 1000000, new CreationCtx(500,
0874: getStartId(ID_Th3Tx100Cr500)));
0875: }
0876: }
0877:
0878: /**
0879: * Tests 1.000 transactions where each of them creates 500 objects using 3
0880: * thread.
0881: */
0882: public void testCreationTh3Tx1000Cr500() {
0883:
0884: if (!interactive) {
0885: perform(3, 1000, 1000000, new CreationCtx(500,
0886: getStartId(ID_Th3Tx1000Cr500)));
0887: }
0888: }
0889:
0890: /**
0891: * Tests 10 transactions where each of them creates 1.000 objects using 3
0892: * thread.
0893: */
0894: public void testCreationTh3Tx10Cr1000() {
0895:
0896: if (!interactive) {
0897: perform(3, 10, 1000000, new CreationCtx(1000,
0898: getStartId(ID_Th3Tx10Cr1000)));
0899: }
0900: }
0901:
0902: /**
0903: * Tests 100 transactions where each of them creates 1.000 objects using 3
0904: * thread.
0905: */
0906: public void testCreationTh3Tx100Cr1000() {
0907:
0908: if (!interactive) {
0909: perform(3, 100, 1000000, new CreationCtx(1000,
0910: getStartId(ID_Th3Tx100Cr1000)));
0911: }
0912: }
0913:
0914: /**
0915: * Tests 1.000 transactions where each of them creates 1.000 objects using
0916: * 1 thread.
0917: */
0918: public void testCreationTh3Tx1000Cr1000() {
0919:
0920: if (!interactive) {
0921: perform(3, 1000, 1000000, new CreationCtx(1000,
0922: getStartId(ID_Th3Tx100Cr1000)));
0923: }
0924: }
0925:
0926: /**
0927: * Tests 10 transactions where each of them creates 2.000 objects using 3
0928: * thread.
0929: */
0930: public void testCreationTh3Tx10Cr2000() {
0931:
0932: if (!interactive) {
0933: perform(3, 10, 1000000, new CreationCtx(2000,
0934: getStartId(ID_Th3Tx10Cr2000)));
0935: }
0936: }
0937:
0938: /**
0939: * Tests 100 transactions where each of them creates 2.000 objects using 3
0940: * thread.
0941: */
0942: public void testCreationTh3Tx100Cr2000() {
0943:
0944: if (!interactive) {
0945: perform(3, 100, 1000000, new CreationCtx(2000,
0946: getStartId(ID_Th3Tx100Cr2000)));
0947: }
0948: }
0949:
0950: /**
0951: * Tests 1.000 transactions where each of them creates 2.000 objects using
0952: * 1 thread.
0953: */
0954: public void testCreationTh3Tx1000Cr2000() {
0955:
0956: if (!interactive) {
0957: perform(3, 1000, 1000000, new CreationCtx(2000,
0958: getStartId(ID_Th3Tx1000Cr2000)));
0959: }
0960: }
0961:
0962: /**
0963: * Tests 10 transactions where each of them creates 10.000 objects using 3
0964: * thread.
0965: */
0966: public void testCreationTh3Tx10Cr10000() {
0967: if (!interactive) {
0968: perform(3, 10, 1000000, new CreationCtx(10000,
0969: getStartId(ID_Th3Tx10Cr10000)));
0970: }
0971: }
0972:
0973: /**
0974: * Tests 100 transactions where each of them creates 10.000 objects using 3
0975: * thread.
0976: */
0977: public void testCreationTh3Tx100Cr10000() {
0978:
0979: if (!interactive) {
0980: perform(3, 100, 1000000, new CreationCtx(10000,
0981: getStartId(ID_Th3Tx100Cr10000)));
0982: }
0983: }
0984:
0985: ///////////////////////////////////////////////////////////////////////////
0986: ///////////////////////////////////////////////////////////////////////////
0987:
0988: /**
0989: * Tests 10 transactions where each of them creates 1 object using 4
0990: * thread.
0991: */
0992: public void testCreationTh4Tx10Cr1() {
0993:
0994: if (!interactive) {
0995: perform(4, 10, 1000000, new CreationCtx(1,
0996: getStartId(ID_Th4Tx10Cr1)));
0997: }
0998: }
0999:
1000: /**
1001: * Tests 100 transactions where each of them creates 1 object using 4
1002: * thread.
1003: */
1004: public void testCreationTh4Tx100Cr1() {
1005:
1006: if (!interactive) {
1007: perform(4, 100, 1000000, new CreationCtx(1,
1008: getStartId(ID_Th4Tx100Cr1)));
1009: }
1010: }
1011:
1012: /**
1013: * Tests 1.000 transactions where each of them creates 1 object using 4
1014: * thread.
1015: */
1016: public void testCreationTh4Tx1000Cr1() {
1017:
1018: if (!interactive) {
1019: perform(4, 1000, 1000000, new CreationCtx(1,
1020: getStartId(ID_Th4Tx1000Cr1)));
1021: }
1022: }
1023:
1024: /**
1025: * Tests 10.000 transactions where each of them creates 1 object using 4
1026: * thread.
1027: */
1028: public void testCreationTh4Tx10000Cr1() {
1029:
1030: if (!interactive) {
1031: perform(4, 10000, 1000000, new CreationCtx(1,
1032: getStartId(ID_Th4Tx10000Cr1)));
1033: }
1034: }
1035:
1036: /**
1037: * Tests 100.000 transactions where each of them creates 1 object using 4
1038: * thread.
1039: */
1040: public void testCreationTh4Tx100000Cr1() {
1041:
1042: if (!interactive) {
1043: perform(4, 100000, 1000000, new CreationCtx(1,
1044: getStartId(ID_Th4Tx100000Cr1)));
1045: }
1046: }
1047:
1048: /**
1049: * Tests 10 transactions where each of them creates 10 objects using 4
1050: * thread.
1051: */
1052: public void testCreationTh4Tx10Cr10() {
1053:
1054: if (!interactive) {
1055: perform(4, 10, 1000000, new CreationCtx(10,
1056: getStartId(ID_Th4Tx10Cr10)));
1057: }
1058: }
1059:
1060: /**
1061: * Tests 100 transactions where each of them creates 10 objects using 4
1062: * thread.
1063: */
1064: public void testCreationTh4Tx100Cr10() {
1065:
1066: if (!interactive) {
1067: perform(4, 100, 1000000, new CreationCtx(10,
1068: getStartId(ID_Th4Tx100Cr10)));
1069: }
1070: }
1071:
1072: /**
1073: * Tests 1.000 transactions where each of them creates 10 objects using 4
1074: * thread.
1075: */
1076: public void testCreationTh4Tx1000Cr10() {
1077:
1078: if (!interactive) {
1079: perform(4, 1000, 1000000, new CreationCtx(10,
1080: getStartId(ID_Th4Tx1000Cr10)));
1081: }
1082: }
1083:
1084: /**
1085: * Tests 10.000 transactions where each of them creates 10 objects using 4
1086: * thread.
1087: */
1088: public void testCreationTh4Tx10000Cr10() {
1089:
1090: if (!interactive) {
1091: perform(4, 10000, 1000000, new CreationCtx(10,
1092: getStartId(ID_Th4Tx10000Cr10)));
1093: }
1094: }
1095:
1096: /**
1097: * Tests 100.000 transactions where each of them creates 10 objects using 4
1098: * thread.
1099: */
1100: public void testCreationTh4Tx100000Cr10() {
1101:
1102: if (!interactive) {
1103: perform(4, 100000, 1000000, new CreationCtx(10,
1104: getStartId(ID_Th4Tx100000Cr10)));
1105: }
1106: }
1107:
1108: /**
1109: * Tests 10 transactions where each of them creates 100 objects using 4
1110: * thread.
1111: */
1112: public void testCreationTh4Tx10Cr100() {
1113:
1114: if (!interactive) {
1115: perform(4, 10, 1000000, new CreationCtx(100,
1116: getStartId(ID_Th4Tx10Cr100)));
1117: }
1118: }
1119:
1120: /**
1121: * Tests 100 transactions where each of them creates 100 objects using 4
1122: * thread.
1123: */
1124: public void testCreationTh4Tx100Cr100() {
1125:
1126: if (!interactive) {
1127: perform(4, 100, 1000000, new CreationCtx(100,
1128: getStartId(ID_Th4Tx100Cr100)));
1129: }
1130: }
1131:
1132: /**
1133: * Tests 1.000 transactions where each of them creates 100 objects using 4
1134: * thread.
1135: */
1136: public void testCreationTh4Tx1000Cr100() {
1137:
1138: if (!interactive) {
1139: perform(4, 1000, 1000000, new CreationCtx(100,
1140: getStartId(ID_Th4Tx1000Cr100)));
1141: }
1142: }
1143:
1144: /**
1145: * Tests 10.000 transactions where each of them creates 100 objects using 4
1146: * thread.
1147: */
1148: public void testCreationTh4Tx10000Cr100() {
1149:
1150: if (!interactive) {
1151: perform(4, 10000, 1000000, new CreationCtx(100,
1152: getStartId(ID_Th4Tx10000Cr100)));
1153: }
1154: }
1155:
1156: /**
1157: * Tests 10 transactions where each of them creates 500 objects using 4
1158: * thread.
1159: */
1160: public void testCreationTh4Tx10Cr500() {
1161:
1162: if (!interactive) {
1163: perform(4, 10, 1000000, new CreationCtx(500,
1164: getStartId(ID_Th4Tx10Cr500)));
1165: }
1166: }
1167:
1168: /**
1169: * Tests 100 transactions where each of them creates 500 objects using 4
1170: * thread.
1171: */
1172: public void testCreationTh4Tx100Cr500() {
1173:
1174: if (!interactive) {
1175: perform(4, 100, 1000000, new CreationCtx(500,
1176: getStartId(ID_Th4Tx100Cr500)));
1177: }
1178: }
1179:
1180: /**
1181: * Tests 1.000 transactions where each of them creates 500 objects using 4
1182: * thread.
1183: */
1184: public void testCreationTh4Tx1000Cr500() {
1185:
1186: if (!interactive) {
1187: perform(4, 1000, 1000000, new CreationCtx(500,
1188: getStartId(ID_Th4Tx1000Cr500)));
1189: }
1190: }
1191:
1192: /**
1193: * Tests 10 transactions where each of them creates 1.000 objects using 4
1194: * thread.
1195: */
1196: public void testCreationTh4Tx10Cr1000() {
1197:
1198: if (!interactive) {
1199: perform(4, 10, 1000000, new CreationCtx(1000,
1200: getStartId(ID_Th4Tx10Cr1000)));
1201: }
1202: }
1203:
1204: /**
1205: * Tests 100 transactions where each of them creates 1.000 objects using 4
1206: * thread.
1207: */
1208: public void testCreationTh4Tx100Cr1000() {
1209:
1210: if (!interactive) {
1211: perform(4, 100, 1000000, new CreationCtx(1000,
1212: getStartId(ID_Th4Tx100Cr1000)));
1213: }
1214: }
1215:
1216: /**
1217: * Tests 1.000 transactions where each of them creates 1.000 objects using
1218: * 1 thread.
1219: */
1220: public void testCreationTh4Tx1000Cr1000() {
1221:
1222: if (!interactive) {
1223: perform(4, 1000, 1000000, new CreationCtx(1000,
1224: getStartId(ID_Th4Tx100Cr1000)));
1225: }
1226: }
1227:
1228: /**
1229: * Tests 10 transactions where each of them creates 2.000 objects using 4
1230: * thread.
1231: */
1232: public void testCreationTh4Tx10Cr2000() {
1233:
1234: if (!interactive) {
1235: perform(4, 10, 1000000, new CreationCtx(2000,
1236: getStartId(ID_Th4Tx10Cr2000)));
1237: }
1238: }
1239:
1240: /**
1241: * Tests 100 transactions where each of them creates 2.000 objects using 4
1242: * thread.
1243: */
1244: public void testCreationTh4Tx100Cr2000() {
1245:
1246: if (!interactive) {
1247: perform(4, 100, 1000000, new CreationCtx(2000,
1248: getStartId(ID_Th4Tx100Cr2000)));
1249: }
1250: }
1251:
1252: /**
1253: * Tests 1.000 transactions where each of them creates 2.000 objects using
1254: * 1 thread.
1255: */
1256: public void testCreationTh4Tx1000Cr2000() {
1257:
1258: if (!interactive) {
1259: perform(4, 1000, 1000000, new CreationCtx(2000,
1260: getStartId(ID_Th4Tx1000Cr2000)));
1261: }
1262: }
1263:
1264: /**
1265: * Tests 10 transactions where each of them creates 10.000 objects using 4
1266: * thread.
1267: */
1268: public void testCreationTh4Tx10Cr10000() {
1269: if (!interactive) {
1270: perform(4, 10, 1000000, new CreationCtx(10000,
1271: getStartId(ID_Th4Tx10Cr10000)));
1272: }
1273: }
1274:
1275: /**
1276: * Tests 100 transactions where each of them creates 10.000 objects using 4
1277: * thread.
1278: */
1279: public void testCreationTh4Tx100Cr10000() {
1280:
1281: if (!interactive) {
1282: perform(4, 100, 1000000, new CreationCtx(10000,
1283: getStartId(ID_Th4Tx100Cr10000)));
1284: }
1285: }
1286:
1287: ///////////////////////////////////////////////////////////////////////////
1288: ///////////////////////////////////////////////////////////////////////////
1289:
1290: /**
1291: * Tests 10 transactions where each of them creates 1 object using 10
1292: * thread.
1293: */
1294: public void testCreationTh10Tx10Cr1() {
1295:
1296: if (!interactive) {
1297: perform(10, 10, 1000000, new CreationCtx(1,
1298: getStartId(ID_Th10Tx10Cr1)));
1299: }
1300: }
1301:
1302: /**
1303: * Tests 100 transactions where each of them creates 1 object using 10
1304: * thread.
1305: */
1306: public void testCreationTh10Tx100Cr1() {
1307:
1308: if (!interactive) {
1309: perform(10, 100, 1000000, new CreationCtx(1,
1310: getStartId(ID_Th10Tx100Cr1)));
1311: }
1312: }
1313:
1314: /**
1315: * Tests 1.000 transactions where each of them creates 1 object using 10
1316: * thread.
1317: */
1318: public void testCreationTh10Tx1000Cr1() {
1319:
1320: if (!interactive) {
1321: perform(10, 1000, 1000000, new CreationCtx(1,
1322: getStartId(ID_Th10Tx1000Cr1)));
1323: }
1324: }
1325:
1326: /**
1327: * Tests 10.000 transactions where each of them creates 1 object using 10
1328: * thread.
1329: */
1330: public void testCreationTh10Tx10000Cr1() {
1331:
1332: if (!interactive) {
1333: perform(10, 10000, 1000000, new CreationCtx(1,
1334: getStartId(ID_Th10Tx10000Cr1)));
1335: }
1336: }
1337:
1338: /**
1339: * Tests 100.000 transactions where each of them creates 1 object using 10
1340: * thread.
1341: */
1342: public void testCreationTh10Tx100000Cr1() {
1343:
1344: if (!interactive) {
1345: perform(10, 100000, 1000000, new CreationCtx(1,
1346: getStartId(ID_Th10Tx100000Cr1)));
1347: }
1348: }
1349:
1350: /**
1351: * Tests 10 transactions where each of them creates 10 objects using 10
1352: * thread.
1353: */
1354: public void testCreationTh10Tx10Cr10() {
1355:
1356: if (!interactive) {
1357: perform(10, 10, 1000000, new CreationCtx(10,
1358: getStartId(ID_Th10Tx10Cr10)));
1359: }
1360: }
1361:
1362: /**
1363: * Tests 100 transactions where each of them creates 10 objects using 10
1364: * thread.
1365: */
1366: public void testCreationTh10Tx100Cr10() {
1367:
1368: if (!interactive) {
1369: perform(10, 100, 1000000, new CreationCtx(10,
1370: getStartId(ID_Th10Tx100Cr10)));
1371: }
1372: }
1373:
1374: /**
1375: * Tests 1.000 transactions where each of them creates 10 objects using 10
1376: * thread.
1377: */
1378: public void testCreationTh10Tx1000Cr10() {
1379:
1380: if (!interactive) {
1381: perform(10, 1000, 1000000, new CreationCtx(10,
1382: getStartId(ID_Th10Tx1000Cr10)));
1383: }
1384: }
1385:
1386: /**
1387: * Tests 10.000 transactions where each of them creates 10 objects using 10
1388: * thread.
1389: */
1390: public void testCreationTh10Tx10000Cr10() {
1391:
1392: if (!interactive) {
1393: perform(10, 10000, 1000000, new CreationCtx(10,
1394: getStartId(ID_Th10Tx10000Cr10)));
1395: }
1396: }
1397:
1398: /**
1399: * Tests 100.000 transactions where each of them creates 10 objects using 10
1400: * thread.
1401: */
1402: public void testCreationTh10Tx100000Cr10() {
1403:
1404: if (!interactive) {
1405: perform(10, 100000, 1000000, new CreationCtx(10,
1406: getStartId(ID_Th10Tx100000Cr10)));
1407: }
1408: }
1409:
1410: /**
1411: * Tests 10 transactions where each of them creates 100 objects using 10
1412: * thread.
1413: */
1414: public void testCreationTh10Tx10Cr100() {
1415:
1416: if (!interactive) {
1417: perform(10, 10, 1000000, new CreationCtx(100,
1418: getStartId(ID_Th10Tx10Cr100)));
1419: }
1420: }
1421:
1422: /**
1423: * Tests 100 transactions where each of them creates 100 objects using 10
1424: * thread.
1425: */
1426: public void testCreationTh10Tx100Cr100() {
1427:
1428: if (!interactive) {
1429: perform(10, 100, 1000000, new CreationCtx(100,
1430: getStartId(ID_Th10Tx100Cr100)));
1431: }
1432: }
1433:
1434: /**
1435: * Tests 1.000 transactions where each of them creates 100 objects using 10
1436: * thread.
1437: */
1438: public void testCreationTh10Tx1000Cr100() {
1439:
1440: if (!interactive) {
1441: perform(10, 1000, 1000000, new CreationCtx(100,
1442: getStartId(ID_Th10Tx1000Cr100)));
1443: }
1444: }
1445:
1446: /**
1447: * Tests 10.000 transactions where each of them creates 100 objects using 10
1448: * thread.
1449: */
1450: public void testCreationTh10Tx10000Cr100() {
1451:
1452: if (!interactive) {
1453: perform(10, 10000, 1000000, new CreationCtx(100,
1454: getStartId(ID_Th10Tx10000Cr100)));
1455: }
1456: }
1457:
1458: /**
1459: * Tests 10 transactions where each of them creates 500 objects using 10
1460: * thread.
1461: */
1462: public void testCreationTh10Tx10Cr500() {
1463:
1464: if (!interactive) {
1465: perform(10, 10, 1000000, new CreationCtx(500,
1466: getStartId(ID_Th10Tx10Cr500)));
1467: }
1468: }
1469:
1470: /**
1471: * Tests 100 transactions where each of them creates 500 objects using 10
1472: * thread.
1473: */
1474: public void testCreationTh10Tx100Cr500() {
1475:
1476: if (!interactive) {
1477: perform(10, 100, 1000000, new CreationCtx(500,
1478: getStartId(ID_Th10Tx100Cr500)));
1479: }
1480: }
1481:
1482: /**
1483: * Tests 1.000 transactions where each of them creates 500 objects using 10
1484: * thread.
1485: */
1486: public void testCreationTh10Tx1000Cr500() {
1487:
1488: if (!interactive) {
1489: perform(10, 1000, 1000000, new CreationCtx(500,
1490: getStartId(ID_Th10Tx1000Cr500)));
1491: }
1492: }
1493:
1494: /**
1495: * Tests 10 transactions where each of them creates 1.000 objects using 10
1496: * thread.
1497: */
1498: public void testCreationTh10Tx10Cr1000() {
1499:
1500: if (!interactive) {
1501: perform(10, 10, 1000000, new CreationCtx(1000,
1502: getStartId(ID_Th10Tx10Cr1000)));
1503: }
1504: }
1505:
1506: /**
1507: * Tests 100 transactions where each of them creates 1.000 objects using 10
1508: * thread.
1509: */
1510: public void testCreationTh10Tx100Cr1000() {
1511:
1512: if (!interactive) {
1513: perform(10, 100, 1000000, new CreationCtx(1000,
1514: getStartId(ID_Th10Tx100Cr1000)));
1515: }
1516: }
1517:
1518: /**
1519: * Tests 1.000 transactions where each of them creates 1.000 objects using
1520: * 1 thread.
1521: */
1522: public void testCreationTh10Tx1000Cr1000() {
1523:
1524: if (!interactive) {
1525: perform(10, 1000, 1000000, new CreationCtx(1000,
1526: getStartId(ID_Th10Tx100Cr1000)));
1527: }
1528: }
1529:
1530: /**
1531: * Tests 10 transactions where each of them creates 2.000 objects using 10
1532: * thread.
1533: */
1534: public void testCreationTh10Tx10Cr2000() {
1535:
1536: if (!interactive) {
1537: perform(10, 10, 1000000, new CreationCtx(2000,
1538: getStartId(ID_Th10Tx10Cr2000)));
1539: }
1540: }
1541:
1542: /**
1543: * Tests 100 transactions where each of them creates 2.000 objects using 10
1544: * thread.
1545: */
1546: public void testCreationTh10Tx100Cr2000() {
1547:
1548: if (!interactive) {
1549: perform(10, 100, 1000000, new CreationCtx(2000,
1550: getStartId(ID_Th10Tx100Cr2000)));
1551: }
1552: }
1553:
1554: /**
1555: * Tests 1.000 transactions where each of them creates 2.000 objects using
1556: * 1 thread.
1557: */
1558: public void testCreationTh10Tx1000Cr2000() {
1559:
1560: if (!interactive) {
1561: perform(10, 1000, 1000000, new CreationCtx(2000,
1562: getStartId(ID_Th10Tx1000Cr2000)));
1563: }
1564: }
1565:
1566: /**
1567: * Tests 10 transactions where each of them creates 10.000 objects using 10
1568: * thread.
1569: */
1570: public void testCreationTh10Tx10Cr10000() {
1571:
1572: if (!interactive) {
1573: perform(10, 10, 1000000, new CreationCtx(10000,
1574: getStartId(ID_Th10Tx10Cr10000)));
1575: }
1576: }
1577:
1578: /**
1579: * Tests 100 transactions where each of them creates 10.000 objects using 10
1580: * thread.
1581: */
1582: public void testCreationTh10Tx100Cr10000() {
1583:
1584: if (!interactive) {
1585: perform(10, 100, 1000000, new CreationCtx(10000,
1586: getStartId(ID_Th10Tx100Cr10000)));
1587: }
1588: }
1589:
1590: }
|