001: /**
002: * Copyright (C) 2001-2004 France Telecom R&D
003: *
004: * This library is free software; you can redistribute it and/or
005: * modify it under the terms of the GNU Lesser General Public
006: * License as published by the Free Software Foundation; either
007: * version 2 of the License, or (at your option) any later version.
008: *
009: * This library is distributed in the hope that it will be useful,
010: * but WITHOUT ANY WARRANTY; without even the implied warranty of
011: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
012: * Lesser General Public License for more details.
013: *
014: * You should have received a copy of the GNU Lesser General Public
015: * License along with this library; if not, write to the Free Software
016: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
017: */package org.objectweb.speedo.runtime.relations;
018:
019: import java.util.ArrayList;
020: import java.util.Arrays;
021: import java.util.Collection;
022: import java.util.Iterator;
023:
024: import javax.jdo.PersistenceManager;
025: import javax.jdo.Query;
026:
027: import org.objectweb.speedo.SpeedoTestHelper;
028: import org.objectweb.speedo.pobjects.relations.C;
029: import org.objectweb.speedo.pobjects.relations.D;
030: import org.objectweb.util.monolog.api.BasicLevel;
031:
032: /**
033: *
034: * @author S.Chassande-Barrioz
035: */
036: public class TestRelationsSeqId extends SpeedoTestHelper {
037:
038: public TestRelationsSeqId(String s) {
039: super (s);
040: }
041:
042: protected String getLoggerName() {
043: return LOG_NAME + "rt.relations.Relations";
044: }
045:
046: public void testOneOne() {
047: C c1 = new C("testOneOne_c1");
048: C c2 = new C("testOneOne_c2");
049: D d1 = new D("testOneOne_d1");
050: D d2 = new D("testOneOne_d2");
051:
052: c1.setD(d1);
053: assertTrue(d1.getC() == c1);
054:
055: c2.setD(d2);
056: assertTrue(d2.getC() == c2);
057:
058: c1.setD(d2);
059: assertTrue(d1.getC() == null);
060: assertTrue(d2.getC() == c1);
061: assertTrue(c2.getD() == null);
062:
063: d1.setC(c2);
064: assertTrue(c2.getD() == d1);
065:
066: d1.setC(c1);
067: assertTrue(c1.getD() == d1);
068: assertTrue(d2.getC() == null);
069: assertTrue(c2.getD() == null);
070: }
071:
072: public void testOneOne2() {
073: C c1 = new C("testOneOne_c1");
074: PersistenceManager pm = pmf.getPersistenceManager();
075:
076: pm.currentTransaction().begin();
077: pm.makePersistent(c1);
078: Object c1oid = pm.getObjectId(c1);
079: c1 = null;
080: pm.currentTransaction().commit();
081:
082: pm.evictAll();
083:
084: pm.currentTransaction().begin();
085: c1 = (C) pm.getObjectById(c1oid, false);
086: pm.deletePersistent(c1);
087: pm.currentTransaction().commit();
088:
089: pm.close();
090: }
091:
092: public void testOneMany() { // tests on active persistent objects
093: C c1 = new C("testOneMany_c1");
094: C c2 = new C("testOneMany_c2");
095:
096: D d1 = new D("testOneMany_d1");
097: D d2 = new D("testOneMany_d2");
098: D d3 = new D("testOneMany_d3");
099: D d4 = new D("testOneMany_d4");
100:
101: PersistenceManager pm = pmf.getPersistenceManager();
102: pm.makePersistent(c1);
103: pm.makePersistent(c2);
104: pm.makePersistent(d1);
105: pm.makePersistent(d2);
106: pm.makePersistent(d3);
107: pm.makePersistent(d4);
108: pm.close();
109:
110: try {
111: pm = pmf.getPersistenceManager();
112:
113: c1.getNds().add(d1);
114: assertTrue(d1.getNc() == c1);
115: c1.getNds().add(d2);
116: assertTrue(d2.getNc() == c1);
117:
118: c2.getNds().add(d3);
119: assertTrue(d3.getNc() == c2);
120: c2.getNds().add(d4);
121: assertTrue(d4.getNc() == c2);
122:
123: c1.getNds().add(d3);
124: assertTrue(d3.getNc() == c1);
125: assertTrue(!c2.getNds().contains(d3));
126:
127: c1.getNds().remove(d1);
128: assertTrue(d1.getNc() == null);
129:
130: d3.setNc(c2);
131: assertTrue(!c1.getNds().contains(d3));
132: assertTrue(c2.getNds().contains(d3));
133:
134: c1.setNds(c2.getNds());
135: // reload objects before testing effects of the above assignement
136: pm.close();
137: pm = pmf.getPersistenceManager();
138:
139: assertTrue(!c1.getNds().contains(d1));
140: assertTrue(!c1.getNds().contains(d2));
141: assertTrue(c1.getNds().contains(d3));
142: assertTrue(c1.getNds().contains(d4));
143:
144: assertTrue(!c2.getNds().contains(d1));
145: assertTrue(!c2.getNds().contains(d2));
146: assertTrue(!c2.getNds().contains(d3));
147: assertTrue(!c2.getNds().contains(d4));
148:
149: assertTrue(d1.getNc() == null);
150: assertTrue(d2.getNc() == null);
151: assertTrue(d3.getNc() == c1);
152: assertTrue(d4.getNc() == c1);
153:
154: pm.close();
155: } finally {
156: pm = pmf.getPersistenceManager();
157: pm.currentTransaction().begin();
158: pm.deletePersistent(c1);
159: pm.deletePersistent(c2);
160: pm.deletePersistent(d1);
161: pm.deletePersistent(d2);
162: pm.deletePersistent(d3);
163: pm.deletePersistent(d4);
164: pm.currentTransaction().commit();
165: pm.close();
166: }
167: }
168:
169: public void testOneMany2() { // tests on non persistent objects
170: C c1 = new C("testOneMany2_c1");
171: C c2 = new C("testOneMany2_c2");
172:
173: D d1 = new D("testOneMany2_d1");
174: D d2 = new D("testOneMany2_d2");
175: D d3 = new D("testOneMany2_d3");
176: D d4 = new D("testOneMany2_d4");
177:
178: PersistenceManager pm = pmf.getPersistenceManager();
179:
180: d1.setNc(c1);
181: // tests that c1.nds, initially null, is created and contains d1
182: assertTrue(c1.getNds() != null);
183: assertTrue(c1.getNds().contains(d1));
184:
185: d2.setNc(c1);
186: assertTrue(c1.getNds().contains(d2));
187:
188: d3.setNc(c2);
189: assertTrue(c2.getNds() != null);
190: assertTrue(c2.getNds().contains(d3));
191:
192: d4.setNc(c2);
193: assertTrue(c2.getNds().contains(d4));
194:
195: pm.makePersistent(c1);
196: pm.makePersistent(c2);
197:
198: pm.close();
199:
200: try {
201: pm = pmf.getPersistenceManager();
202:
203: Collection c = new ArrayList();
204: c.addAll(c2.getNds());
205: c1.setNds(c);
206:
207: pm.close();
208:
209: pm = pmf.getPersistenceManager();
210:
211: assertTrue(!c1.getNds().contains(d1));
212: assertTrue(!c1.getNds().contains(d2));
213: assertTrue(c1.getNds().contains(d3));
214: assertTrue(c1.getNds().contains(d4));
215:
216: assertTrue(c2.getNds().size() == 0);
217:
218: assertTrue(d1.getNc() == null);
219: assertTrue(d2.getNc() == null);
220: assertTrue(d3.getNc() == c1);
221: assertTrue(d4.getNc() == c1);
222:
223: pm.close();
224: } finally {
225: pm = pmf.getPersistenceManager();
226: pm.currentTransaction().begin();
227: pm.deletePersistent(c1);
228: pm.deletePersistent(c2);
229: pm.deletePersistent(d1);
230: pm.deletePersistent(d2);
231: pm.deletePersistent(d3);
232: pm.deletePersistent(d4);
233: pm.currentTransaction().commit();
234: pm.close();
235: }
236: }
237:
238: public void testOneMany3() { // tests with manually managed consistency
239: C c1 = new C("testOneMany3_c1");
240:
241: D d1 = new D("testOneMany3_d1");
242: D d2 = new D("testOneMany3_d2");
243:
244: PersistenceManager pm = pmf.getPersistenceManager();
245:
246: ArrayList l = new ArrayList();
247: l.add(d1);
248: l.add(d2);
249: c1.setNds(l);
250:
251: d1.setNc(c1);
252: d2.setNc(c1);
253:
254: assertTrue(c1.getNds().size() == 2);
255:
256: pm.makePersistent(c1);
257: pm.close();
258:
259: try {
260: pm = pmf.getPersistenceManager();
261: assertTrue(c1.getNds().size() == 2);
262: pm.close();
263: } finally {
264: pm = pmf.getPersistenceManager();
265: pm.currentTransaction().begin();
266: pm.deletePersistent(c1);
267: pm.deletePersistent(d1);
268: pm.deletePersistent(d2);
269: pm.currentTransaction().commit();
270: pm.close();
271: }
272: }
273:
274: public void testOneMany4() { // tests with manually managed consistency
275: PersistenceManager pm = pmf.getPersistenceManager();
276: C c1 = new C("testOneMany4_c1");
277: D d1 = new D("testOneMany4_d1");
278: ArrayList l = new ArrayList();
279: l.add(d1);
280: c1.setNds(l);
281: d1.setNc(c1);
282: assertTrue(c1.getNds().size() == 1);
283:
284: pm.currentTransaction().begin();
285: pm.makePersistent(c1);
286: pm.currentTransaction().commit();
287: try {
288: assertNotNull("c1 not written", found(C.class,
289: "testOneMany4_c1", pm));
290: assertNotNull("d1 not written", found(D.class,
291: "testOneMany4_d1", pm));
292: } finally {
293: pm.close();
294: }
295:
296: pm = pmf.getPersistenceManager();
297: D d2 = new D("testOneMany4_d2");
298: d2.setNc(c1);
299: pm.close();
300:
301: pm = pmf.getPersistenceManager();
302: pm.currentTransaction().begin();
303: pm.deletePersistent(c1);
304: pm.deletePersistent(d1);
305: pm.deletePersistent(d2);
306: pm.currentTransaction().commit();
307: pm.close();
308: pm = pmf.getPersistenceManager();
309: try {
310: assertNull("c1 was not removed", found(C.class,
311: "testOneMany4_c1", pm));
312: assertNull("d1 was not removed", found(D.class,
313: "testOneMany4_d1", pm));
314: assertNull("d2 was not removed", found(D.class,
315: "testOneMany4_d2", pm));
316: } finally {
317: pm.close();
318: }
319: }
320:
321: public void testManyMany() { // tests on active persistent objects
322: C c1 = new C("testManyMany_c1");
323: C c2 = new C("testManyMany_c2");
324: C c3 = new C("testManyMany_c3");
325:
326: D d1 = new D("testManyMany_d1");
327: D d2 = new D("testManyMany_d2");
328: D d3 = new D("testManyMany_d3");
329:
330: PersistenceManager pm = pmf.getPersistenceManager();
331: pm.makePersistent(c1);
332: pm.makePersistent(c2);
333: pm.makePersistent(c3);
334: pm.makePersistent(d1);
335: pm.makePersistent(d2);
336: pm.makePersistent(d3);
337: pm.close();
338:
339: try {
340: pm = pmf.getPersistenceManager();
341: c1.getDs().add(d1);
342: assertTrue(d1.getCs().contains(c1));
343: c1.getDs().add(d2);
344: assertTrue(d2.getCs().contains(c1));
345:
346: c2.getDs().add(d1);
347: assertTrue(d1.getCs().contains(c2));
348: c2.getDs().add(d2);
349: assertTrue(d2.getCs().contains(c2));
350: c2.getDs().add(d3);
351: assertTrue(d3.getCs().contains(c2));
352:
353: c3.getDs().add(d2);
354: assertTrue(d2.getCs().contains(c3));
355: c3.getDs().add(d3);
356: assertTrue(d3.getCs().contains(c3));
357:
358: c1.getDs().add(d3);
359: assertTrue(d3.getCs().contains(c1));
360:
361: c1.getDs().remove(d1);
362: assertTrue(!d1.getCs().contains(c1));
363:
364: d2.getCs().remove(c2);
365: assertTrue(!c2.getDs().contains(d2));
366:
367: c1.setDs(c2.getDs());
368: // reload objects before testing effects of the above assignement
369: pm.close();
370: pm = pmf.getPersistenceManager();
371: assertTrue(c1.getDs().contains(d1));
372: assertTrue(!c1.getDs().contains(d2));
373: assertTrue(c1.getDs().contains(d3));
374:
375: assertTrue(c2.getDs().contains(d1));
376: assertTrue(!c2.getDs().contains(d2));
377: assertTrue(c2.getDs().contains(d3));
378:
379: assertTrue(!c3.getDs().contains(d1));
380: assertTrue(c3.getDs().contains(d2));
381: assertTrue(c3.getDs().contains(d3));
382:
383: assertTrue(d1.getCs().contains(c1));
384: assertTrue(d1.getCs().contains(c2));
385: assertTrue(!d1.getCs().contains(c3));
386:
387: assertTrue(!d2.getCs().contains(c1));
388: assertTrue(!d2.getCs().contains(c2));
389: assertTrue(d2.getCs().contains(c3));
390:
391: assertTrue(d3.getCs().contains(c1));
392: assertTrue(d3.getCs().contains(c2));
393: assertTrue(d3.getCs().contains(c3));
394:
395: pm.close();
396: } finally {
397: pm = pmf.getPersistenceManager();
398: pm.currentTransaction().begin();
399: pm.deletePersistent(c1);
400: pm.deletePersistent(c2);
401: pm.deletePersistent(c3);
402: pm.deletePersistent(d1);
403: pm.deletePersistent(d2);
404: pm.deletePersistent(d3);
405: pm.currentTransaction().commit();
406: pm.close();
407: }
408: }
409:
410: public void testManyMany2() { // tests on non persistent objects
411: C c1 = new C("testManyMany2_c1");
412: C c2 = new C("testManyMany2_c2");
413: C c3 = new C("testManyMany2_c3");
414:
415: D d1 = new D("testManyMany2_d1");
416: D d2 = new D("testManyMany2_d2");
417: D d3 = new D("testManyMany2_d3");
418:
419: PersistenceManager pm = pmf.getPersistenceManager();
420:
421: c1.getDs().add(d1);
422: c1.getDs().add(d2);
423:
424: c2.getDs().add(d1);
425: c2.getDs().add(d2);
426: c2.getDs().add(d3);
427:
428: c3.getDs().add(d2);
429: c3.getDs().add(d3);
430:
431: pm.makePersistent(c1);
432: pm.makePersistent(c2);
433: pm.makePersistent(c3);
434: pm.close();
435:
436: try {
437: pm = pmf.getPersistenceManager();
438: assertTrue(d1.getCs().contains(c1));
439: assertTrue(d2.getCs().contains(c1));
440:
441: assertTrue(d1.getCs().contains(c2));
442: assertTrue(d2.getCs().contains(c2));
443: assertTrue(d3.getCs().contains(c2));
444:
445: assertTrue(d2.getCs().contains(c3));
446: assertTrue(d3.getCs().contains(c3));
447:
448: Collection c = new ArrayList();
449: c.addAll(c2.getDs());
450: c1.setDs(c);
451:
452: pm.close();
453:
454: pm = pmf.getPersistenceManager();
455: assertTrue(c1.getDs().contains(d1));
456: assertTrue(c1.getDs().contains(d2));
457: assertTrue(c1.getDs().contains(d3));
458:
459: assertTrue(c2.getDs().contains(d1));
460: assertTrue(c2.getDs().contains(d2));
461: assertTrue(c2.getDs().contains(d3));
462:
463: assertTrue(!c3.getDs().contains(d1));
464: assertTrue(c3.getDs().contains(d2));
465: assertTrue(c3.getDs().contains(d3));
466:
467: assertTrue(d1.getCs().contains(c1));
468: assertTrue(d1.getCs().contains(c2));
469: assertTrue(!d1.getCs().contains(c3));
470:
471: assertTrue(d2.getCs().contains(c1));
472: assertTrue(d2.getCs().contains(c2));
473: assertTrue(d2.getCs().contains(c3));
474:
475: assertTrue(d3.getCs().contains(c1));
476: assertTrue(d3.getCs().contains(c2));
477: assertTrue(d3.getCs().contains(c3));
478:
479: pm.close();
480: } finally {
481: pm = pmf.getPersistenceManager();
482: pm.currentTransaction().begin();
483: pm.deletePersistent(c1);
484: pm.deletePersistent(c2);
485: pm.deletePersistent(c3);
486: pm.deletePersistent(d1);
487: pm.deletePersistent(d2);
488: pm.deletePersistent(d3);
489: pm.currentTransaction().commit();
490: pm.close();
491: }
492: }
493:
494: public void testManyMany3() { // tests with manually managed consistency
495: C c1 = new C("testManyMany3_c1");
496: C c2 = new C("testManyMany3_c2");
497: C c3 = new C("testManyMany3_c3");
498:
499: D d1 = new D("testManyMany3_d1");
500: D d2 = new D("testManyMany3_d2");
501: D d3 = new D("testManyMany3_d3");
502:
503: PersistenceManager pm = pmf.getPersistenceManager();
504:
505: c1.setDs(Arrays.asList(new Object[] { d1, d2 }));
506: c2.setDs(Arrays.asList(new Object[] { d1, d2, d3 }));
507: c3.setDs(Arrays.asList(new Object[] { d2, d3 }));
508:
509: d1.setCs(Arrays.asList(new Object[] { c1, c2 }));
510: d2.setCs(Arrays.asList(new Object[] { c1, c2, c3 }));
511: d3.setCs(Arrays.asList(new Object[] { c2, c3 }));
512:
513: pm.makePersistent(c1);
514: pm.makePersistent(c2);
515: pm.makePersistent(c3);
516: pm.close();
517:
518: try {
519: pm = pmf.getPersistenceManager();
520: assertTrue(c1.getDs().size() == 2);
521: assertTrue(c1.getDs().contains(d1));
522: assertTrue(c1.getDs().contains(d2));
523:
524: assertTrue(c2.getDs().size() == 3);
525: assertTrue(c2.getDs().contains(d1));
526: assertTrue(c2.getDs().contains(d2));
527: assertTrue(c2.getDs().contains(d3));
528:
529: assertTrue(c3.getDs().size() == 2);
530: assertTrue(c3.getDs().contains(d2));
531: assertTrue(c3.getDs().contains(d3));
532:
533: assertTrue(d1.getCs().size() == 2);
534: assertTrue(d1.getCs().contains(c1));
535: assertTrue(d1.getCs().contains(c2));
536:
537: assertTrue(d2.getCs().size() == 3);
538: assertTrue(d2.getCs().contains(c1));
539: assertTrue(d2.getCs().contains(c2));
540: assertTrue(d2.getCs().contains(c3));
541:
542: assertTrue(d3.getCs().size() == 2);
543: assertTrue(d3.getCs().contains(c2));
544: assertTrue(d3.getCs().contains(c3));
545:
546: pm.close();
547: } finally {
548: pm = pmf.getPersistenceManager();
549: pm.currentTransaction().begin();
550: pm.deletePersistent(c1);
551: pm.deletePersistent(c2);
552: pm.deletePersistent(c3);
553: pm.deletePersistent(d1);
554: pm.deletePersistent(d2);
555: pm.deletePersistent(d3);
556: pm.currentTransaction().commit();
557: pm.close();
558: }
559: }
560:
561: public void testManyManyDelete() {
562: C c1 = new C("testManyManyDelete_c1");
563: C c2 = new C("testManyManyDelete_c2");
564: C c3 = new C("testManyManyDelete_c3");
565:
566: D d1 = new D("testManyManyDelete_d1");
567: D d2 = new D("testManyManyDelete_d2");
568: D d3 = new D("testManyManyDelete_d3");
569:
570: PersistenceManager pm = pmf.getPersistenceManager();
571: pm.makePersistent(c1);
572: pm.makePersistent(c2);
573: pm.makePersistent(c3);
574: pm.makePersistent(d1);
575: pm.makePersistent(d2);
576: pm.makePersistent(d3);
577: logger.log(BasicLevel.DEBUG,
578: "testManyManyDelete:after makePersistent");
579: pm.close();
580: logger.log(BasicLevel.DEBUG, "testManyManyDelete:after close");
581:
582: try {
583: pm = pmf.getPersistenceManager();
584:
585: c1.getDs().add(d1);
586:
587: c1.getDs().add(d2);
588:
589: c2.getDs().add(d1);
590: c2.getDs().add(d2);
591: c2.getDs().add(d3);
592:
593: c3.getDs().add(d2);
594: c3.getDs().add(d3);
595:
596: logger.log(BasicLevel.DEBUG,
597: "testManyManyDelete:after ad collection content");
598:
599: pm.close();
600: logger.log(BasicLevel.DEBUG,
601: "testManyManyDelete:after close");
602:
603: pm = pmf.getPersistenceManager();
604: pm.currentTransaction().begin();
605: assertTrue(d1.getCs().contains(c1));
606: assertTrue(d2.getCs().contains(c1));
607: assertTrue(d1.getCs().contains(c2));
608: assertTrue(d2.getCs().contains(c2));
609: assertTrue(d3.getCs().contains(c2));
610: assertTrue(d2.getCs().contains(c3));
611: assertTrue(d3.getCs().contains(c3));
612:
613: pm.deletePersistent(d2);
614: logger.log(BasicLevel.DEBUG,
615: "testManyManyDelete:after delete d2");
616: pm.currentTransaction().commit();
617: pm.close();
618: logger.log(BasicLevel.DEBUG,
619: "testManyManyDelete:after close");
620:
621: pm = pmf.getPersistenceManager();
622:
623: assertTrue(c1.getDs().size() == 1);
624: logger.log(BasicLevel.DEBUG,
625: "testManyManyDelete:c1.nds.size()==1 : "
626: + (c1.getDs().size() == 1));
627: assertTrue(c1.getDs().contains(d1));
628: logger.log(BasicLevel.DEBUG,
629: "testManyManyDelete:c1.nds.contains(d1) : "
630: + (c1.getDs().contains(d1)));
631:
632: assertTrue(c2.getDs().size() == 2);
633: logger.log(BasicLevel.DEBUG,
634: "testManyManyDelete:c2.nds.size()==1 : "
635: + (c2.getDs().size() == 1));
636: assertTrue(c2.getDs().contains(d1));
637: logger.log(BasicLevel.DEBUG,
638: "testManyManyDelete:c2.nds.contains(d1) : "
639: + (c2.getDs().contains(d1)));
640: assertTrue(c2.getDs().contains(d3));
641: logger.log(BasicLevel.DEBUG,
642: "testManyManyDelete:c2.nds.contains(d3) : "
643: + (c2.getDs().contains(d3)));
644:
645: assertTrue(c3.getDs().size() == 1);
646: logger.log(BasicLevel.DEBUG,
647: "testManyManyDelete:c3.nds.size()==1 : "
648: + (c3.getDs().size() == 1));
649: assertTrue(c3.getDs().contains(d3));
650: logger.log(BasicLevel.DEBUG,
651: "testManyManyDelete:c3.nds.contains(d3) : "
652: + (c3.getDs().contains(d3)));
653:
654: assertTrue(d1.getCs().contains(c1));
655: logger.log(BasicLevel.DEBUG,
656: "testManyManyDelete:d1.cs.contains(c1) : "
657: + (d1.getCs().contains(c1)));
658: assertTrue(d1.getCs().contains(c2));
659: logger.log(BasicLevel.DEBUG,
660: "testManyManyDelete:d1.cs.contains(c2) : "
661: + (d1.getCs().contains(c2)));
662: assertTrue(!d1.getCs().contains(c3));
663: logger.log(BasicLevel.DEBUG,
664: "testManyManyDelete:!d1.cs.contains(c3) : "
665: + (!d1.getCs().contains(c3)));
666:
667: assertTrue(!d3.getCs().contains(c1));
668: logger.log(BasicLevel.DEBUG,
669: "testManyManyDelete:!d3.cs.contains(c1) : "
670: + (!d3.getCs().contains(c1)));
671: assertTrue(d3.getCs().contains(c2));
672: logger.log(BasicLevel.DEBUG,
673: "testManyManyDelete:d3.cs.contains(c2) : "
674: + (d3.getCs().contains(c2)));
675: assertTrue(d3.getCs().contains(c3));
676: logger.log(BasicLevel.DEBUG,
677: "testManyManyDelete:d3.cs.contains(c3) : "
678: + (d3.getCs().contains(c3)));
679:
680: pm.close();
681: logger.log(BasicLevel.DEBUG,
682: "testManyManyDelete:after close()");
683: } finally {
684: pm = pmf.getPersistenceManager();
685: pm.currentTransaction().begin();
686: pm.deletePersistent(c1);
687: pm.deletePersistent(c2);
688: pm.deletePersistent(c3);
689: pm.deletePersistent(d1);
690: pm.deletePersistent(d3);
691: logger.log(BasicLevel.DEBUG,
692: "testManyManyDelete:after deletes()");
693: pm.currentTransaction().commit();
694: pm.close();
695: logger.log(BasicLevel.DEBUG,
696: "testManyManyDelete:after close()");
697: }
698: logger.log(BasicLevel.DEBUG, "testManyManyDelete:end");
699: }
700:
701: private Object found(Class clazz, String name, PersistenceManager pm) {
702: Query q = pm.newQuery(clazz);
703: q.setFilter("(name == p1)");
704: q.declareParameters("String p1");
705: Collection res = (Collection) q.execute(name);
706: Iterator it = res.iterator();
707: try {
708: if (it.hasNext()) {
709: return it.next();
710: } else {
711: return null;
712: }
713: } finally {
714: q.closeAll();
715: }
716: }
717: }
|