1 package org.melati.poem.test;
2
3 import org.melati.poem.*;
4 import org.melati.poem.User;
5
6 import java.io.ByteArrayOutputStream;
7 import java.io.PrintStream;
8 import java.text.DateFormat;
9 import java.util.Enumeration;
10
11
12
13
14
15 public class PersistentTest extends EverythingTestCase {
16
17 public PersistentTest(String name) {
18 super(name);
19 }
20
21 protected void setUp()
22 throws Exception {
23 super.setUp();
24 }
25
26 protected void tearDown()
27 throws Exception {
28 super.tearDown();
29 }
30
31
32
33
34
35 public void testInvalidate() {
36 getDb().uncache();
37 JdbcPersistent p = (JdbcPersistent)getDb().getUserTable().newPersistent();
38 try {
39 p.invalidate();
40 fail("Should have blown up");
41 } catch (InvalidOperationOnFloatingPersistentPoemException e) {
42 e = null;
43 }
44
45
46 int hits = getDb().getQueryCount();
47 int hits2 = getDb().getQueryCount();
48 getDb().getUserTable().guestUser();
49 getDb().getUserTable().guestUser();
50 int hits3 = getDb().getQueryCount();
51 getDb().uncache();
52 int hits4 = getDb().getQueryCount();
53 getDb().getUserTable().guestUser();
54 int hits5 = getDb().getQueryCount();
55 assertTrue(hits == hits2);
56 assertTrue(hits == hits3);
57 assertTrue(hits == hits4);
58 assertTrue(hits == hits5);
59
60
61 getDb().getUserTable().count();
62 int countHits1 = getDb().getQueryCount();
63 assertEquals(hits5 + 1, countHits1 );
64 getDb().getUserTable().count();
65 int countHits2 = getDb().getQueryCount();
66
67 assertEquals(countHits1 + 1, countHits2);
68
69
70
71 getDb().getUserTable().selection();
72 int selectionHits1 = getDb().getQueryCount();
73 getDb().getUserTable().selection();
74 int selectionHits2 = getDb().getQueryCount();
75 assertEquals(selectionHits1, selectionHits2);
76 getDb().uncache();
77 getDb().getUserTable().selection();
78 int selectionHits3 = getDb().getQueryCount();
79 assertEquals(selectionHits2 + 1, selectionHits3);
80
81 getDb().getUserTable().getUserObject(0);
82 int getHits1 = getDb().getQueryCount();
83
84 assertEquals(selectionHits3 + 1, getHits1);
85 getDb().uncache();
86 getDb().getUserTable().getUserObject(0);
87 int getHits2 = getDb().getQueryCount();
88 assertEquals(getHits1 + 1, getHits2);
89
90 Persistent p2 = getDb().getUserTable().newPersistent();
91 p2.setCooked("name", "testuser");
92 p2.setCooked("login", "testuser");
93 p2.setCooked("password", "testuser");
94 p2.makePersistent();
95 int getHits3 = getDb().getQueryCount();
96
97 assertEquals(getHits2 + 3, getHits3);
98 p2.delete();
99 PoemThread.commit();
100 }
101
102
103
104
105
106 public void testPersistent() {
107
108 }
109
110
111
112
113 public void testPersistentStringString() {
114 Persistent p = new JdbcPersistent("user", "0");
115 try {
116 p.makePersistent();
117 fail("Should have blown up");
118 } catch (DoubleCreatePoemException e) {
119 e = null;
120 }
121 p = new JdbcPersistent(getDb().getUserTable(), new Integer(2));
122 try {
123 p.makePersistent();
124 fail("Should have blown up");
125 } catch (DoubleCreatePoemException e) {
126 e = null;
127 }
128 }
129
130
131
132
133 public void testPersistentTableInteger() {
134 Persistent p = new JdbcPersistent(getDb().getUserTable(), new Integer(0));
135 try {
136 p.makePersistent();
137 fail("Should have blown up");
138 } catch (DoubleCreatePoemException e) {
139 e = null;
140 }
141 p = new JdbcPersistent(getDb().getUserTable(), new Integer(2));
142 try {
143 p.makePersistent();
144 fail("Should have blown up");
145 } catch (DoubleCreatePoemException e) {
146 e = null;
147 }
148 }
149
150
151
152
153
154 public void testStatusNonexistent() {
155
156 }
157
158
159
160
161 public void testStatusExistent() {
162
163 }
164
165
166
167
168 public void testMakePersistent() {
169
170 }
171
172
173
174
175
176 public void testGetTable() {
177
178 }
179
180
181
182
183
184 public void testGetDatabase() {
185 Persistent p = new JdbcPersistent(getDb().getUserTable(), new Integer(0));
186 assertEquals(p.getDatabase(), getDb());
187 }
188
189
190
191
192 public void testTroid() {
193 Persistent p = new JdbcPersistent();
194 assertNull(p.troid());
195 p = new JdbcPersistent(getDb().getUserTable(), new Integer(0));
196 assertEquals(p.troid(), new Integer(0));
197 }
198
199
200
201
202 public void testGetTroid() {
203 Persistent p = new JdbcPersistent();
204 assertNull(p.getTroid());
205 p = new JdbcPersistent(getDb().getUserTable(), new Integer(0));
206 assertEquals(p.getTroid(), new Integer(0));
207 }
208
209
210
211
212 public void testExistenceLock() {
213 Persistent p = new JdbcPersistent();
214 p.existenceLock();
215 try {
216 p.delete();
217 fail("Should have blown up");
218 } catch (InvalidOperationOnFloatingPersistentPoemException e) {
219 e = null;
220 }
221
222 }
223
224
225
226
227
228 public void testAssertCanWriteAccessToken() {
229 Persistent p = getDb().getUserTable().guestUser();
230 AccessToken g = getDb().getUserTable().guestUser();
231 try {
232 p.assertCanWrite(g);
233 fail("Should have bombed");
234 } catch (WritePersistentAccessPoemException e) {
235 e = null;
236 }
237 AccessToken a = getDb().getUserTable().administratorUser();
238 p.assertCanWrite(a);
239 }
240
241
242
243
244 public void testAssertCanWrite() {
245 Persistent p = getDb().getUserTable().administratorUser();
246 AccessToken g = getDb().getUserTable().guestUser();
247 p.assertCanWrite();
248 try {
249 PoemThread.setAccessToken(g);
250 p.assertCanWrite();
251 fail("Should have bombed");
252 } catch (WritePersistentAccessPoemException e) {
253 e = null;
254 }
255 }
256
257
258
259
260 public void testAssertCanDeleteAccessToken() {
261 Persistent p = getDb().getUserTable().guestUser();
262 AccessToken g = getDb().getUserTable().guestUser();
263 try {
264 p.assertCanDelete(g);
265 fail("Should have bombed");
266 } catch (DeletePersistentAccessPoemException e) {
267 e = null;
268 }
269 AccessToken a = getDb().getUserTable().administratorUser();
270 p.assertCanDelete(a);
271 }
272
273
274
275
276 public void testAssertCanDelete() {
277 Persistent p = getDb().getUserTable().administratorUser();
278 AccessToken g = getDb().getUserTable().guestUser();
279 p.assertCanDelete();
280 try {
281 PoemThread.setAccessToken(g);
282 p.assertCanDelete();
283 fail("Should have bombed");
284 } catch (DeletePersistentAccessPoemException e) {
285 e = null;
286 }
287 }
288
289
290
291
292 public void testAssertCanCreateAccessToken() {
293 Persistent p = getDb().getUserTable().guestUser();
294 AccessToken g = getDb().getUserTable().guestUser();
295 try {
296 p.assertCanCreate(g);
297 fail("Should have bombed");
298 } catch (CreationAccessPoemException e) {
299 e = null;
300 }
301 AccessToken a = getDb().getUserTable().administratorUser();
302 p.assertCanWrite(a);
303 }
304
305
306
307
308 public void testAssertCanCreate() {
309 Persistent p = getDb().getUserTable().administratorUser();
310 AccessToken g = getDb().getUserTable().guestUser();
311 p.assertCanCreate();
312 try {
313 PoemThread.setAccessToken(g);
314 p.assertCanCreate();
315 fail("Should have bombed");
316 } catch (CreationAccessPoemException e) {
317 e = null;
318 }
319 }
320
321
322
323
324 public void testGetRaw() {
325 Persistent p = getDb().getUserTable().administratorUser();
326 String name = (String)p.getRaw("name");
327 assertEquals("Melati database administrator", name);
328 Integer id = (Integer)p.getRaw("id");
329 assertEquals(new Integer(1), id);
330 }
331
332
333
334
335 public void testGetRawString() {
336 Persistent p = getDb().getUserTable().administratorUser();
337 String name = p.getRawString("name");
338 assertEquals("Melati database administrator", name);
339 String id = p.getRawString("id");
340 assertEquals("1", id);
341 }
342
343
344
345
346 public void testSetRaw() {
347 Persistent p = getDb().getUserTable().administratorUser();
348 String name = p.getRawString("name");
349 assertEquals("Melati database administrator", name);
350 p.setRaw("name", "test");
351 String name2 = p.getRawString("name");
352 assertEquals("test", name2);
353 p.setRaw("name", name);
354 String name3 = p.getRawString("name");
355 assertEquals("Melati database administrator", name3);
356 }
357
358
359
360
361 public void testSetRawString() {
362 Persistent p = getDb().getUserTable().administratorUser();
363 String name = p.getRawString("name");
364 assertEquals("Melati database administrator", name);
365 p.setRawString("name", "test");
366 String name2 = p.getRawString("name");
367 assertEquals("test", name2);
368 p.setRawString("name", name);
369 String name3 = p.getRawString("name");
370 assertEquals("Melati database administrator", name3);
371 }
372
373
374
375
376 public void testGetCooked() {
377 Persistent p = getDb().getUserTable().administratorUser();
378 String name = (String)p.getCooked("name");
379 assertEquals("Melati database administrator", name);
380 p = getDb().getUserTable().getTableInfo();
381 TableCategory c = (TableCategory)p.getCooked("category");
382 assertEquals("tableCategory/0", c.toString());
383 }
384
385
386
387
388 public void testGetCookedString() {
389 Persistent p = getDb().getUserTable().administratorUser();
390 String name = p.getCookedString("name", PoemLocale.HERE, DateFormat.MEDIUM);
391 assertEquals("Melati database administrator", name);
392 Persistent p2 = getDb().getUserTable().getTableInfo();
393 String c = p2.getCookedString("category", PoemLocale.HERE, DateFormat.MEDIUM);
394 assertEquals("User", c);
395 }
396
397
398
399
400 public void testSetCooked() {
401 Persistent p = getDb().getUserTable().administratorUser();
402 String name = p.getRawString("name");
403 assertEquals("Melati database administrator", name);
404 p.setCooked("name", "test");
405 String name2 = p.getRawString("name");
406 assertEquals("test", name2);
407 p.setCooked("name", name);
408 String name3 = p.getRawString("name");
409 assertEquals("Melati database administrator", name3);
410
411 Persistent p2 = getDb().getUserTable().getTableInfo();
412 TableCategory c = (TableCategory)p2.getCooked("category");
413 TableCategory c2 = (TableCategory)getDb().getTableCategoryTable().newPersistent();
414 c2.setName("Test");
415 c2.makePersistent();
416 p2.setCooked("category",c2);
417 String cString = p2.getCookedString("category",PoemLocale.HERE, DateFormat.MEDIUM);
418 assertEquals("Test", cString);
419 p2.setCooked("category",c);
420 cString = p2.getCookedString("category",PoemLocale.HERE, DateFormat.MEDIUM);
421 assertEquals("User", cString);
422 c2.delete();
423 }
424
425
426
427
428 public void testGetField() {
429 Persistent p = getDb().getGroupMembershipTable().getObject(0);
430 Field<?> f = p.getField("user");
431 assertEquals("user: Melati database administrator", f.toString());
432 }
433
434
435
436
437 public void testFieldsOfColumns() {
438 Persistent p = getDb().getGroupMembershipTable().getObject(0);
439 Enumeration<Field<?>> fields = p.fieldsOfColumns(p.getTable().columns());
440 Field<?> f = (Field<?>)fields.nextElement();
441 assertEquals("id: 0", f.toString());
442 f = (Field<?>)fields.nextElement();
443 assertEquals("user: Melati database administrator", f.toString());
444 f = (Field<?>)fields.nextElement();
445 assertEquals("group: Melati database administrators", f.toString());
446 }
447
448
449
450
451 public void testGetFields() {
452 Persistent p = getDb().getGroupMembershipTable().getObject(0);
453 Enumeration<Field<?>> fields = p.getFields();
454 Field<?> f = (Field<?>)fields.nextElement();
455 assertEquals("id: 0", f.toString());
456 f = (Field<?>)fields.nextElement();
457 assertEquals("user: Melati database administrator", f.toString());
458 f = (Field<?>)fields.nextElement();
459 assertEquals("group: Melati database administrators", f.toString());
460 }
461
462
463
464
465 public void testGetRecordDisplayFields() {
466 Persistent p = getDb().getGroupMembershipTable().getObject(0);
467 Enumeration<Field<?>> fields = p.getRecordDisplayFields();
468 Field<?> f = (Field<?>)fields.nextElement();
469 assertEquals("user: Melati database administrator", f.toString());
470 f = (Field<?>)fields.nextElement();
471 assertEquals("group: Melati database administrators", f.toString());
472 }
473
474
475
476
477 public void testGetDetailDisplayFields() {
478 Persistent p = getDb().getGroupMembershipTable().getObject(0);
479 Enumeration<Field<?>> fields = p.getDetailDisplayFields();
480 Field<?> f = (Field<?>)fields.nextElement();
481 assertEquals("id: 0", f.toString());
482 f = (Field<?>)fields.nextElement();
483 assertEquals("user: Melati database administrator", f.toString());
484 f = (Field<?>)fields.nextElement();
485 assertEquals("group: Melati database administrators", f.toString());
486 }
487
488
489
490
491 public void testGetSummaryDisplayFields() {
492 Persistent p = getDb().getGroupMembershipTable().getObject(0);
493 Enumeration<Field<?>> fields = p.getSummaryDisplayFields();
494 Field<?> f = (Field<?>)fields.nextElement();
495 assertEquals("user: Melati database administrator", f.toString());
496 f = (Field<?>)fields.nextElement();
497 assertEquals("group: Melati database administrators", f.toString());
498 }
499
500
501
502
503 public void testGetSearchCriterionFields() {
504 Persistent p = getDb().getGroupMembershipTable().getObject(0);
505 Enumeration<Field<?>> fields = p.getSearchCriterionFields();
506 Field<?> f = (Field<?>)fields.nextElement();
507 assertEquals("id: 0", f.toString());
508 f = (Field<?>)fields.nextElement();
509 assertEquals("user: Melati database administrator", f.toString());
510 f = (Field<?>)fields.nextElement();
511 assertEquals("group: Melati database administrators", f.toString());
512 }
513
514
515
516
517
518 public void testGetPrimaryDisplayField() {
519 }
520
521
522
523
524
525 public void testDelete() {
526 Persistent p = getDb().getCapabilityTable().newPersistent();
527 try {
528 p.delete();
529 fail("Should have bombed");
530 } catch (InvalidOperationOnFloatingPersistentPoemException e) {
531 e = null;
532 }
533 p.setCooked("name","testCapability");
534 p.makePersistent();
535 assertEquals("testCapability", p.getCooked("name"));
536 p.delete();
537 try {
538 p.delete();
539 fail("Should have bombed");
540 } catch (RowDisappearedPoemException e) {
541 e = null;
542 }
543 try {
544 getDb().getGroupTable().getObject(p.getTroid());
545 fail("Should have bombed");
546 } catch (NoSuchRowPoemException e) {
547 e = null;
548 }
549
550 PoemThread.rollback();
551 try {
552 getDb().getGroupTable().getObject(p.getTroid());
553 fail("Should have bombed");
554 } catch (NoSuchRowPoemException e) {
555 e = null;
556 }
557 p = getDb().getGroupTable().newPersistent();
558 p.setCooked("name","testGroup");
559 p.makePersistent();
560 assertEquals("testGroup", p.getCooked("name"));
561
562 PoemThread.commit();
563 p.delete();
564 try {
565 p.delete();
566 fail("Should have bombed");
567 } catch (RowDisappearedPoemException e) {
568 e = null;
569 }
570 try {
571 getDb().getGroupTable().getObject(p.getTroid());
572 fail("Should have bombed");
573 } catch (NoSuchRowPoemException e) {
574 e = null;
575 }
576
577 getDb().setLogCommits(true);
578 PoemThread.rollback();
579 getDb().setLogCommits(false);
580 getDb().getGroupTable().getObject(p.getTroid());
581 assertEquals("testGroup", p.getCooked("name"));
582 p.delete();
583 try {
584 p.delete();
585 fail("Should have bombed");
586 } catch (RowDisappearedPoemException e) {
587 e = null;
588 }
589 try {
590 getDb().getGroupTable().getObject(1);
591 fail("Should have bombed");
592 } catch (NoSuchRowPoemException e) {
593 e = null;
594 }
595
596 getDb().setLogCommits(true);
597 PoemThread.commit();
598 getDb().setLogCommits(false);
599 }
600
601
602
603
604 public void testDelete_unsafe() {
605 Persistent p = getDb().getGroupTable().newPersistent();
606 try {
607 p.delete_unsafe();
608 fail("Should have bombed");
609 } catch (InvalidOperationOnFloatingPersistentPoemException e) {
610 e = null;
611 }
612 p.setCooked("name","test");
613 p.makePersistent();
614
615 assertEquals("test", p.getCooked("name"));
616 p.delete_unsafe();
617 try {
618 p.delete_unsafe();
619 } catch (RowDisappearedPoemException e) {
620 e = null;
621 }
622 try {
623 getDb().getGroupTable().getObject(2);
624 fail("Should have bombed");
625 } catch (NoSuchRowPoemException e) {
626 e = null;
627 }
628
629 }
630
631
632
633
634
635 public void testDeleteAndCommit() {
636 Persistent p = getDb().getGroupTable().newPersistent();
637 try {
638 p.deleteAndCommit();
639 fail("Should have bombed");
640 } catch (InvalidOperationOnFloatingPersistentPoemException e) {
641 e = null;
642 }
643 p.setCooked("name","test");
644 p.makePersistent();
645 assertEquals("test", p.getCooked("name"));
646 p.deleteAndCommit();
647 try {
648 p.deleteAndCommit();
649 } catch (RowDisappearedPoemException e) {
650 e = null;
651 }
652 try {
653 getDb().getGroupTable().getObject(3);
654 fail("Should have bombed");
655 } catch (NoSuchRowPoemException e) {
656 e = null;
657 }
658 }
659
660
661
662
663 public void testDeleteAndCommitMap() {
664 Persistent p = getDb().getGroupTable().newPersistent();
665 try {
666 p.deleteAndCommit(null);
667 fail("Should have bombed");
668 } catch (InvalidOperationOnFloatingPersistentPoemException e) {
669 e = null;
670 }
671 p.setCooked("name","test");
672 p.makePersistent();
673 assertEquals("test", p.getCooked("name"));
674 Integer troid = p.getTroid();
675 p.deleteAndCommit(null);
676 try {
677 p.deleteAndCommit(null);
678 } catch (RowDisappearedPoemException e) {
679 e = null;
680 }
681 try {
682 getDb().getGroupTable().getObject(troid);
683 fail("Should have bombed");
684 } catch (NoSuchRowPoemException e) {
685 e = null;
686 }
687
688 }
689
690
691
692
693 public void testDuplicated() {
694 Persistent p = getDb().getGroupTable().getObject(0);
695 Persistent p2 = p.duplicated();
696 assertFalse(p.equals(p2));
697 try {
698 p2.duplicated();
699 fail("Should have bombed");
700 } catch (InvalidOperationOnFloatingPersistentPoemException e) {
701 e = null;
702 }
703 }
704
705
706
707
708 public void testDuplicatedFloating() {
709 Persistent p = getDb().getGroupTable().getObject(0);
710 Persistent p2 = p.duplicatedFloating();
711 assertFalse(p.equals(p2));
712 Persistent p3 = p2.duplicatedFloating();
713 assertTrue(p2.equals(p3));
714 }
715
716
717
718
719 public void testToString() {
720 Persistent p = getDb().getGroupMembershipTable().getObject(0);
721 assertEquals("groupMembership/0", p.toString());
722 }
723
724
725
726
727 public void testDisplayStringPoemLocaleInt() {
728 Persistent p = getDb().getGroupTable().getObject(0);
729 assertEquals("Melati database administrators",
730 p.displayString(PoemLocale.HERE, DateFormat.MEDIUM));
731 }
732
733
734
735
736 public void testDisplayStringPoemLocale() {
737 Persistent p = getDb().getGroupTable().getObject(0);
738 assertEquals("Melati database administrators",
739 p.displayString(PoemLocale.HERE));
740 }
741
742
743
744
745 public void testDisplayString() {
746 Persistent p = getDb().getGroupTable().getObject(0);
747 assertEquals("Melati database administrators",
748 p.displayString());
749 }
750
751
752
753
754 public void testHashCode() {
755 Persistent p = getDb().getUserTable().guestUser();
756
757 assertEquals(2645995, p.hashCode());
758 try {
759 p = getDb().getUserTable().newPersistent();
760 p.hashCode();
761 fail("Should have bombed");
762 } catch (InvalidOperationOnFloatingPersistentPoemException e) {
763 e = null;
764 }
765 }
766
767
768
769
770 public void testEqualsObject() {
771 Persistent p = getDb().getGroupTable().getObject(0);
772 assertTrue(p.equals(p));
773 Persistent p2 = getDb().getGroupTable().newPersistent();
774 assertTrue(p2.equals(p2));
775 assertFalse(p.equals(p2));
776 assertFalse(p.equals(null));
777 assertFalse(p.equals(new Integer(0)));
778
779
780 p2.setRaw("id", new Integer(0));
781 assertFalse(p.equals(p2));
782 }
783
784
785
786
787 public void testDump() {
788 Persistent p = new JdbcPersistent(getDb().getUserTable(), new Integer(0));
789 String d = null;
790 try {
791 d = p.dump();
792 fail("Should have blown up");
793 } catch (ClassCastException e) {
794 e = null;
795 }
796 assertNull(d);
797
798 User u = (User)getDb().getUserTable().newPersistent();
799 d = u.dump();
800
801 assertTrue(d, d.startsWith("User/null"));
802 u = getDb().getUserTable().guestUser();
803 d = u.dump();
804 assertTrue(d,d.startsWith("User/0"));
805
806
807
808 Setting stringSetting = getDb().getSettingTable().ensure("stringSetting","set","String","A set string setting");
809 ByteArrayOutputStream baos = new ByteArrayOutputStream();
810 PrintStream ps = new PrintStream(baos);
811 stringSetting.dump(ps);
812
813 assertTrue(baos.toString().startsWith("setting/"));
814 stringSetting.delete();
815
816 }
817
818
819
820 public void testDumpPrintStream() {
821 ByteArrayOutputStream baos = new ByteArrayOutputStream();
822 PrintStream ps = new PrintStream(baos);
823 try {
824 Persistent p = new JdbcPersistent(getDb().getUserTable(), new Integer(0));
825 p.dump(ps);
826 fail("Should have blown up");
827 } catch (ClassCastException e) {
828 e = null;
829 }
830
831 assertEquals(baos.toString(),
832 "User/0\n ",
833 baos.toString().replace("\r", ""));
834
835 baos = new ByteArrayOutputStream();
836 ps = new PrintStream(baos);
837 User u = (User)getDb().getUserTable().newPersistent();
838 u.dump(ps);
839 assertTrue(baos.toString().startsWith("User/null"));
840 u = getDb().getUserTable().guestUser();
841 baos = new ByteArrayOutputStream();
842 ps = new PrintStream(baos);
843 u.dump(ps);
844 assertTrue(baos.toString().startsWith("User/0"));
845
846 }
847
848
849
850
851 public void testPostWrite() {
852 Persistent p = getDb().getUserTable().guestUser();
853 p.postWrite();
854 }
855
856
857
858
859 public void testPostInsert() {
860 Persistent p = getDb().getUserTable().guestUser();
861 p.postInsert();
862 }
863
864
865
866
867 public void testPostModify() {
868 Persistent p = getDb().getUserTable().guestUser();
869 p.postModify();
870 }
871
872
873
874
875 public void testPreEdit() {
876 Persistent p = getDb().getUserTable().guestUser();
877 p.preEdit();
878 }
879
880
881
882
883 public void testPostEdit() {
884 Persistent p = getDb().getUserTable().guestUser();
885 p.postEdit(true);
886 p.postEdit(false);
887 }
888
889
890
891
892
893 public void testToStringNull() {
894 Persistent unit = new JdbcPersistent();
895 assertEquals("null/null", unit.toString());
896 }
897
898
899
900
901 public void testEqualsNull() {
902 Persistent unitOne = new JdbcPersistent();
903 Persistent unitTwo = new JdbcPersistent();
904 assertTrue(unitOne.equals(unitTwo));
905 }
906
907 }