/**
* Copyright (C) 2001-2004 France Telecom R&D
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
package org.objectweb.speedo.stress;
import org.objectweb.speedo.pobjects.userid.IntUserId;
import org.objectweb.util.monolog.api.BasicLevel;
import javax.jdo.PersistenceManager;
import javax.jdo.JDOFatalException;
import junit.framework.TestSuite;
import junit.textui.TestRunner;
/**
* Stresses the creation function of Speedo.
*
* @author P. Dechamboux
*/
public class TestCreation extends StressHelper {
private String CREATION = getLoggerName() + ".creation";
private String STARTID = getLoggerName() + ".startid";
public TestCreation(String s) {
super(s);
}
protected String[] getClassNamesToInit() {
return new String[] {IntUserId.class.getName()};
}
protected String getLoggerName() {
return STRESS_LOG_NAME + ".TestCreation";
}
public static void main(String[] args) {
TestRunner.run(new TestSuite(TestCreation.class));
}
class CreationCtx {
int nbc;
int startid;
public CreationCtx(int _nbc, int _startid) {
this.nbc = _nbc;
this.startid = _startid;
}
public String toString() {
return "nbCreation = " + nbc + " / startid = " + startid;
}
}
protected void perform(Task task, int threadId, int txId, Object ctx, PerformResult res) {
CreationCtx cc = (CreationCtx) ctx;
final int nbCreation = cc.nbc;
final int startId = cc.startid;
PersistenceManager pm = getPM(task, threadId,txId);
try {
res.beginTest();
beginTx(pm, task, threadId, txId);
for (int no = 0; no < nbCreation; no++) {
int oid = (txId * nbCreation) + no + startId;
if (debug) {
logger.log(BasicLevel.DEBUG, "Creating object " + oid);
}
IntUserId iui = new IntUserId(oid, "Obj No " + oid);
pm.makePersistent(iui);
}
commitTx(pm, task, threadId, txId);
res.endTest();
} catch (JDOFatalException e) {
rollbackOnException(pm, e, res, task, threadId, txId);
} catch (Throwable e) {
stopOnError(pm, e, res, task, threadId, txId);
} finally {
closePM(pm, threadId, txId, task, res);
}
}
/**
* Tests the creation of a lot of persistent objects, with interactive
* setting of test parameteres (see file userconf/project.properties).
*/
public void testInteractive() {
if (interactive) {
perform(Integer.getInteger(THREAD, 10).intValue(),
Integer.getInteger(TX, 100).intValue(),
Integer.getInteger(TIMEOUT, 1000000).intValue(),
new CreationCtx(
Integer.getInteger(CREATION, 1000).intValue(),
Integer.getInteger(STARTID, 0).intValue()));
}
}
/**
* Tests 10 transactions where each of them creates 1 object using 1
* thread.
*/
public void testCreationTh1Tx10Cr1() {
if (!interactive) {
perform(1, 10, 1000000, new CreationCtx(1, getStartId(ID_Th1Tx10Cr1)));
}
}
/**
* Tests 100 transactions where each of them creates 1 object using 1
* thread.
*/
public void testCreationTh1Tx100Cr1() {
if (!interactive) {
perform(1, 100, 1000000, new CreationCtx(1, getStartId(ID_Th1Tx100Cr1)));
}
}
/**
* Tests 1.000 transactions where each of them creates 1 object using 1
* thread.
*/
public void testCreationTh1Tx1000Cr1() {
if (!interactive) {
perform(1, 1000, 1000000, new CreationCtx(1, getStartId(ID_Th1Tx1000Cr1)));
}
}
/**
* Tests 10.000 transactions where each of them creates 1 object using 1
* thread.
*/
public void testCreationTh1Tx10000Cr1() {
if (!interactive) {
perform(1, 10000, 1000000, new CreationCtx(1, getStartId(ID_Th1Tx10000Cr1)));
}
}
/**
* Tests 10 transactions where each of them creates 10 objects using 1
* thread.
*/
public void testCreationTh1Tx10Cr10() {
if (!interactive) {
perform(1, 10, 1000000, new CreationCtx(10, getStartId(ID_Th1Tx10Cr10)));
}
}
/**
* Tests 100 transactions where each of them creates 10 objects using 1
* thread.
*/
public void testCreationTh1Tx100Cr10() {
if (!interactive) {
perform(1, 100, 1000000, new CreationCtx(10, getStartId(ID_Th1Tx100Cr10)));
}
}
/**
* Tests 1.000 transactions where each of them creates 10 objects using 1
* thread.
*/
public void testCreationTh1Tx1000Cr10() {
if (!interactive) {
perform(1, 1000, 1000000, new CreationCtx(10, getStartId(ID_Th1Tx1000Cr10)));
}
}
/**
* Tests 10.000 transactions where each of them creates 10 objects using 1
* thread.
*/
public void testCreationTh1Tx10000Cr10() {
if (!interactive) {
perform(1, 10000, 1000000, new CreationCtx(10, getStartId(ID_Th1Tx10000Cr10)));
}
}
/**
* Tests 10 transactions where each of them creates 100 objects using 1
* thread.
*/
public void testCreationTh1Tx10Cr100() {
if (!interactive) {
perform(1, 10, 1000000, new CreationCtx(100, getStartId(ID_Th1Tx10Cr100)));
}
}
/**
* Tests 100 transactions where each of them creates 100 objects using 1
* thread.
*/
public void testCreationTh1Tx100Cr100() {
if (!interactive) {
perform(1, 100, 1000000, new CreationCtx(100, getStartId(ID_Th1Tx100Cr100)));
}
}
/**
* Tests 1.000 transactions where each of them creates 100 objects using 1
* thread.
*/
public void testCreationTh1Tx1000Cr100() {
if (!interactive) {
perform(1, 1000, 1000000, new CreationCtx(100, getStartId(ID_Th1Tx1000Cr100)));
}
}
/**
* Tests 10.000 transactions where each of them creates 100 objects using 1
* thread.
*/
public void testCreationTh1Tx10000Cr100() {
if (!interactive) {
perform(1, 10000, 1000000, new CreationCtx(100, getStartId(ID_Th1Tx10000Cr100)));
}
}
/**
* Tests 10 transactions where each of them creates 500 objects using 1
* thread.
*/
public void testCreationTh1Tx10Cr500() {
if (!interactive) {
perform(1, 10, 1000000, new CreationCtx(500, getStartId(ID_Th1Tx10Cr500)));
}
}
/**
* Tests 100 transactions where each of them creates 500 objects using 1
* thread.
*/
public void testCreationTh1Tx100Cr500() {
if (!interactive) {
perform(1, 100, 1000000, new CreationCtx(500, getStartId(ID_Th1Tx100Cr500)));
}
}
/**
* Tests 1.000 transactions where each of them creates 500 objects using 1
* thread.
*/
public void testCreationTh1Tx1000Cr500() {
if (!interactive) {
perform(1, 1000, 1000000, new CreationCtx(500, getStartId(ID_Th1Tx1000Cr500)));
}
}
/**
* Tests 10 transactions where each of them creates 1.000 objects using 1
* thread.
*/
public void testCreationTh1Tx10Cr1000() {
if (!interactive) {
perform(1, 10, 1000000, new CreationCtx(1000, getStartId(ID_Th1Tx10Cr1000)));
}
}
/**
* Tests 100 transactions where each of them creates 1.000 objects using 1
* thread.
*/
public void testCreationTh1Tx100Cr1000() {
if (!interactive) {
perform(1, 100, 1000000, new CreationCtx(1000, getStartId(ID_Th1Tx100Cr1000)));
}
}
/**
* Tests 1.000 transactions where each of them creates 1.000 objects using
* 1 thread.
*/
public void testCreationTh1Tx1000Cr1000() {
if (!interactive) {
perform(1, 1000, 1000000, new CreationCtx(1000, getStartId(ID_Th1Tx100Cr1000)));
}
}
/**
* Tests 10 transactions where each of them creates 2.000 objects using 1
* thread.
*/
public void testCreationTh1Tx10Cr2000() {
if (!interactive) {
perform(1, 10, 1000000, new CreationCtx(2000, getStartId(ID_Th1Tx10Cr2000)));
}
}
/**
* Tests 100 transactions where each of them creates 2.000 objects using 1
* thread.
*/
public void testCreationTh1Tx100Cr2000() {
if (!interactive) {
perform(1, 100, 1000000, new CreationCtx(2000, getStartId(ID_Th1Tx100Cr2000)));
}
}
/**
* Tests 1.000 transactions where each of them creates 2.000 objects using
* 1 thread.
*/
public void testCreationTh1Tx1000Cr2000() {
if (!interactive) {
perform(1, 1000, 1000000, new CreationCtx(2000, getStartId(ID_Th1Tx1000Cr2000)));
}
}
/**
* Tests 10 transactions where each of them creates 10.000 objects using 1
* thread.
*/
public void testCreationTh1Tx10Cr10000() {
if (!interactive) {
perform(1, 10, 1000000, new CreationCtx(10000, getStartId(ID_Th1Tx10Cr10000)));
}
}
/**
* Tests 100 transactions where each of them creates 10.000 objects using 1
* thread.
*/
public void testCreationTh1Tx100Cr10000() {
if (!interactive) {
perform(1, 100, 1000000, new CreationCtx(10000, getStartId(ID_Th1Tx100Cr10000)));
}
}
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
/**
* Tests 10 transactions where each of them creates 1 object using 2
* thread.
*/
public void testCreationTh2Tx10Cr1() {
if (!interactive) {
perform(2, 10, 1000000, new CreationCtx(1, getStartId(ID_Th2Tx10Cr1)));
}
}
/**
* Tests 100 transactions where each of them creates 1 object using 2
* thread.
*/
public void testCreationTh2Tx100Cr1() {
if (!interactive) {
perform(2, 100, 1000000, new CreationCtx(1, getStartId(ID_Th2Tx100Cr1)));
}
}
/**
* Tests 1.000 transactions where each of them creates 1 object using 2
* thread.
*/
public void testCreationTh2Tx1000Cr1() {
if (!interactive) {
perform(2, 1000, 1000000, new CreationCtx(1, getStartId(ID_Th2Tx1000Cr1)));
}
}
/**
* Tests 10.000 transactions where each of them creates 1 object using 2
* thread.
*/
public void testCreationTh2Tx10000Cr1() {
if (!interactive) {
perform(2, 10000, 1000000, new CreationCtx(1, getStartId(ID_Th2Tx10000Cr1)));
}
}
/**
* Tests 100.000 transactions where each of them creates 1 object using 2
* thread.
*/
public void testCreationTh2Tx100000Cr1() {
if (!interactive) {
perform(2, 100000, 1000000, new CreationCtx(1, getStartId(ID_Th2Tx100000Cr1)));
}
}
/**
* Tests 10 transactions where each of them creates 10 objects using 2
* thread.
*/
public void testCreationTh2Tx10Cr10() {
if (!interactive) {
perform(2, 10, 1000000, new CreationCtx(10, getStartId(ID_Th2Tx10Cr10)));
}
}
/**
* Tests 100 transactions where each of them creates 10 objects using 2
* thread.
*/
public void testCreationTh2Tx100Cr10() {
if (!interactive) {
perform(2, 100, 1000000, new CreationCtx(10, getStartId(ID_Th2Tx100Cr10)));
}
}
/**
* Tests 1.000 transactions where each of them creates 10 objects using 2
* thread.
*/
public void testCreationTh2Tx1000Cr10() {
if (!interactive) {
perform(2, 1000, 1000000, new CreationCtx(10, getStartId(ID_Th2Tx1000Cr10)));
}
}
/**
* Tests 10.000 transactions where each of them creates 10 objects using 2
* thread.
*/
public void testCreationTh2Tx10000Cr10() {
if (!interactive) {
perform(2, 10000, 1000000, new CreationCtx(10, getStartId(ID_Th2Tx10000Cr10)));
}
}
/**
* Tests 100.000 transactions where each of them creates 10 objects using 2
* thread.
*/
public void testCreationTh2Tx100000Cr10() {
if (!interactive) {
perform(2, 100000, 1000000, new CreationCtx(10, getStartId(ID_Th2Tx100000Cr10)));
}
}
/**
* Tests 10 transactions where each of them creates 100 objects using 2
* thread.
*/
public void testCreationTh2Tx10Cr100() {
if (!interactive) {
perform(2, 10, 1000000, new CreationCtx(100, getStartId(ID_Th2Tx10Cr100)));
}
}
/**
* Tests 100 transactions where each of them creates 100 objects using 2
* thread.
*/
public void testCreationTh2Tx100Cr100() {
if (!interactive) {
perform(2, 100, 1000000, new CreationCtx(100, getStartId(ID_Th2Tx100Cr100)));
}
}
/**
* Tests 1.000 transactions where each of them creates 100 objects using 2
* thread.
*/
public void testCreationTh2Tx1000Cr100() {
if (!interactive) {
perform(2, 1000, 1000000, new CreationCtx(100, getStartId(ID_Th2Tx1000Cr100)));
}
}
/**
* Tests 10.000 transactions where each of them creates 100 objects using 2
* thread.
*/
public void testCreationTh2Tx10000Cr100() {
if (!interactive) {
perform(2, 10000, 1000000, new CreationCtx(100, getStartId(ID_Th2Tx10000Cr100)));
}
}
/**
* Tests 10 transactions where each of them creates 500 objects using 2
* thread.
*/
public void testCreationTh2Tx10Cr500() {
if (!interactive) {
perform(2, 10, 1000000, new CreationCtx(500, getStartId(ID_Th2Tx10Cr500)));
}
}
/**
* Tests 100 transactions where each of them creates 500 objects using 2
* thread.
*/
public void testCreationTh2Tx100Cr500() {
if (!interactive) {
perform(2, 100, 1000000, new CreationCtx(500, getStartId(ID_Th2Tx100Cr500)));
}
}
/**
* Tests 1.000 transactions where each of them creates 500 objects using 2
* thread.
*/
public void testCreationTh2Tx1000Cr500() {
if (!interactive) {
perform(2, 1000, 1000000, new CreationCtx(500, getStartId(ID_Th2Tx1000Cr500)));
}
}
/**
* Tests 10 transactions where each of them creates 1.000 objects using 2
* thread.
*/
public void testCreationTh2Tx10Cr1000() {
if (!interactive) {
perform(2, 10, 1000000, new CreationCtx(1000, getStartId(ID_Th2Tx10Cr1000)));
}
}
/**
* Tests 100 transactions where each of them creates 1.000 objects using 2
* thread.
*/
public void testCreationTh2Tx100Cr1000() {
if (!interactive) {
perform(2, 100, 1000000, new CreationCtx(1000, getStartId(ID_Th2Tx100Cr1000)));
}
}
/**
* Tests 1.000 transactions where each of them creates 1.000 objects using
* 1 thread.
*/
public void testCreationTh2Tx1000Cr1000() {
if (!interactive) {
perform(2, 1000, 1000000, new CreationCtx(1000, getStartId(ID_Th2Tx100Cr1000)));
}
}
/**
* Tests 10 transactions where each of them creates 2.000 objects using 2
* thread.
*/
public void testCreationTh2Tx10Cr2000() {
if (!interactive) {
perform(2, 10, 1000000, new CreationCtx(2000, getStartId(ID_Th2Tx10Cr2000)));
}
}
/**
* Tests 100 transactions where each of them creates 2.000 objects using 2
* thread.
*/
public void testCreationTh2Tx100Cr2000() {
if (!interactive) {
perform(2, 100, 1000000, new CreationCtx(2000, getStartId(ID_Th2Tx100Cr2000)));
}
}
/**
* Tests 1.000 transactions where each of them creates 2.000 objects using
* 1 thread.
*/
public void testCreationTh2Tx1000Cr2000() {
if (!interactive) {
perform(2, 1000, 1000000, new CreationCtx(2000, getStartId(ID_Th2Tx1000Cr2000)));
}
}
/**
* Tests 10 transactions where each of them creates 10.000 objects using 2
* thread.
*/
public void testCreationTh2Tx10Cr10000() {
if (!interactive) {
perform(2, 10, 1000000, new CreationCtx(10000, getStartId(ID_Th2Tx10Cr10000)));
}
}
/**
* Tests 100 transactions where each of them creates 10.000 objects using 2
* thread.
*/
public void testCreationTh2Tx100Cr10000() {
if (!interactive) {
perform(2, 100, 1000000, new CreationCtx(10000, getStartId(ID_Th2Tx100Cr10000)));
}
}
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
/**
* Tests 10 transactions where each of them creates 1 object using 3
* thread.
*/
public void testCreationTh3Tx10Cr1() {
if (!interactive) {
perform(3, 10, 1000000, new CreationCtx(1, getStartId(ID_Th3Tx10Cr1)));
}
}
/**
* Tests 100 transactions where each of them creates 1 object using 3
* thread.
*/
public void testCreationTh3Tx100Cr1() {
if (!interactive) {
perform(3, 100, 1000000, new CreationCtx(1, getStartId(ID_Th3Tx100Cr1)));
}
}
/**
* Tests 1.000 transactions where each of them creates 1 object using 3
* thread.
*/
public void testCreationTh3Tx1000Cr1() {
if (!interactive) {
perform(3, 1000, 1000000, new CreationCtx(1, getStartId(ID_Th3Tx1000Cr1)));
}
}
/**
* Tests 10.000 transactions where each of them creates 1 object using 3
* thread.
*/
public void testCreationTh3Tx10000Cr1() {
if (!interactive) {
perform(3, 10000, 1000000, new CreationCtx(1, getStartId(ID_Th3Tx10000Cr1)));
}
}
/**
* Tests 100.000 transactions where each of them creates 1 object using 3
* thread.
*/
public void testCreationTh3Tx100000Cr1() {
if (!interactive) {
perform(3, 100000, 1000000, new CreationCtx(1, getStartId(ID_Th3Tx100000Cr1)));
}
}
/**
* Tests 10 transactions where each of them creates 10 objects using 3
* thread.
*/
public void testCreationTh3Tx10Cr10() {
if (!interactive) {
perform(3, 10, 1000000, new CreationCtx(10, getStartId(ID_Th3Tx10Cr10)));
}
}
/**
* Tests 100 transactions where each of them creates 10 objects using 3
* thread.
*/
public void testCreationTh3Tx100Cr10() {
if (!interactive) {
perform(3, 100, 1000000, new CreationCtx(10, getStartId(ID_Th3Tx100Cr10)));
}
}
/**
* Tests 1.000 transactions where each of them creates 10 objects using 3
* thread.
*/
public void testCreationTh3Tx1000Cr10() {
if (!interactive) {
perform(3, 1000, 1000000, new CreationCtx(10, getStartId(ID_Th3Tx1000Cr10)));
}
}
/**
* Tests 10.000 transactions where each of them creates 10 objects using 3
* thread.
*/
public void testCreationTh3Tx10000Cr10() {
if (!interactive) {
perform(3, 10000, 1000000, new CreationCtx(10, getStartId(ID_Th3Tx10000Cr10)));
}
}
/**
* Tests 100.000 transactions where each of them creates 10 objects using 3
* thread.
*/
public void testCreationTh3Tx100000Cr10() {
if (!interactive) {
perform(3, 100000, 1000000, new CreationCtx(10, getStartId(ID_Th3Tx100000Cr10)));
}
}
/**
* Tests 10 transactions where each of them creates 100 objects using 3
* thread.
*/
public void testCreationTh3Tx10Cr100() {
if (!interactive) {
perform(3, 10, 1000000, new CreationCtx(100, getStartId(ID_Th3Tx10Cr100)));
}
}
/**
* Tests 100 transactions where each of them creates 100 objects using 3
* thread.
*/
public void testCreationTh3Tx100Cr100() {
if (!interactive) {
perform(3, 100, 1000000, new CreationCtx(100, getStartId(ID_Th3Tx100Cr100)));
}
}
/**
* Tests 1.000 transactions where each of them creates 100 objects using 3
* thread.
*/
public void testCreationTh3Tx1000Cr100() {
if (!interactive) {
perform(3, 1000, 1000000, new CreationCtx(100, getStartId(ID_Th3Tx1000Cr100)));
}
}
/**
* Tests 10.000 transactions where each of them creates 100 objects using 3
* thread.
*/
public void testCreationTh3Tx10000Cr100() {
if (!interactive) {
perform(3, 10000, 1000000, new CreationCtx(100, getStartId(ID_Th3Tx10000Cr100)));
}
}
/**
* Tests 10 transactions where each of them creates 500 objects using 3
* thread.
*/
public void testCreationTh3Tx10Cr500() {
if (!interactive) {
perform(3, 10, 1000000, new CreationCtx(500, getStartId(ID_Th3Tx10Cr500)));
}
}
/**
* Tests 100 transactions where each of them creates 500 objects using 3
* thread.
*/
public void testCreationTh3Tx100Cr500() {
if (!interactive) {
perform(3, 100, 1000000, new CreationCtx(500, getStartId(ID_Th3Tx100Cr500)));
}
}
/**
* Tests 1.000 transactions where each of them creates 500 objects using 3
* thread.
*/
public void testCreationTh3Tx1000Cr500() {
if (!interactive) {
perform(3, 1000, 1000000, new CreationCtx(500, getStartId(ID_Th3Tx1000Cr500)));
}
}
/**
* Tests 10 transactions where each of them creates 1.000 objects using 3
* thread.
*/
public void testCreationTh3Tx10Cr1000() {
if (!interactive) {
perform(3, 10, 1000000, new CreationCtx(1000, getStartId(ID_Th3Tx10Cr1000)));
}
}
/**
* Tests 100 transactions where each of them creates 1.000 objects using 3
* thread.
*/
public void testCreationTh3Tx100Cr1000() {
if (!interactive) {
perform(3, 100, 1000000, new CreationCtx(1000, getStartId(ID_Th3Tx100Cr1000)));
}
}
/**
* Tests 1.000 transactions where each of them creates 1.000 objects using
* 1 thread.
*/
public void testCreationTh3Tx1000Cr1000() {
if (!interactive) {
perform(3, 1000, 1000000, new CreationCtx(1000, getStartId(ID_Th3Tx100Cr1000)));
}
}
/**
* Tests 10 transactions where each of them creates 2.000 objects using 3
* thread.
*/
public void testCreationTh3Tx10Cr2000() {
if (!interactive) {
perform(3, 10, 1000000, new CreationCtx(2000, getStartId(ID_Th3Tx10Cr2000)));
}
}
/**
* Tests 100 transactions where each of them creates 2.000 objects using 3
* thread.
*/
public void testCreationTh3Tx100Cr2000() {
if (!interactive) {
perform(3, 100, 1000000, new CreationCtx(2000, getStartId(ID_Th3Tx100Cr2000)));
}
}
/**
* Tests 1.000 transactions where each of them creates 2.000 objects using
* 1 thread.
*/
public void testCreationTh3Tx1000Cr2000() {
if (!interactive) {
perform(3, 1000, 1000000, new CreationCtx(2000, getStartId(ID_Th3Tx1000Cr2000)));
}
}
/**
* Tests 10 transactions where each of them creates 10.000 objects using 3
* thread.
*/
public void testCreationTh3Tx10Cr10000() {
if (!interactive) {
perform(3, 10, 1000000, new CreationCtx(10000, getStartId(ID_Th3Tx10Cr10000)));
}
}
/**
* Tests 100 transactions where each of them creates 10.000 objects using 3
* thread.
*/
public void testCreationTh3Tx100Cr10000() {
if (!interactive) {
perform(3, 100, 1000000, new CreationCtx(10000, getStartId(ID_Th3Tx100Cr10000)));
}
}
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
/**
* Tests 10 transactions where each of them creates 1 object using 4
* thread.
*/
public void testCreationTh4Tx10Cr1() {
if (!interactive) {
perform(4, 10, 1000000, new CreationCtx(1, getStartId(ID_Th4Tx10Cr1)));
}
}
/**
* Tests 100 transactions where each of them creates 1 object using 4
* thread.
*/
public void testCreationTh4Tx100Cr1() {
if (!interactive) {
perform(4, 100, 1000000, new CreationCtx(1, getStartId(ID_Th4Tx100Cr1)));
}
}
/**
* Tests 1.000 transactions where each of them creates 1 object using 4
* thread.
*/
public void testCreationTh4Tx1000Cr1() {
if (!interactive) {
perform(4, 1000, 1000000, new CreationCtx(1, getStartId(ID_Th4Tx1000Cr1)));
}
}
/**
* Tests 10.000 transactions where each of them creates 1 object using 4
* thread.
*/
public void testCreationTh4Tx10000Cr1() {
if (!interactive) {
perform(4, 10000, 1000000, new CreationCtx(1, getStartId(ID_Th4Tx10000Cr1)));
}
}
/**
* Tests 100.000 transactions where each of them creates 1 object using 4
* thread.
*/
public void testCreationTh4Tx100000Cr1() {
if (!interactive) {
perform(4, 100000, 1000000, new CreationCtx(1, getStartId(ID_Th4Tx100000Cr1)));
}
}
/**
* Tests 10 transactions where each of them creates 10 objects using 4
* thread.
*/
public void testCreationTh4Tx10Cr10() {
if (!interactive) {
perform(4, 10, 1000000, new CreationCtx(10, getStartId(ID_Th4Tx10Cr10)));
}
}
/**
* Tests 100 transactions where each of them creates 10 objects using 4
* thread.
*/
public void testCreationTh4Tx100Cr10() {
if (!interactive) {
perform(4, 100, 1000000, new CreationCtx(10, getStartId(ID_Th4Tx100Cr10)));
}
}
/**
* Tests 1.000 transactions where each of them creates 10 objects using 4
* thread.
*/
public void testCreationTh4Tx1000Cr10() {
if (!interactive) {
perform(4, 1000, 1000000, new CreationCtx(10, getStartId(ID_Th4Tx1000Cr10)));
}
}
/**
* Tests 10.000 transactions where each of them creates 10 objects using 4
* thread.
*/
public void testCreationTh4Tx10000Cr10() {
if (!interactive) {
perform(4, 10000, 1000000, new CreationCtx(10, getStartId(ID_Th4Tx10000Cr10)));
}
}
/**
* Tests 100.000 transactions where each of them creates 10 objects using 4
* thread.
*/
public void testCreationTh4Tx100000Cr10() {
if (!interactive) {
perform(4, 100000, 1000000, new CreationCtx(10, getStartId(ID_Th4Tx100000Cr10)));
}
}
/**
* Tests 10 transactions where each of them creates 100 objects using 4
* thread.
*/
public void testCreationTh4Tx10Cr100() {
if (!interactive) {
perform(4, 10, 1000000, new CreationCtx(100, getStartId(ID_Th4Tx10Cr100)));
}
}
/**
* Tests 100 transactions where each of them creates 100 objects using 4
* thread.
*/
public void testCreationTh4Tx100Cr100() {
if (!interactive) {
perform(4, 100, 1000000, new CreationCtx(100, getStartId(ID_Th4Tx100Cr100)));
}
}
/**
* Tests 1.000 transactions where each of them creates 100 objects using 4
* thread.
*/
public void testCreationTh4Tx1000Cr100() {
if (!interactive) {
perform(4, 1000, 1000000, new CreationCtx(100, getStartId(ID_Th4Tx1000Cr100)));
}
}
/**
* Tests 10.000 transactions where each of them creates 100 objects using 4
* thread.
*/
public void testCreationTh4Tx10000Cr100() {
if (!interactive) {
perform(4, 10000, 1000000, new CreationCtx(100, getStartId(ID_Th4Tx10000Cr100)));
}
}
/**
* Tests 10 transactions where each of them creates 500 objects using 4
* thread.
*/
public void testCreationTh4Tx10Cr500() {
if (!interactive) {
perform(4, 10, 1000000, new CreationCtx(500, getStartId(ID_Th4Tx10Cr500)));
}
}
/**
* Tests 100 transactions where each of them creates 500 objects using 4
* thread.
*/
public void testCreationTh4Tx100Cr500() {
if (!interactive) {
perform(4, 100, 1000000, new CreationCtx(500, getStartId(ID_Th4Tx100Cr500)));
}
}
/**
* Tests 1.000 transactions where each of them creates 500 objects using 4
* thread.
*/
public void testCreationTh4Tx1000Cr500() {
if (!interactive) {
perform(4, 1000, 1000000, new CreationCtx(500, getStartId(ID_Th4Tx1000Cr500)));
}
}
/**
* Tests 10 transactions where each of them creates 1.000 objects using 4
* thread.
*/
public void testCreationTh4Tx10Cr1000() {
if (!interactive) {
perform(4, 10, 1000000, new CreationCtx(1000, getStartId(ID_Th4Tx10Cr1000)));
}
}
/**
* Tests 100 transactions where each of them creates 1.000 objects using 4
* thread.
*/
public void testCreationTh4Tx100Cr1000() {
if (!interactive) {
perform(4, 100, 1000000, new CreationCtx(1000, getStartId(ID_Th4Tx100Cr1000)));
}
}
/**
* Tests 1.000 transactions where each of them creates 1.000 objects using
* 1 thread.
*/
public void testCreationTh4Tx1000Cr1000() {
if (!interactive) {
perform(4, 1000, 1000000, new CreationCtx(1000, getStartId(ID_Th4Tx100Cr1000)));
}
}
/**
* Tests 10 transactions where each of them creates 2.000 objects using 4
* thread.
*/
public void testCreationTh4Tx10Cr2000() {
if (!interactive) {
perform(4, 10, 1000000, new CreationCtx(2000, getStartId(ID_Th4Tx10Cr2000)));
}
}
/**
* Tests 100 transactions where each of them creates 2.000 objects using 4
* thread.
*/
public void testCreationTh4Tx100Cr2000() {
if (!interactive) {
perform(4, 100, 1000000, new CreationCtx(2000, getStartId(ID_Th4Tx100Cr2000)));
}
}
/**
* Tests 1.000 transactions where each of them creates 2.000 objects using
* 1 thread.
*/
public void testCreationTh4Tx1000Cr2000() {
if (!interactive) {
perform(4, 1000, 1000000, new CreationCtx(2000, getStartId(ID_Th4Tx1000Cr2000)));
}
}
/**
* Tests 10 transactions where each of them creates 10.000 objects using 4
* thread.
*/
public void testCreationTh4Tx10Cr10000() {
if (!interactive) {
perform(4, 10, 1000000, new CreationCtx(10000, getStartId(ID_Th4Tx10Cr10000)));
}
}
/**
* Tests 100 transactions where each of them creates 10.000 objects using 4
* thread.
*/
public void testCreationTh4Tx100Cr10000() {
if (!interactive) {
perform(4, 100, 1000000, new CreationCtx(10000, getStartId(ID_Th4Tx100Cr10000)));
}
}
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
/**
* Tests 10 transactions where each of them creates 1 object using 10
* thread.
*/
public void testCreationTh10Tx10Cr1() {
if (!interactive) {
perform(10, 10, 1000000, new CreationCtx(1, getStartId(ID_Th10Tx10Cr1)));
}
}
/**
* Tests 100 transactions where each of them creates 1 object using 10
* thread.
*/
public void testCreationTh10Tx100Cr1() {
if (!interactive) {
perform(10, 100, 1000000, new CreationCtx(1, getStartId(ID_Th10Tx100Cr1)));
}
}
/**
* Tests 1.000 transactions where each of them creates 1 object using 10
* thread.
*/
public void testCreationTh10Tx1000Cr1() {
if (!interactive) {
perform(10, 1000, 1000000, new CreationCtx(1, getStartId(ID_Th10Tx1000Cr1)));
}
}
/**
* Tests 10.000 transactions where each of them creates 1 object using 10
* thread.
*/
public void testCreationTh10Tx10000Cr1() {
if (!interactive) {
perform(10, 10000, 1000000, new CreationCtx(1, getStartId(ID_Th10Tx10000Cr1)));
}
}
/**
* Tests 100.000 transactions where each of them creates 1 object using 10
* thread.
*/
public void testCreationTh10Tx100000Cr1() {
if (!interactive) {
perform(10, 100000, 1000000, new CreationCtx(1, getStartId(ID_Th10Tx100000Cr1)));
}
}
/**
* Tests 10 transactions where each of them creates 10 objects using 10
* thread.
*/
public void testCreationTh10Tx10Cr10() {
if (!interactive) {
perform(10, 10, 1000000, new CreationCtx(10, getStartId(ID_Th10Tx10Cr10)));
}
}
/**
* Tests 100 transactions where each of them creates 10 objects using 10
* thread.
*/
public void testCreationTh10Tx100Cr10() {
if (!interactive) {
perform(10, 100, 1000000, new CreationCtx(10, getStartId(ID_Th10Tx100Cr10)));
}
}
/**
* Tests 1.000 transactions where each of them creates 10 objects using 10
* thread.
*/
public void testCreationTh10Tx1000Cr10() {
if (!interactive) {
perform(10, 1000, 1000000, new CreationCtx(10, getStartId(ID_Th10Tx1000Cr10)));
}
}
/**
* Tests 10.000 transactions where each of them creates 10 objects using 10
* thread.
*/
public void testCreationTh10Tx10000Cr10() {
if (!interactive) {
perform(10, 10000, 1000000, new CreationCtx(10, getStartId(ID_Th10Tx10000Cr10)));
}
}
/**
* Tests 100.000 transactions where each of them creates 10 objects using 10
* thread.
*/
public void testCreationTh10Tx100000Cr10() {
if (!interactive) {
perform(10, 100000, 1000000, new CreationCtx(10, getStartId(ID_Th10Tx100000Cr10)));
}
}
/**
* Tests 10 transactions where each of them creates 100 objects using 10
* thread.
*/
public void testCreationTh10Tx10Cr100() {
if (!interactive) {
perform(10, 10, 1000000, new CreationCtx(100, getStartId(ID_Th10Tx10Cr100)));
}
}
/**
* Tests 100 transactions where each of them creates 100 objects using 10
* thread.
*/
public void testCreationTh10Tx100Cr100() {
if (!interactive) {
perform(10, 100, 1000000, new CreationCtx(100, getStartId(ID_Th10Tx100Cr100)));
}
}
/**
* Tests 1.000 transactions where each of them creates 100 objects using 10
* thread.
*/
public void testCreationTh10Tx1000Cr100() {
if (!interactive) {
perform(10, 1000, 1000000, new CreationCtx(100, getStartId(ID_Th10Tx1000Cr100)));
}
}
/**
* Tests 10.000 transactions where each of them creates 100 objects using 10
* thread.
*/
public void testCreationTh10Tx10000Cr100() {
if (!interactive) {
perform(10, 10000, 1000000, new CreationCtx(100, getStartId(ID_Th10Tx10000Cr100)));
}
}
/**
* Tests 10 transactions where each of them creates 500 objects using 10
* thread.
*/
public void testCreationTh10Tx10Cr500() {
if (!interactive) {
perform(10, 10, 1000000, new CreationCtx(500, getStartId(ID_Th10Tx10Cr500)));
}
}
/**
* Tests 100 transactions where each of them creates 500 objects using 10
* thread.
*/
public void testCreationTh10Tx100Cr500() {
if (!interactive) {
perform(10, 100, 1000000, new CreationCtx(500, getStartId(ID_Th10Tx100Cr500)));
}
}
/**
* Tests 1.000 transactions where each of them creates 500 objects using 10
* thread.
*/
public void testCreationTh10Tx1000Cr500() {
if (!interactive) {
perform(10, 1000, 1000000, new CreationCtx(500, getStartId(ID_Th10Tx1000Cr500)));
}
}
/**
* Tests 10 transactions where each of them creates 1.000 objects using 10
* thread.
*/
public void testCreationTh10Tx10Cr1000() {
if (!interactive) {
perform(10, 10, 1000000, new CreationCtx(1000, getStartId(ID_Th10Tx10Cr1000)));
}
}
/**
* Tests 100 transactions where each of them creates 1.000 objects using 10
* thread.
*/
public void testCreationTh10Tx100Cr1000() {
if (!interactive) {
perform(10, 100, 1000000, new CreationCtx(1000, getStartId(ID_Th10Tx100Cr1000)));
}
}
/**
* Tests 1.000 transactions where each of them creates 1.000 objects using
* 1 thread.
*/
public void testCreationTh10Tx1000Cr1000() {
if (!interactive) {
perform(10, 1000, 1000000, new CreationCtx(1000, getStartId(ID_Th10Tx100Cr1000)));
}
}
/**
* Tests 10 transactions where each of them creates 2.000 objects using 10
* thread.
*/
public void testCreationTh10Tx10Cr2000() {
if (!interactive) {
perform(10, 10, 1000000, new CreationCtx(2000, getStartId(ID_Th10Tx10Cr2000)));
}
}
/**
* Tests 100 transactions where each of them creates 2.000 objects using 10
* thread.
*/
public void testCreationTh10Tx100Cr2000() {
if (!interactive) {
perform(10, 100, 1000000, new CreationCtx(2000, getStartId(ID_Th10Tx100Cr2000)));
}
}
/**
* Tests 1.000 transactions where each of them creates 2.000 objects using
* 1 thread.
*/
public void testCreationTh10Tx1000Cr2000() {
if (!interactive) {
perform(10, 1000, 1000000, new CreationCtx(2000, getStartId(ID_Th10Tx1000Cr2000)));
}
}
/**
* Tests 10 transactions where each of them creates 10.000 objects using 10
* thread.
*/
public void testCreationTh10Tx10Cr10000() {
if (!interactive) {
perform(10, 10, 1000000, new CreationCtx(10000, getStartId(ID_Th10Tx10Cr10000)));
}
}
/**
* Tests 100 transactions where each of them creates 10.000 objects using 10
* thread.
*/
public void testCreationTh10Tx100Cr10000() {
if (!interactive) {
perform(10, 100, 1000000, new CreationCtx(10000, getStartId(ID_Th10Tx100Cr10000)));
}
}
}