View Javadoc
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   * @author timp
13   * @since 27/11/2006
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     * @see org.melati.poem.JdbcPersistent#invalidate()
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      // guestUser does not hit the database
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      // Count always increments queryCount
61      getDb().getUserTable().count();
62      int countHits1 = getDb().getQueryCount();
63      assertEquals(hits5 + 1, countHits1 );
64      getDb().getUserTable().count();
65      int countHits2 = getDb().getQueryCount();
66      //System.err.println(countHits2);
67      assertEquals(countHits1 + 1, countHits2);
68      
69      // FIXME Selection is cached but not invalidated 
70      // when table cache is invalidated
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      //System.err.println(getHits1);
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      //System.err.println(getHits3);
97      assertEquals(getHits2 + 3, getHits3);
98      p2.delete();
99      PoemThread.commit();
100   }
101 
102 
103   /**
104    * @see org.melati.poem.JdbcPersistent()
105    */
106   public void testPersistent() {
107 
108   }
109 
110   /**
111    * @see org.melati.poem.JdbcPersistent(String)
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    * @see org.melati.poem.JdbcPersistent(Table, Integer)
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    * @see org.melati.poem.Persistent#statusNonexistent()
153    */
154   public void testStatusNonexistent() {
155 
156   }
157 
158   /**
159    * @see org.melati.poem.Persistent#statusExistent()
160    */
161   public void testStatusExistent() {
162 
163   }
164 
165   /**
166    * @see org.melati.poem.Persistent#makePersistent()
167    */
168   public void testMakePersistent() {
169 
170   }
171 
172 
173   /**
174    * @see org.melati.poem.Persistent#getTable()
175    */
176   public void testGetTable() {
177 
178   }
179 
180 
181   /**
182    * @see org.melati.poem.Persistent#getDatabase()
183    */
184   public void testGetDatabase() {
185     Persistent p = new JdbcPersistent(getDb().getUserTable(), new Integer(0));
186     assertEquals(p.getDatabase(), getDb());
187   }
188 
189   /**
190    * @see org.melati.poem.Persistent#troid()
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    * @see org.melati.poem.Persistent#getTroid()
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    * @see org.melati.poem.Persistent#existenceLock()
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    * @see org.melati.poem.Persistent#assertCanWrite(AccessToken)
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    * @see org.melati.poem.Persistent#assertCanWrite()
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    * @see org.melati.poem.Persistent#assertCanDelete(AccessToken)
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    * @see org.melati.poem.Persistent#assertCanDelete()
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    * @see org.melati.poem.Persistent#assertCanCreate(AccessToken)
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    * @see org.melati.poem.Persistent#assertCanCreate()
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    * @see org.melati.poem.Persistent#getRaw(String)
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    * @see org.melati.poem.Persistent#getRawString(String)
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    * @see org.melati.poem.Persistent#setRaw(String, Object)
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    * @see org.melati.poem.Persistent#setRawString(String, String)
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    * @see org.melati.poem.Persistent#getCooked(String)
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    * @see org.melati.poem.Persistent#getCookedString(String, PoemLocale, int)
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    * @see org.melati.poem.Persistent#setCooked(String, Object)
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    * @see org.melati.poem.Persistent#getField(String)
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    * @see org.melati.poem.Persistent#fieldsOfColumns(Enumeration)
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    * @see org.melati.poem.Persistent#getFields()
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    * @see org.melati.poem.Persistent#getRecordDisplayFields()
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    * @see org.melati.poem.Persistent#getDetailDisplayFields()
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    * @see org.melati.poem.Persistent#getSummaryDisplayFields()
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    * @see org.melati.poem.Persistent#getSearchCriterionFields()
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    * @see org.melati.poem.test.ProtectedPersistentTest#testGetPrimaryDisplayField()
516    * @see org.melati.poem.Persistent#getPrimaryDisplayField()
517    */
518   public void testGetPrimaryDisplayField() {
519   }
520 
521 
522   /**
523    * @see org.melati.poem.Persistent#delete()
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     // To before we started
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     // Write to db
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     // Rollback so it should be there again
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     // So the db state should be unchanged
596     getDb().setLogCommits(true);
597     PoemThread.commit();
598     getDb().setLogCommits(false);
599   }
600 
601   /**
602    * @see org.melati.poem.Persistent#delete_unsafe()
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     // Hmm - not sure I am happy with this ordered dependency
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    * @see org.melati.poem.Persistent#deleteAndCommit()
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    * @see org.melati.poem.Persistent#deleteAndCommit(Map)
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    * @see org.melati.poem.Persistent#duplicated()
692    */
693   public void testDuplicated() {
694     Persistent p = getDb().getGroupTable().getObject(0); 
695     Persistent p2 = p.duplicated();
696     assertFalse(p.equals(p2)); // p2 is floating
697     try {
698       p2.duplicated();
699       fail("Should have bombed");
700     } catch (InvalidOperationOnFloatingPersistentPoemException e) { 
701       e = null;
702     }
703   }
704 
705   /**
706    * @see org.melati.poem.Persistent#duplicatedFloating()
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    * @see org.melati.poem.Persistent#toString()
718    */
719   public void testToString() {
720     Persistent p = getDb().getGroupMembershipTable().getObject(0);
721     assertEquals("groupMembership/0", p.toString());
722   }
723 
724   /**
725    * @see org.melati.poem.Persistent#displayString(PoemLocale, int)
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    * @see org.melati.poem.Persistent#displayString(PoemLocale)
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    * @see org.melati.poem.Persistent#displayString()
744    */
745   public void testDisplayString() {
746     Persistent p = getDb().getGroupTable().getObject(0);
747     assertEquals("Melati database administrators", 
748         p.displayString());    
749   }
750   
751   /**
752    * @see org.melati.poem.Persistent#hashCode()
753    */
754   public void testHashCode() {
755     Persistent p = getDb().getUserTable().guestUser();
756     //assertEquals(3599307, p.hashCode());
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    * @see org.melati.poem.Persistent#equals(Object)
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     // Note that id != troid
779     // troid remains null
780     p2.setRaw("id", new Integer(0));
781     assertFalse(p.equals(p2));
782   }
783 
784   /**
785    * @see org.melati.poem.Persistent#dump()
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     //System.err.println(baos.toString().trim() + ":");
813     assertTrue(baos.toString().startsWith("setting/"));
814     stringSetting.delete();
815     
816   }
817   /**
818    * @see org.melati.poem.Persistent#dump(PrintStream)
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     // Some gets written before blowing up
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    * @see org.melati.poem.Persistent#postWrite()
850    */
851   public void testPostWrite() {
852     Persistent p = getDb().getUserTable().guestUser();
853     p.postWrite();
854   }
855 
856   /**
857    * @see org.melati.poem.Persistent#postInsert()
858    */
859   public void testPostInsert() {
860     Persistent p = getDb().getUserTable().guestUser();
861     p.postInsert();
862   }
863 
864   /**
865    * @see org.melati.poem.Persistent#postModify()
866    */
867   public void testPostModify() {
868     Persistent p = getDb().getUserTable().guestUser();
869     p.postModify();
870   }
871 
872   /**
873    * @see org.melati.poem.Persistent#preEdit()
874    */
875   public void testPreEdit() {
876     Persistent p = getDb().getUserTable().guestUser();
877     p.preEdit();
878   }
879 
880   /**
881    * @see org.melati.poem.Persistent#postEdit(boolean)
882    */
883   public void testPostEdit() {
884     Persistent p = getDb().getUserTable().guestUser();
885     p.postEdit(true);
886     p.postEdit(false);
887   }
888 
889 
890   /**
891    * Test the representation of an uninitialised Persistent.
892    */
893   public void testToStringNull() {
894     Persistent unit = new JdbcPersistent();
895     assertEquals("null/null", unit.toString());
896   }
897 
898   /**
899    * Test that two uninitialised Persistents are equal.
900    */
901   public void testEqualsNull() {
902     Persistent unitOne = new JdbcPersistent();
903     Persistent unitTwo = new JdbcPersistent();
904     assertTrue(unitOne.equals(unitTwo));
905   }
906 
907 }