KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > objectweb > speedo > stress > TestCreation


1 /**
2  * Copyright (C) 2001-2004 France Telecom R&D
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with this library; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17  */
18
19 package org.objectweb.speedo.stress;
20
21 import org.objectweb.speedo.pobjects.userid.IntUserId;
22 import org.objectweb.util.monolog.api.BasicLevel;
23
24 import javax.jdo.PersistenceManager;
25 import javax.jdo.JDOFatalException;
26
27 import junit.framework.TestSuite;
28 import junit.textui.TestRunner;
29
30 /**
31  * Stresses the creation function of Speedo.
32  *
33  * @author P. Dechamboux
34  */
35 public class TestCreation extends StressHelper {
36     private String JavaDoc CREATION = getLoggerName() + ".creation";
37     private String JavaDoc STARTID = getLoggerName() + ".startid";
38
39     public TestCreation(String JavaDoc s) {
40         super(s);
41     }
42
43     protected String JavaDoc[] getClassNamesToInit() {
44         return new String JavaDoc[] {IntUserId.class.getName()};
45     }
46
47     protected String JavaDoc getLoggerName() {
48         return STRESS_LOG_NAME + ".TestCreation";
49     }
50
51     public static void main(String JavaDoc[] args) {
52         TestRunner.run(new TestSuite(TestCreation.class));
53     }
54
55     class CreationCtx {
56         int nbc;
57         int startid;
58
59         public CreationCtx(int _nbc, int _startid) {
60             this.nbc = _nbc;
61             this.startid = _startid;
62         }
63
64         public String JavaDoc toString() {
65             return "nbCreation = " + nbc + " / startid = " + startid;
66         }
67     }
68
69     protected void perform(Task task, int threadId, int txId, Object JavaDoc ctx, PerformResult res) {
70         CreationCtx cc = (CreationCtx) ctx;
71         final int nbCreation = cc.nbc;
72         final int startId = cc.startid;
73         PersistenceManager pm = getPM(task, threadId,txId);
74         try {
75             res.beginTest();
76             beginTx(pm, task, threadId, txId);
77             for (int no = 0; no < nbCreation; no++) {
78                 int oid = (txId * nbCreation) + no + startId;
79                 if (debug) {
80                     logger.log(BasicLevel.DEBUG, "Creating object " + oid);
81                 }
82                 IntUserId iui = new IntUserId(oid, "Obj No " + oid);
83                 pm.makePersistent(iui);
84             }
85             commitTx(pm, task, threadId, txId);
86             res.endTest();
87         } catch (JDOFatalException e) {
88             rollbackOnException(pm, e, res, task, threadId, txId);
89         } catch (Throwable JavaDoc e) {
90             stopOnError(pm, e, res, task, threadId, txId);
91         } finally {
92             closePM(pm, threadId, txId, task, res);
93         }
94     }
95
96     /**
97      * Tests the creation of a lot of persistent objects, with interactive
98      * setting of test parameteres (see file userconf/project.properties).
99      */
100     public void testInteractive() {
101         if (interactive) {
102             perform(Integer.getInteger(THREAD, 10).intValue(),
103                     Integer.getInteger(TX, 100).intValue(),
104                     Integer.getInteger(TIMEOUT, 1000000).intValue(),
105                     new CreationCtx(
106                             Integer.getInteger(CREATION, 1000).intValue(),
107                             Integer.getInteger(STARTID, 0).intValue()));
108         }
109     }
110
111     /**
112      * Tests 10 transactions where each of them creates 1 object using 1
113      * thread.
114      */
115     public void testCreationTh1Tx10Cr1() {
116         if (!interactive) {
117             perform(1, 10, 1000000, new CreationCtx(1, getStartId(ID_Th1Tx10Cr1)));
118         }
119     }
120
121     /**
122      * Tests 100 transactions where each of them creates 1 object using 1
123      * thread.
124      */
125     public void testCreationTh1Tx100Cr1() {
126         if (!interactive) {
127             perform(1, 100, 1000000, new CreationCtx(1, getStartId(ID_Th1Tx100Cr1)));
128         }
129     }
130
131     /**
132      * Tests 1.000 transactions where each of them creates 1 object using 1
133      * thread.
134      */
135     public void testCreationTh1Tx1000Cr1() {
136         if (!interactive) {
137             perform(1, 1000, 1000000, new CreationCtx(1, getStartId(ID_Th1Tx1000Cr1)));
138         }
139     }
140
141     /**
142      * Tests 10.000 transactions where each of them creates 1 object using 1
143      * thread.
144      */
145     public void testCreationTh1Tx10000Cr1() {
146         if (!interactive) {
147             perform(1, 10000, 1000000, new CreationCtx(1, getStartId(ID_Th1Tx10000Cr1)));
148         }
149     }
150
151     /**
152      * Tests 10 transactions where each of them creates 10 objects using 1
153      * thread.
154      */
155     public void testCreationTh1Tx10Cr10() {
156         if (!interactive) {
157             perform(1, 10, 1000000, new CreationCtx(10, getStartId(ID_Th1Tx10Cr10)));
158         }
159     }
160
161     /**
162      * Tests 100 transactions where each of them creates 10 objects using 1
163      * thread.
164      */
165     public void testCreationTh1Tx100Cr10() {
166
167         if (!interactive) {
168             perform(1, 100, 1000000, new CreationCtx(10, getStartId(ID_Th1Tx100Cr10)));
169         }
170     }
171
172     /**
173      * Tests 1.000 transactions where each of them creates 10 objects using 1
174      * thread.
175      */
176     public void testCreationTh1Tx1000Cr10() {
177
178         if (!interactive) {
179             perform(1, 1000, 1000000, new CreationCtx(10, getStartId(ID_Th1Tx1000Cr10)));
180         }
181     }
182
183     /**
184      * Tests 10.000 transactions where each of them creates 10 objects using 1
185      * thread.
186      */
187     public void testCreationTh1Tx10000Cr10() {
188
189         if (!interactive) {
190             perform(1, 10000, 1000000, new CreationCtx(10, getStartId(ID_Th1Tx10000Cr10)));
191         }
192     }
193
194     /**
195      * Tests 10 transactions where each of them creates 100 objects using 1
196      * thread.
197      */
198     public void testCreationTh1Tx10Cr100() {
199
200         if (!interactive) {
201             perform(1, 10, 1000000, new CreationCtx(100, getStartId(ID_Th1Tx10Cr100)));
202         }
203     }
204
205     /**
206      * Tests 100 transactions where each of them creates 100 objects using 1
207      * thread.
208      */
209     public void testCreationTh1Tx100Cr100() {
210
211         if (!interactive) {
212             perform(1, 100, 1000000, new CreationCtx(100, getStartId(ID_Th1Tx100Cr100)));
213         }
214     }
215
216     /**
217      * Tests 1.000 transactions where each of them creates 100 objects using 1
218      * thread.
219      */
220     public void testCreationTh1Tx1000Cr100() {
221
222         if (!interactive) {
223             perform(1, 1000, 1000000, new CreationCtx(100, getStartId(ID_Th1Tx1000Cr100)));
224         }
225     }
226
227     /**
228      * Tests 10.000 transactions where each of them creates 100 objects using 1
229      * thread.
230      */
231     public void testCreationTh1Tx10000Cr100() {
232
233         if (!interactive) {
234             perform(1, 10000, 1000000, new CreationCtx(100, getStartId(ID_Th1Tx10000Cr100)));
235         }
236     }
237
238     /**
239      * Tests 10 transactions where each of them creates 500 objects using 1
240      * thread.
241      */
242     public void testCreationTh1Tx10Cr500() {
243
244         if (!interactive) {
245             perform(1, 10, 1000000, new CreationCtx(500, getStartId(ID_Th1Tx10Cr500)));
246         }
247     }
248
249     /**
250      * Tests 100 transactions where each of them creates 500 objects using 1
251      * thread.
252      */
253     public void testCreationTh1Tx100Cr500() {
254
255         if (!interactive) {
256             perform(1, 100, 1000000, new CreationCtx(500, getStartId(ID_Th1Tx100Cr500)));
257         }
258     }
259
260     /**
261      * Tests 1.000 transactions where each of them creates 500 objects using 1
262      * thread.
263      */
264     public void testCreationTh1Tx1000Cr500() {
265
266         if (!interactive) {
267             perform(1, 1000, 1000000, new CreationCtx(500, getStartId(ID_Th1Tx1000Cr500)));
268         }
269     }
270
271     /**
272      * Tests 10 transactions where each of them creates 1.000 objects using 1
273      * thread.
274      */
275     public void testCreationTh1Tx10Cr1000() {
276
277         if (!interactive) {
278             perform(1, 10, 1000000, new CreationCtx(1000, getStartId(ID_Th1Tx10Cr1000)));
279         }
280     }
281
282     /**
283      * Tests 100 transactions where each of them creates 1.000 objects using 1
284      * thread.
285      */
286     public void testCreationTh1Tx100Cr1000() {
287
288         if (!interactive) {
289             perform(1, 100, 1000000, new CreationCtx(1000, getStartId(ID_Th1Tx100Cr1000)));
290         }
291     }
292
293     /**
294      * Tests 1.000 transactions where each of them creates 1.000 objects using
295      * 1 thread.
296      */
297     public void testCreationTh1Tx1000Cr1000() {
298
299         if (!interactive) {
300             perform(1, 1000, 1000000, new CreationCtx(1000, getStartId(ID_Th1Tx100Cr1000)));
301         }
302     }
303
304     /**
305      * Tests 10 transactions where each of them creates 2.000 objects using 1
306      * thread.
307      */
308     public void testCreationTh1Tx10Cr2000() {
309
310         if (!interactive) {
311             perform(1, 10, 1000000, new CreationCtx(2000, getStartId(ID_Th1Tx10Cr2000)));
312         }
313     }
314
315     /**
316      * Tests 100 transactions where each of them creates 2.000 objects using 1
317      * thread.
318      */
319     public void testCreationTh1Tx100Cr2000() {
320
321         if (!interactive) {
322             perform(1, 100, 1000000, new CreationCtx(2000, getStartId(ID_Th1Tx100Cr2000)));
323         }
324     }
325
326     /**
327      * Tests 1.000 transactions where each of them creates 2.000 objects using
328      * 1 thread.
329      */
330     public void testCreationTh1Tx1000Cr2000() {
331
332         if (!interactive) {
333             perform(1, 1000, 1000000, new CreationCtx(2000, getStartId(ID_Th1Tx1000Cr2000)));
334         }
335     }
336
337     /**
338      * Tests 10 transactions where each of them creates 10.000 objects using 1
339      * thread.
340      */
341     public void testCreationTh1Tx10Cr10000() {
342         if (!interactive) {
343             perform(1, 10, 1000000, new CreationCtx(10000, getStartId(ID_Th1Tx10Cr10000)));
344         }
345     }
346
347     /**
348      * Tests 100 transactions where each of them creates 10.000 objects using 1
349      * thread.
350      */
351     public void testCreationTh1Tx100Cr10000() {
352
353         if (!interactive) {
354             perform(1, 100, 1000000, new CreationCtx(10000, getStartId(ID_Th1Tx100Cr10000)));
355         }
356     }
357
358     ///////////////////////////////////////////////////////////////////////////
359 ///////////////////////////////////////////////////////////////////////////
360
361     /**
362      * Tests 10 transactions where each of them creates 1 object using 2
363      * thread.
364      */
365     public void testCreationTh2Tx10Cr1() {
366
367         if (!interactive) {
368             perform(2, 10, 1000000, new CreationCtx(1, getStartId(ID_Th2Tx10Cr1)));
369         }
370     }
371
372     /**
373      * Tests 100 transactions where each of them creates 1 object using 2
374      * thread.
375      */
376     public void testCreationTh2Tx100Cr1() {
377
378         if (!interactive) {
379             perform(2, 100, 1000000, new CreationCtx(1, getStartId(ID_Th2Tx100Cr1)));
380         }
381     }
382
383     /**
384      * Tests 1.000 transactions where each of them creates 1 object using 2
385      * thread.
386      */
387     public void testCreationTh2Tx1000Cr1() {
388
389         if (!interactive) {
390             perform(2, 1000, 1000000, new CreationCtx(1, getStartId(ID_Th2Tx1000Cr1)));
391         }
392     }
393
394     /**
395      * Tests 10.000 transactions where each of them creates 1 object using 2
396      * thread.
397      */
398     public void testCreationTh2Tx10000Cr1() {
399
400         if (!interactive) {
401             perform(2, 10000, 1000000, new CreationCtx(1, getStartId(ID_Th2Tx10000Cr1)));
402         }
403     }
404
405     /**
406      * Tests 100.000 transactions where each of them creates 1 object using 2
407      * thread.
408      */
409     public void testCreationTh2Tx100000Cr1() {
410
411         if (!interactive) {
412             perform(2, 100000, 1000000, new CreationCtx(1, getStartId(ID_Th2Tx100000Cr1)));
413         }
414     }
415
416     /**
417      * Tests 10 transactions where each of them creates 10 objects using 2
418      * thread.
419      */
420     public void testCreationTh2Tx10Cr10() {
421
422         if (!interactive) {
423             perform(2, 10, 1000000, new CreationCtx(10, getStartId(ID_Th2Tx10Cr10)));
424         }
425     }
426
427     /**
428      * Tests 100 transactions where each of them creates 10 objects using 2
429      * thread.
430      */
431     public void testCreationTh2Tx100Cr10() {
432
433         if (!interactive) {
434             perform(2, 100, 1000000, new CreationCtx(10, getStartId(ID_Th2Tx100Cr10)));
435         }
436     }
437
438     /**
439      * Tests 1.000 transactions where each of them creates 10 objects using 2
440      * thread.
441      */
442     public void testCreationTh2Tx1000Cr10() {
443
444         if (!interactive) {
445             perform(2, 1000, 1000000, new CreationCtx(10, getStartId(ID_Th2Tx1000Cr10)));
446         }
447     }
448
449     /**
450      * Tests 10.000 transactions where each of them creates 10 objects using 2
451      * thread.
452      */
453     public void testCreationTh2Tx10000Cr10() {
454
455         if (!interactive) {
456             perform(2, 10000, 1000000, new CreationCtx(10, getStartId(ID_Th2Tx10000Cr10)));
457         }
458     }
459
460     /**
461      * Tests 100.000 transactions where each of them creates 10 objects using 2
462      * thread.
463      */
464     public void testCreationTh2Tx100000Cr10() {
465
466         if (!interactive) {
467             perform(2, 100000, 1000000, new CreationCtx(10, getStartId(ID_Th2Tx100000Cr10)));
468         }
469     }
470
471     /**
472      * Tests 10 transactions where each of them creates 100 objects using 2
473      * thread.
474      */
475     public void testCreationTh2Tx10Cr100() {
476
477         if (!interactive) {
478             perform(2, 10, 1000000, new CreationCtx(100, getStartId(ID_Th2Tx10Cr100)));
479         }
480     }
481
482     /**
483      * Tests 100 transactions where each of them creates 100 objects using 2
484      * thread.
485      */
486     public void testCreationTh2Tx100Cr100() {
487
488         if (!interactive) {
489             perform(2, 100, 1000000, new CreationCtx(100, getStartId(ID_Th2Tx100Cr100)));
490         }
491     }
492
493     /**
494      * Tests 1.000 transactions where each of them creates 100 objects using 2
495      * thread.
496      */
497     public void testCreationTh2Tx1000Cr100() {
498
499         if (!interactive) {
500             perform(2, 1000, 1000000, new CreationCtx(100, getStartId(ID_Th2Tx1000Cr100)));
501         }
502     }
503
504     /**
505      * Tests 10.000 transactions where each of them creates 100 objects using 2
506      * thread.
507      */
508     public void testCreationTh2Tx10000Cr100() {
509
510         if (!interactive) {
511             perform(2, 10000, 1000000, new CreationCtx(100, getStartId(ID_Th2Tx10000Cr100)));
512         }
513     }
514
515     /**
516      * Tests 10 transactions where each of them creates 500 objects using 2
517      * thread.
518      */
519     public void testCreationTh2Tx10Cr500() {
520
521         if (!interactive) {
522             perform(2, 10, 1000000, new CreationCtx(500, getStartId(ID_Th2Tx10Cr500)));
523         }
524     }
525
526     /**
527      * Tests 100 transactions where each of them creates 500 objects using 2
528      * thread.
529      */
530     public void testCreationTh2Tx100Cr500() {
531
532         if (!interactive) {
533             perform(2, 100, 1000000, new CreationCtx(500, getStartId(ID_Th2Tx100Cr500)));
534         }
535     }
536
537     /**
538      * Tests 1.000 transactions where each of them creates 500 objects using 2
539      * thread.
540      */
541     public void testCreationTh2Tx1000Cr500() {
542
543         if (!interactive) {
544             perform(2, 1000, 1000000, new CreationCtx(500, getStartId(ID_Th2Tx1000Cr500)));
545         }
546     }
547
548     /**
549      * Tests 10 transactions where each of them creates 1.000 objects using 2
550      * thread.
551      */
552     public void testCreationTh2Tx10Cr1000() {
553
554         if (!interactive) {
555             perform(2, 10, 1000000, new CreationCtx(1000, getStartId(ID_Th2Tx10Cr1000)));
556         }
557     }
558
559     /**
560      * Tests 100 transactions where each of them creates 1.000 objects using 2
561      * thread.
562      */
563     public void testCreationTh2Tx100Cr1000() {
564
565         if (!interactive) {
566             perform(2, 100, 1000000, new CreationCtx(1000, getStartId(ID_Th2Tx100Cr1000)));
567         }
568     }
569
570     /**
571      * Tests 1.000 transactions where each of them creates 1.000 objects using
572      * 1 thread.
573      */
574     public void testCreationTh2Tx1000Cr1000() {
575
576         if (!interactive) {
577             perform(2, 1000, 1000000, new CreationCtx(1000, getStartId(ID_Th2Tx100Cr1000)));
578         }
579     }
580
581     /**
582      * Tests 10 transactions where each of them creates 2.000 objects using 2
583      * thread.
584      */
585     public void testCreationTh2Tx10Cr2000() {
586
587         if (!interactive) {
588             perform(2, 10, 1000000, new CreationCtx(2000, getStartId(ID_Th2Tx10Cr2000)));
589         }
590     }
591
592     /**
593      * Tests 100 transactions where each of them creates 2.000 objects using 2
594      * thread.
595      */
596     public void testCreationTh2Tx100Cr2000() {
597
598         if (!interactive) {
599             perform(2, 100, 1000000, new CreationCtx(2000, getStartId(ID_Th2Tx100Cr2000)));
600         }
601     }
602
603     /**
604      * Tests 1.000 transactions where each of them creates 2.000 objects using
605      * 1 thread.
606      */
607     public void testCreationTh2Tx1000Cr2000() {
608
609         if (!interactive) {
610             perform(2, 1000, 1000000, new CreationCtx(2000, getStartId(ID_Th2Tx1000Cr2000)));
611         }
612     }
613
614     /**
615      * Tests 10 transactions where each of them creates 10.000 objects using 2
616      * thread.
617      */
618     public void testCreationTh2Tx10Cr10000() {
619         if (!interactive) {
620             perform(2, 10, 1000000, new CreationCtx(10000, getStartId(ID_Th2Tx10Cr10000)));
621         }
622     }
623
624     /**
625      * Tests 100 transactions where each of them creates 10.000 objects using 2
626      * thread.
627      */
628     public void testCreationTh2Tx100Cr10000() {
629
630         if (!interactive) {
631             perform(2, 100, 1000000, new CreationCtx(10000, getStartId(ID_Th2Tx100Cr10000)));
632         }
633     }
634
635     ///////////////////////////////////////////////////////////////////////////
636 ///////////////////////////////////////////////////////////////////////////
637
638     /**
639      * Tests 10 transactions where each of them creates 1 object using 3
640      * thread.
641      */
642     public void testCreationTh3Tx10Cr1() {
643
644         if (!interactive) {
645             perform(3, 10, 1000000, new CreationCtx(1, getStartId(ID_Th3Tx10Cr1)));
646         }
647     }
648
649     /**
650      * Tests 100 transactions where each of them creates 1 object using 3
651      * thread.
652      */
653     public void testCreationTh3Tx100Cr1() {
654
655         if (!interactive) {
656             perform(3, 100, 1000000, new CreationCtx(1, getStartId(ID_Th3Tx100Cr1)));
657         }
658     }
659
660     /**
661      * Tests 1.000 transactions where each of them creates 1 object using 3
662      * thread.
663      */
664     public void testCreationTh3Tx1000Cr1() {
665
666         if (!interactive) {
667             perform(3, 1000, 1000000, new CreationCtx(1, getStartId(ID_Th3Tx1000Cr1)));
668         }
669     }
670
671     /**
672      * Tests 10.000 transactions where each of them creates 1 object using 3
673      * thread.
674      */
675     public void testCreationTh3Tx10000Cr1() {
676
677         if (!interactive) {
678             perform(3, 10000, 1000000, new CreationCtx(1, getStartId(ID_Th3Tx10000Cr1)));
679         }
680     }
681
682     /**
683      * Tests 100.000 transactions where each of them creates 1 object using 3
684      * thread.
685      */
686     public void testCreationTh3Tx100000Cr1() {
687
688         if (!interactive) {
689             perform(3, 100000, 1000000, new CreationCtx(1, getStartId(ID_Th3Tx100000Cr1)));
690         }
691     }
692
693     /**
694      * Tests 10 transactions where each of them creates 10 objects using 3
695      * thread.
696      */
697     public void testCreationTh3Tx10Cr10() {
698
699         if (!interactive) {
700             perform(3, 10, 1000000, new CreationCtx(10, getStartId(ID_Th3Tx10Cr10)));
701         }
702     }
703
704     /**
705      * Tests 100 transactions where each of them creates 10 objects using 3
706      * thread.
707      */
708     public void testCreationTh3Tx100Cr10() {
709
710         if (!interactive) {
711             perform(3, 100, 1000000, new CreationCtx(10, getStartId(ID_Th3Tx100Cr10)));
712         }
713     }
714
715     /**
716      * Tests 1.000 transactions where each of them creates 10 objects using 3
717      * thread.
718      */
719     public void testCreationTh3Tx1000Cr10() {
720
721         if (!interactive) {
722             perform(3, 1000, 1000000, new CreationCtx(10, getStartId(ID_Th3Tx1000Cr10)));
723         }
724     }
725
726     /**
727      * Tests 10.000 transactions where each of them creates 10 objects using 3
728      * thread.
729      */
730     public void testCreationTh3Tx10000Cr10() {
731
732         if (!interactive) {
733             perform(3, 10000, 1000000, new CreationCtx(10, getStartId(ID_Th3Tx10000Cr10)));
734         }
735     }
736
737     /**
738      * Tests 100.000 transactions where each of them creates 10 objects using 3
739      * thread.
740      */
741     public void testCreationTh3Tx100000Cr10() {
742
743         if (!interactive) {
744             perform(3, 100000, 1000000, new CreationCtx(10, getStartId(ID_Th3Tx100000Cr10)));
745         }
746     }
747
748     /**
749      * Tests 10 transactions where each of them creates 100 objects using 3
750      * thread.
751      */
752     public void testCreationTh3Tx10Cr100() {
753
754         if (!interactive) {
755             perform(3, 10, 1000000, new CreationCtx(100, getStartId(ID_Th3Tx10Cr100)));
756         }
757     }
758
759     /**
760      * Tests 100 transactions where each of them creates 100 objects using 3
761      * thread.
762      */
763     public void testCreationTh3Tx100Cr100() {
764
765         if (!interactive) {
766             perform(3, 100, 1000000, new CreationCtx(100, getStartId(ID_Th3Tx100Cr100)));
767         }
768     }
769
770     /**
771      * Tests 1.000 transactions where each of them creates 100 objects using 3
772      * thread.
773      */
774     public void testCreationTh3Tx1000Cr100() {
775
776         if (!interactive) {
777             perform(3, 1000, 1000000, new CreationCtx(100, getStartId(ID_Th3Tx1000Cr100)));
778         }
779     }
780
781     /**
782      * Tests 10.000 transactions where each of them creates 100 objects using 3
783      * thread.
784      */
785     public void testCreationTh3Tx10000Cr100() {
786
787         if (!interactive) {
788             perform(3, 10000, 1000000, new CreationCtx(100, getStartId(ID_Th3Tx10000Cr100)));
789         }
790     }
791
792     /**
793      * Tests 10 transactions where each of them creates 500 objects using 3
794      * thread.
795      */
796     public void testCreationTh3Tx10Cr500() {
797
798         if (!interactive) {
799             perform(3, 10, 1000000, new CreationCtx(500, getStartId(ID_Th3Tx10Cr500)));
800         }
801     }
802
803     /**
804      * Tests 100 transactions where each of them creates 500 objects using 3
805      * thread.
806      */
807     public void testCreationTh3Tx100Cr500() {
808
809         if (!interactive) {
810             perform(3, 100, 1000000, new CreationCtx(500, getStartId(ID_Th3Tx100Cr500)));
811         }
812     }
813
814     /**
815      * Tests 1.000 transactions where each of them creates 500 objects using 3
816      * thread.
817      */
818     public void testCreationTh3Tx1000Cr500() {
819
820         if (!interactive) {
821             perform(3, 1000, 1000000, new CreationCtx(500, getStartId(ID_Th3Tx1000Cr500)));
822         }
823     }
824
825     /**
826      * Tests 10 transactions where each of them creates 1.000 objects using 3
827      * thread.
828      */
829     public void testCreationTh3Tx10Cr1000() {
830
831         if (!interactive) {
832             perform(3, 10, 1000000, new CreationCtx(1000, getStartId(ID_Th3Tx10Cr1000)));
833         }
834     }
835
836     /**
837      * Tests 100 transactions where each of them creates 1.000 objects using 3
838      * thread.
839      */
840     public void testCreationTh3Tx100Cr1000() {
841
842         if (!interactive) {
843             perform(3, 100, 1000000, new CreationCtx(1000, getStartId(ID_Th3Tx100Cr1000)));
844         }
845     }
846
847     /**
848      * Tests 1.000 transactions where each of them creates 1.000 objects using
849      * 1 thread.
850      */
851     public void testCreationTh3Tx1000Cr1000() {
852
853         if (!interactive) {
854             perform(3, 1000, 1000000, new CreationCtx(1000, getStartId(ID_Th3Tx100Cr1000)));
855         }
856     }
857
858     /**
859      * Tests 10 transactions where each of them creates 2.000 objects using 3
860      * thread.
861      */
862     public void testCreationTh3Tx10Cr2000() {
863
864         if (!interactive) {
865             perform(3, 10, 1000000, new CreationCtx(2000, getStartId(ID_Th3Tx10Cr2000)));
866         }
867     }
868
869     /**
870      * Tests 100 transactions where each of them creates 2.000 objects using 3
871      * thread.
872      */
873     public void testCreationTh3Tx100Cr2000() {
874
875         if (!interactive) {
876             perform(3, 100, 1000000, new CreationCtx(2000, getStartId(ID_Th3Tx100Cr2000)));
877         }
878     }
879
880     /**
881      * Tests 1.000 transactions where each of them creates 2.000 objects using
882      * 1 thread.
883      */
884     public void testCreationTh3Tx1000Cr2000() {
885
886         if (!interactive) {
887             perform(3, 1000, 1000000, new CreationCtx(2000, getStartId(ID_Th3Tx1000Cr2000)));
888         }
889     }
890
891     /**
892      * Tests 10 transactions where each of them creates 10.000 objects using 3
893      * thread.
894      */
895     public void testCreationTh3Tx10Cr10000() {
896         if (!interactive) {
897             perform(3, 10, 1000000, new CreationCtx(10000, getStartId(ID_Th3Tx10Cr10000)));
898         }
899     }
900
901     /**
902      * Tests 100 transactions where each of them creates 10.000 objects using 3
903      * thread.
904      */
905     public void testCreationTh3Tx100Cr10000() {
906
907         if (!interactive) {
908             perform(3, 100, 1000000, new CreationCtx(10000, getStartId(ID_Th3Tx100Cr10000)));
909         }
910     }
911
912     ///////////////////////////////////////////////////////////////////////////
913 ///////////////////////////////////////////////////////////////////////////
914
915     /**
916      * Tests 10 transactions where each of them creates 1 object using 4
917      * thread.
918      */
919     public void testCreationTh4Tx10Cr1() {
920
921         if (!interactive) {
922             perform(4, 10, 1000000, new CreationCtx(1, getStartId(ID_Th4Tx10Cr1)));
923         }
924     }
925
926     /**
927      * Tests 100 transactions where each of them creates 1 object using 4
928      * thread.
929      */
930     public void testCreationTh4Tx100Cr1() {
931
932         if (!interactive) {
933             perform(4, 100, 1000000, new CreationCtx(1, getStartId(ID_Th4Tx100Cr1)));
934         }
935     }
936
937     /**
938      * Tests 1.000 transactions where each of them creates 1 object using 4
939      * thread.
940      */
941     public void testCreationTh4Tx1000Cr1() {
942
943         if (!interactive) {
944             perform(4, 1000, 1000000, new CreationCtx(1, getStartId(ID_Th4Tx1000Cr1)));
945         }
946     }
947
948     /**
949      * Tests 10.000 transactions where each of them creates 1 object using 4
950      * thread.
951      */
952     public void testCreationTh4Tx10000Cr1() {
953
954         if (!interactive) {
955             perform(4, 10000, 1000000, new CreationCtx(1, getStartId(ID_Th4Tx10000Cr1)));
956         }
957     }
958
959     /**
960      * Tests 100.000 transactions where each of them creates 1 object using 4
961      * thread.
962      */
963     public void testCreationTh4Tx100000Cr1() {
964
965         if (!interactive) {
966             perform(4, 100000, 1000000, new CreationCtx(1, getStartId(ID_Th4Tx100000Cr1)));
967         }
968     }
969
970     /**
971      * Tests 10 transactions where each of them creates 10 objects using 4
972      * thread.
973      */
974     public void testCreationTh4Tx10Cr10() {
975
976         if (!interactive) {
977             perform(4, 10, 1000000, new CreationCtx(10, getStartId(ID_Th4Tx10Cr10)));
978         }
979     }
980
981     /**
982      * Tests 100 transactions where each of them creates 10 objects using 4
983      * thread.
984      */
985     public void testCreationTh4Tx100Cr10() {
986
987         if (!interactive) {
988             perform(4, 100, 1000000, new CreationCtx(10, getStartId(ID_Th4Tx100Cr10)));
989         }
990     }
991
992     /**
993      * Tests 1.000 transactions where each of them creates 10 objects using 4
994      * thread.
995      */
996     public void testCreationTh4Tx1000Cr10() {
997
998         if (!interactive) {
999             perform(4, 1000, 1000000, new CreationCtx(10, getStartId(ID_Th4Tx1000Cr10)));
1000        }
1001    }
1002
1003    /**
1004     * Tests 10.000 transactions where each of them creates 10 objects using 4
1005     * thread.
1006     */
1007    public void testCreationTh4Tx10000Cr10() {
1008
1009        if (!interactive) {
1010            perform(4, 10000, 1000000, new CreationCtx(10, getStartId(ID_Th4Tx10000Cr10)));
1011        }
1012    }
1013
1014    /**
1015     * Tests 100.000 transactions where each of them creates 10 objects using 4
1016     * thread.
1017     */
1018    public void testCreationTh4Tx100000Cr10() {
1019
1020        if (!interactive) {
1021            perform(4, 100000, 1000000, new CreationCtx(10, getStartId(ID_Th4Tx100000Cr10)));
1022        }
1023    }
1024
1025    /**
1026     * Tests 10 transactions where each of them creates 100 objects using 4
1027     * thread.
1028     */
1029    public void testCreationTh4Tx10Cr100() {
1030
1031        if (!interactive) {
1032            perform(4, 10, 1000000, new CreationCtx(100, getStartId(ID_Th4Tx10Cr100)));
1033        }
1034    }
1035
1036    /**
1037     * Tests 100 transactions where each of them creates 100 objects using 4
1038     * thread.
1039     */
1040    public void testCreationTh4Tx100Cr100() {
1041
1042        if (!interactive) {
1043            perform(4, 100, 1000000, new CreationCtx(100, getStartId(ID_Th4Tx100Cr100)));
1044        }
1045    }
1046
1047    /**
1048     * Tests 1.000 transactions where each of them creates 100 objects using 4
1049     * thread.
1050     */
1051    public void testCreationTh4Tx1000Cr100() {
1052
1053        if (!interactive) {
1054            perform(4, 1000, 1000000, new CreationCtx(100, getStartId(ID_Th4Tx1000Cr100)));
1055        }
1056    }
1057
1058    /**
1059     * Tests 10.000 transactions where each of them creates 100 objects using 4
1060     * thread.
1061     */
1062    public void testCreationTh4Tx10000Cr100() {
1063
1064        if (!interactive) {
1065            perform(4, 10000, 1000000, new CreationCtx(100, getStartId(ID_Th4Tx10000Cr100)));
1066        }
1067    }
1068
1069    /**
1070     * Tests 10 transactions where each of them creates 500 objects using 4
1071     * thread.
1072     */
1073    public void testCreationTh4Tx10Cr500() {
1074
1075        if (!interactive) {
1076            perform(4, 10, 1000000, new CreationCtx(500, getStartId(ID_Th4Tx10Cr500)));
1077        }
1078    }
1079
1080    /**
1081     * Tests 100 transactions where each of them creates 500 objects using 4
1082     * thread.
1083     */
1084    public void testCreationTh4Tx100Cr500() {
1085
1086        if (!interactive) {
1087            perform(4, 100, 1000000, new CreationCtx(500, getStartId(ID_Th4Tx100Cr500)));
1088        }
1089    }
1090
1091    /**
1092     * Tests 1.000 transactions where each of them creates 500 objects using 4
1093     * thread.
1094     */
1095    public void testCreationTh4Tx1000Cr500() {
1096
1097        if (!interactive) {
1098            perform(4, 1000, 1000000, new CreationCtx(500, getStartId(ID_Th4Tx1000Cr500)));
1099        }
1100    }
1101
1102    /**
1103     * Tests 10 transactions where each of them creates 1.000 objects using 4
1104     * thread.
1105     */
1106    public void testCreationTh4Tx10Cr1000() {
1107
1108        if (!interactive) {
1109            perform(4, 10, 1000000, new CreationCtx(1000, getStartId(ID_Th4Tx10Cr1000)));
1110        }
1111    }
1112
1113    /**
1114     * Tests 100 transactions where each of them creates 1.000 objects using 4
1115     * thread.
1116     */
1117    public void testCreationTh4Tx100Cr1000() {
1118
1119        if (!interactive) {
1120            perform(4, 100, 1000000, new CreationCtx(1000, getStartId(ID_Th4Tx100Cr1000)));
1121        }
1122    }
1123
1124    /**
1125     * Tests 1.000 transactions where each of them creates 1.000 objects using
1126     * 1 thread.
1127     */
1128    public void testCreationTh4Tx1000Cr1000() {
1129
1130        if (!interactive) {
1131            perform(4, 1000, 1000000, new CreationCtx(1000, getStartId(ID_Th4Tx100Cr1000)));
1132        }
1133    }
1134
1135    /**
1136     * Tests 10 transactions where each of them creates 2.000 objects using 4
1137     * thread.
1138     */
1139    public void testCreationTh4Tx10Cr2000() {
1140
1141        if (!interactive) {
1142            perform(4, 10, 1000000, new CreationCtx(2000, getStartId(ID_Th4Tx10Cr2000)));
1143        }
1144    }
1145
1146    /**
1147     * Tests 100 transactions where each of them creates 2.000 objects using 4
1148     * thread.
1149     */
1150    public void testCreationTh4Tx100Cr2000() {
1151
1152        if (!interactive) {
1153            perform(4, 100, 1000000, new CreationCtx(2000, getStartId(ID_Th4Tx100Cr2000)));
1154        }
1155    }
1156
1157    /**
1158     * Tests 1.000 transactions where each of them creates 2.000 objects using
1159     * 1 thread.
1160     */
1161    public void testCreationTh4Tx1000Cr2000() {
1162
1163        if (!interactive) {
1164            perform(4, 1000, 1000000, new CreationCtx(2000, getStartId(ID_Th4Tx1000Cr2000)));
1165        }
1166    }
1167
1168    /**
1169     * Tests 10 transactions where each of them creates 10.000 objects using 4
1170     * thread.
1171     */
1172    public void testCreationTh4Tx10Cr10000() {
1173        if (!interactive) {
1174            perform(4, 10, 1000000, new CreationCtx(10000, getStartId(ID_Th4Tx10Cr10000)));
1175        }
1176    }
1177
1178    /**
1179     * Tests 100 transactions where each of them creates 10.000 objects using 4
1180     * thread.
1181     */
1182    public void testCreationTh4Tx100Cr10000() {
1183
1184        if (!interactive) {
1185            perform(4, 100, 1000000, new CreationCtx(10000, getStartId(ID_Th4Tx100Cr10000)));
1186        }
1187    }
1188
1189
1190    ///////////////////////////////////////////////////////////////////////////
1191 ///////////////////////////////////////////////////////////////////////////
1192
1193    /**
1194     * Tests 10 transactions where each of them creates 1 object using 10
1195     * thread.
1196     */
1197    public void testCreationTh10Tx10Cr1() {
1198
1199        if (!interactive) {
1200            perform(10, 10, 1000000, new CreationCtx(1, getStartId(ID_Th10Tx10Cr1)));
1201        }
1202    }
1203
1204    /**
1205     * Tests 100 transactions where each of them creates 1 object using 10
1206     * thread.
1207     */
1208    public void testCreationTh10Tx100Cr1() {
1209
1210        if (!interactive) {
1211            perform(10, 100, 1000000, new CreationCtx(1, getStartId(ID_Th10Tx100Cr1)));
1212        }
1213    }
1214
1215    /**
1216     * Tests 1.000 transactions where each of them creates 1 object using 10
1217     * thread.
1218     */
1219    public void testCreationTh10Tx1000Cr1() {
1220
1221        if (!interactive) {
1222            perform(10, 1000, 1000000, new CreationCtx(1, getStartId(ID_Th10Tx1000Cr1)));
1223        }
1224    }
1225
1226    /**
1227     * Tests 10.000 transactions where each of them creates 1 object using 10
1228     * thread.
1229     */
1230    public void testCreationTh10Tx10000Cr1() {
1231
1232        if (!interactive) {
1233            perform(10, 10000, 1000000, new CreationCtx(1, getStartId(ID_Th10Tx10000Cr1)));
1234        }
1235    }
1236
1237    /**
1238     * Tests 100.000 transactions where each of them creates 1 object using 10
1239     * thread.
1240     */
1241    public void testCreationTh10Tx100000Cr1() {
1242
1243        if (!interactive) {
1244            perform(10, 100000, 1000000, new CreationCtx(1, getStartId(ID_Th10Tx100000Cr1)));
1245        }
1246    }
1247
1248    /**
1249     * Tests 10 transactions where each of them creates 10 objects using 10
1250     * thread.
1251     */
1252    public void testCreationTh10Tx10Cr10() {
1253
1254        if (!interactive) {
1255            perform(10, 10, 1000000, new CreationCtx(10, getStartId(ID_Th10Tx10Cr10)));
1256        }
1257    }
1258
1259    /**
1260     * Tests 100 transactions where each of them creates 10 objects using 10
1261     * thread.
1262     */
1263    public void testCreationTh10Tx100Cr10() {
1264
1265        if (!interactive) {
1266            perform(10, 100, 1000000, new CreationCtx(10, getStartId(ID_Th10Tx100Cr10)));
1267        }
1268    }
1269
1270    /**
1271     * Tests 1.000 transactions where each of them creates 10 objects using 10
1272     * thread.
1273     */
1274    public void testCreationTh10Tx1000Cr10() {
1275
1276        if (!interactive) {
1277            perform(10, 1000, 1000000, new CreationCtx(10, getStartId(ID_Th10Tx1000Cr10)));
1278        }
1279    }
1280
1281    /**
1282     * Tests 10.000 transactions where each of them creates 10 objects using 10
1283     * thread.
1284     */
1285    public void testCreationTh10Tx10000Cr10() {
1286
1287        if (!interactive) {
1288            perform(10, 10000, 1000000, new CreationCtx(10, getStartId(ID_Th10Tx10000Cr10)));
1289        }
1290    }
1291
1292    /**
1293     * Tests 100.000 transactions where each of them creates 10 objects using 10
1294     * thread.
1295     */
1296    public void testCreationTh10Tx100000Cr10() {
1297
1298        if (!interactive) {
1299            perform(10, 100000, 1000000, new CreationCtx(10, getStartId(ID_Th10Tx100000Cr10)));
1300        }
1301    }
1302
1303    /**
1304     * Tests 10 transactions where each of them creates 100 objects using 10
1305     * thread.
1306     */
1307    public void testCreationTh10Tx10Cr100() {
1308
1309        if (!interactive) {
1310            perform(10, 10, 1000000, new CreationCtx(100, getStartId(ID_Th10Tx10Cr100)));
1311        }
1312    }
1313
1314    /**
1315     * Tests 100 transactions where each of them creates 100 objects using 10
1316     * thread.
1317     */
1318    public void testCreationTh10Tx100Cr100() {
1319
1320        if (!interactive) {
1321            perform(10, 100, 1000000, new CreationCtx(100, getStartId(ID_Th10Tx100Cr100)));
1322        }
1323    }
1324
1325    /**
1326     * Tests 1.000 transactions where each of them creates 100 objects using 10
1327     * thread.
1328     */
1329    public void testCreationTh10Tx1000Cr100() {
1330
1331        if (!interactive) {
1332            perform(10, 1000, 1000000, new CreationCtx(100, getStartId(ID_Th10Tx1000Cr100)));
1333        }
1334    }
1335
1336    /**
1337     * Tests 10.000 transactions where each of them creates 100 objects using 10
1338     * thread.
1339     */
1340    public void testCreationTh10Tx10000Cr100() {
1341
1342        if (!interactive) {
1343            perform(10, 10000, 1000000, new CreationCtx(100, getStartId(ID_Th10Tx10000Cr100)));
1344        }
1345    }
1346
1347    /**
1348     * Tests 10 transactions where each of them creates 500 objects using 10
1349     * thread.
1350     */
1351    public void testCreationTh10Tx10Cr500() {
1352
1353        if (!interactive) {
1354            perform(10, 10, 1000000, new CreationCtx(500, getStartId(ID_Th10Tx10Cr500)));
1355        }
1356    }
1357
1358    /**
1359     * Tests 100 transactions where each of them creates 500 objects using 10
1360     * thread.
1361     */
1362    public void testCreationTh10Tx100Cr500() {
1363
1364        if (!interactive) {
1365            perform(10, 100, 1000000, new CreationCtx(500, getStartId(ID_Th10Tx100Cr500)));
1366        }
1367    }
1368
1369    /**
1370     * Tests 1.000 transactions where each of them creates 500 objects using 10
1371     * thread.
1372     */
1373    public void testCreationTh10Tx1000Cr500() {
1374
1375        if (!interactive) {
1376            perform(10, 1000, 1000000, new CreationCtx(500, getStartId(ID_Th10Tx1000Cr500)));
1377        }
1378    }
1379
1380    /**
1381     * Tests 10 transactions where each of them creates 1.000 objects using 10
1382     * thread.
1383     */
1384    public void testCreationTh10Tx10Cr1000() {
1385
1386        if (!interactive) {
1387            perform(10, 10, 1000000, new CreationCtx(1000, getStartId(ID_Th10Tx10Cr1000)));
1388        }
1389    }
1390
1391    /**
1392     * Tests 100 transactions where each of them creates 1.000 objects using 10
1393     * thread.
1394     */
1395    public void testCreationTh10Tx100Cr1000() {
1396
1397        if (!interactive) {
1398            perform(10, 100, 1000000, new CreationCtx(1000, getStartId(ID_Th10Tx100Cr1000)));
1399        }
1400    }
1401
1402    /**
1403     * Tests 1.000 transactions where each of them creates 1.000 objects using
1404     * 1 thread.
1405     */
1406    public void testCreationTh10Tx1000Cr1000() {
1407
1408        if (!interactive) {
1409            perform(10, 1000, 1000000, new CreationCtx(1000, getStartId(ID_Th10Tx100Cr1000)));
1410        }
1411    }
1412
1413    /**
1414     * Tests 10 transactions where each of them creates 2.000 objects using 10
1415     * thread.
1416     */
1417    public void testCreationTh10Tx10Cr2000() {
1418
1419        if (!interactive) {
1420            perform(10, 10, 1000000, new CreationCtx(2000, getStartId(ID_Th10Tx10Cr2000)));
1421        }
1422    }
1423
1424    /**
1425     * Tests 100 transactions where each of them creates 2.000 objects using 10
1426     * thread.
1427     */
1428    public void testCreationTh10Tx100Cr2000() {
1429
1430        if (!interactive) {
1431            perform(10, 100, 1000000, new CreationCtx(2000, getStartId(ID_Th10Tx100Cr2000)));
1432        }
1433    }
1434
1435    /**
1436     * Tests 1.000 transactions where each of them creates 2.000 objects using
1437     * 1 thread.
1438     */
1439    public void testCreationTh10Tx1000Cr2000() {
1440
1441        if (!interactive) {
1442            perform(10, 1000, 1000000, new CreationCtx(2000, getStartId(ID_Th10Tx1000Cr2000)));
1443        }
1444    }
1445
1446    /**
1447     * Tests 10 transactions where each of them creates 10.000 objects using 10
1448     * thread.
1449     */
1450    public void testCreationTh10Tx10Cr10000() {
1451
1452            
1453        if (!interactive) {
1454            perform(10, 10, 1000000, new CreationCtx(10000, getStartId(ID_Th10Tx10Cr10000)));
1455        }
1456    }
1457
1458    /**
1459     * Tests 100 transactions where each of them creates 10.000 objects using 10
1460     * thread.
1461     */
1462    public void testCreationTh10Tx100Cr10000() {
1463
1464        if (!interactive) {
1465            perform(10, 100, 1000000, new CreationCtx(10000, getStartId(ID_Th10Tx100Cr10000)));
1466        }
1467    }
1468
1469}
1470
Popular Tags