View Javadoc
1   /**
2    * 
3    */
4   package org.melati.poem.test;
5   
6   import java.io.ByteArrayOutputStream;
7   import java.io.PrintStream;
8   import java.util.Enumeration;
9   import java.util.Vector;
10  
11  import org.melati.poem.*;
12  import org.melati.poem.User;
13  import org.melati.poem.UserTable;
14  import org.melati.poem.util.EmptyEnumeration;
15  import org.melati.poem.util.EnumUtils;
16  
17  /**
18   * @author timp
19   * 
20   */
21  public class TableTest extends PoemTestCase {
22  
23    public TableTest(String arg0) {
24      super(arg0);
25    }
26  
27    protected void setUp() throws Exception {
28      super.setUp();
29    }
30  
31    protected void tearDown() throws Exception {
32      super.tearDown();
33    }
34  
35    
36    
37    /**
38     * @see org.melati.poem.Table
39     */
40    public void testTable() {
41  
42    }
43  
44    /**
45     * @see org.melati.poem.Table#postInitialise()
46     */
47    public void testPostInitialise() {
48  
49    }
50  
51    /**
52     * @see org.melati.poem.Table#getDatabase()
53     */
54    public void testGetDatabase() {
55      assertTrue(getDb().getUserTable().getDatabase().equals(getDb()));
56    }
57  
58    /**
59     * @see org.melati.poem.Table#getName()
60     */
61    public void testGetName() {
62      UserTable<User> ut = getDb().getUserTable();
63      assertEquals("user", ut.getName());
64    }
65  
66    /**
67     * @see org.melati.poem.Table#quotedName()
68     */
69    public void testQuotedName() {
70      UserTable<User> ut = getDb().getUserTable();
71      assertEquals(getDb().getDbms().getQuotedName("user"), ut.quotedName());
72  
73    }
74  
75    /**
76     * @see org.melati.poem.Table#getDisplayName()
77     */
78    public void testGetDisplayName() {
79  
80    }
81  
82    /**
83     * @see org.melati.poem.Table#getDescription()
84     */
85    public void testGetDescription() {
86      assertEquals("A registered User of the database", getDb().getUserTable()
87          .getDescription());
88    }
89  
90    /**
91     * @see org.melati.poem.Table#getCategory()
92     */
93    public void testGetCategory() {
94      assertEquals("User", getDb().getUserTable().getCategory().getName());
95    }
96  
97    /**
98     * @see org.melati.poem.Table#getInfo()
99     */
100   public void testGetInfo() {
101     assertEquals("User", getDb().getUserTable().getInfo().getCategory()
102         .getName());
103   }
104 
105   /**
106    * @see org.melati.poem.Table#tableInfoID()
107    */
108   public void testTableInfoID() {
109 
110   }
111 
112   /**
113    * @see org.melati.poem.Table#getColumn(String)
114    */
115   public void testGetColumn() {
116     try { 
117       getDb().getUserTable().getColumn("nonexistantcolum");
118       fail("Should have blown up");
119     } catch (NoSuchColumnPoemException e) { 
120       e = null; 
121     }
122   }
123 
124 
125   /**
126    * Assert that all columns are currently returned at the detail level.
127    * It would be possible to exclude range for example. 
128    *  
129    * @see org.melati.poem.Table#columns()
130    */
131   public void testColumns() {
132     Enumeration<Table<?>> en = getDb().tables();
133     while(en.hasMoreElements()) { 
134       Table<?> t = en.nextElement();
135       int colCount = EnumUtils.vectorOf(t.columns()).size();
136       assertTrue("Table " + t.getName() + 
137               " columns(): " + colCount + 
138               " t.getDetailDisplayColumnsCount(): " + t.getDetailDisplayColumnsCount(), 
139               colCount == t.getDetailDisplayColumnsCount());
140       int colIndex = 0;
141       String[][] cols = new String[colCount][3] ;
142       Enumeration<Column<?>> colEn = t.columns();
143       while (colEn.hasMoreElements()) {
144         Column<?> c = (Column<?>)colEn.nextElement();
145         cols[colIndex][0] = c.getName();
146         boolean inDetailDisplayColumns = false; 
147         Enumeration<Column<?>> detailDisplayCols = t.getDetailDisplayColumns();
148         while (detailDisplayCols.hasMoreElements()) { 
149           Column<?> recCol = detailDisplayCols.nextElement();
150           if (recCol == c) 
151             inDetailDisplayColumns = true;
152         }
153         cols[colIndex][1] = new Boolean(inDetailDisplayColumns).toString();
154         colIndex++;
155       }
156       for (int i = 0; i< colCount; i++) { 
157         assertTrue("    " + i + " " + cols[i][0] + " " + cols[i][1] ,  
158                 cols[i][1].equals("true"));
159       }
160     }
161 
162   }
163 
164   /**
165    * Not actually used in java, maybe in templates.
166    * 
167    * @see org.melati.poem.Table#getColumnsCount()
168    */
169   public void testGetColumnsCount() {
170     assertEquals(4, getDb().getUserTable().getColumnsCount());
171 
172   }
173 
174   /**
175    * Null return not testable from public name space.
176    * 
177    * @see org.melati.poem.Table#columnWithColumnInfoID(int)
178    */
179   public void testColumnWithColumnInfoID() {
180   }
181 
182   /**
183    * @see org.melati.poem.Table#troidColumn()
184    */
185   public void testTroidColumn() {
186 
187   }
188 
189   /**
190    * @see org.melati.poem.Table#deletedColumn()
191    */
192   public void testDeletedColumn() {
193 
194   }
195 
196   /**
197    * @see org.melati.poem.Table#displayColumn()
198    */
199   public void testDisplayColumn() {
200 
201   }
202 
203   /**
204    * @see org.melati.poem.Table#setDisplayColumn(Column)
205    */
206   public void testSetDisplayColumn() {
207 
208   }
209 
210   /**
211    * @see org.melati.poem.Table#primaryCriterionColumn()
212    */
213   public void testPrimaryCriterionColumn() {
214     assertEquals("name", getDb().getUserTable().primaryCriterionColumn().getName());
215   }
216 
217   /**
218    * @see org.melati.poem.Table#setSearchColumn(Column)
219    */
220   public void testSetSearchColumn() {
221 
222   }
223 
224   /**
225    * @see org.melati.poem.Table#defaultOrderByClause()
226    */
227   public void testDefaultOrderByClause() {
228 
229   }
230 
231   /**
232    * @see org.melati.poem.Table#notifyColumnInfo(ColumnInfo)
233    */
234   public void testNotifyColumnInfo() {
235 
236   }
237 
238   /**
239    * @see org.melati.poem.Table#displayColumns(DisplayLevel)
240    */
241   public void testDisplayColumns() {
242 
243   }
244 
245   /**
246    * @see org.melati.poem.Table#displayColumnsCount(DisplayLevel)
247    */
248   public void testDisplayColumnsCount() {
249     assertEquals(1, getDb().getUserTable().displayColumnsCount(DisplayLevel.primary));
250   }
251 
252   /**
253    * @see org.melati.poem.Table#getDetailDisplayColumns()
254    */
255   public void testGetDetailDisplayColumns() {
256     Enumeration<Column<?>> them = getDb().getUserTable().getDetailDisplayColumns();
257     int counter = 0;
258     while (them.hasMoreElements()) {
259       them.nextElement();
260       counter++;
261     }
262     assertEquals(4, counter);
263   }
264 
265   /**
266    * @see org.melati.poem.Table#getDetailDisplayColumnsCount()
267    */
268   public void testGetDetailDisplayColumnsCount() {
269     assertEquals(4, getDb().getUserTable().getDetailDisplayColumnsCount());
270   }
271 
272   /**
273    * @see org.melati.poem.Table#getRecordDisplayColumns()
274    */
275   public void testGetRecordDisplayColumns() {
276     Enumeration<Column<?>> them = getDb().getUserTable().getRecordDisplayColumns();
277     int counter = 0;
278     while (them.hasMoreElements()) {
279       them.nextElement();
280       counter++;
281     }
282     assertEquals(3, counter);
283   }
284 
285   /**
286    * @see org.melati.poem.Table#getRecordDisplayColumnsCount()
287    */
288   public void testGetRecordDisplayColumnsCount() {
289     assertEquals(3, getDb().getUserTable().getRecordDisplayColumnsCount());
290   }
291 
292   /**
293    * @see org.melati.poem.Table#getSummaryDisplayColumns()
294    */
295   public void testGetSummaryDisplayColumns() {
296     Enumeration<Column<?>> them = getDb().getUserTable().getSummaryDisplayColumns();
297     int counter = 0;
298     while (them.hasMoreElements()) {
299       them.nextElement();
300       counter++;
301     }
302     assertEquals(2, counter);
303   }
304 
305   /**
306    * @see org.melati.poem.Table#getSummaryDisplayColumnsCount()
307    */
308   public void testGetSummaryDisplayColumnsCount() {
309     assertEquals(2, getDb().getUserTable().getSummaryDisplayColumnsCount());
310   }
311 
312   /**
313    * @see org.melati.poem.Table#getSearchCriterionColumns()
314    */
315   public void testGetSearchCriterionColumns() {
316 
317   }
318 
319   /**
320    * Not used in the java, possibly in templates.
321    * @see org.melati.poem.Table#getSearchCriterionColumnsCount()
322    */
323   public void testGetSearchCriterionColumnsCount() {
324     assertEquals(3, getDb().getUserTable().getSearchCriterionColumnsCount());
325   }
326 
327 
328   /**
329    * @see org.melati.poem.Table#load(PoemTransaction, Persistent)
330    */
331   public void testLoad() {
332 
333   }
334 
335   /**
336    * @see org.melati.poem.Table#delete(Integer, PoemTransaction)
337    */
338   public void testDelete() {
339 
340   }
341 
342   /**
343    * @see PoemThread#commit()
344    */
345   public void testWriteDown() {
346     User u = getDb().administratorUser();
347     String name = u.getName();
348     u.setName("changed");
349     PoemThread.commit();
350     assertEquals("changed", u.getName());
351     u.setName(name);
352     PoemThread.commit();
353     assertEquals(name, u.getName());
354   }
355 
356   /**
357    * @see org.melati.poem.Table#uncache()
358    */
359   public void testUncacheContents() {
360 
361   }
362 
363   /**
364    * @see org.melati.poem.Table#trimCache(int)
365    */
366   public void testTrimCache() {
367 
368   }
369 
370   /**
371    * Used in cache dump servlet.
372    * @see org.melati.poem.Table#getCacheInfo()
373    */
374   public void testGetCacheInfo() {
375     getDb().uncache();
376     Enumeration<Object> them = getDb().getUserTable().getCacheInfo().getHeldElements();
377     int counter = 0;
378     while(them.hasMoreElements()){
379       them.nextElement();
380       counter++;
381     }
382     assertEquals(2,counter);
383   }
384 
385   /**
386    * @see org.melati.poem.Table#addListener(TableListener)
387    */
388   public void testAddListener() {
389 
390   }
391 
392   /**
393    * @see org.melati.poem.Table#notifyTouched(PoemTransaction, Persistent)
394    */
395   public void testNotifyTouched() {
396 
397   }
398 
399   /**
400    * @see org.melati.poem.Table#serial(PoemTransaction)
401    */
402   public void testSerial() {
403 
404   }
405 
406   /**
407    * @see org.melati.poem.Table#readLock()
408    */
409   public void testReadLock() {
410 
411   }
412 
413   /**
414    * @see org.melati.poem.Table#getObject(Integer)
415    */
416   public void testGetObjectInteger() {
417     int count1 = getDb().getQueryCount();
418     User u = getDb().guestUser();
419     int count2 = getDb().getQueryCount();
420     UserTable<User> ut = getDb().getUserTable();
421     int count3 = getDb().getQueryCount();
422     User u2 = (User)ut.getObject(new Integer(0));
423     int count4 = getDb().getQueryCount();
424     User u3 = (User)ut.getObject(new Integer(0));
425     int count5 = getDb().getQueryCount();
426     assertEquals(u,u2);
427     System.err.println(u3.getName());
428     int count6 = getDb().getQueryCount();
429     System.err.println(count1 + ":" + count2 + ":" +  count3 + ":" + count4 + ":"+  count5 + ":" + count6);    
430   }
431 
432   /**
433    * @see org.melati.poem.Table#getObject(int)
434    */
435   public void testGetObjectInt() {
436     GroupTable<Group> t = getDb().getGroupTable();
437     Persistent p = t.getObject(0);
438     assertEquals(new Integer(0),p.getTroid());
439   }
440 
441   /**
442    * @see org.melati.poem.Table#selectionSQL
443    */
444   public void testSelectionSQLStringStringBoolean() {
445   }
446 
447   /**
448    * @see org.melati.poem.Table#selectionSQL(String, String, String, boolean,
449    *      boolean)
450    */
451   public void testSelectionSQLStringStringStringBooleanBoolean() {
452 
453   }
454 
455   /**
456    * @see org.melati.poem.Table#troidSelection(String, String, boolean,
457    *      PoemTransaction)
458    */
459   public void testTroidSelectionStringStringBooleanPoemTransaction() {
460   }
461 
462   /**
463    * @see org.melati.poem.Table#troidSelection(Persistent, String, boolean,
464    *      boolean, PoemTransaction)
465    */
466   public void testTroidSelectionPersistentStringBooleanBooleanPoemTransaction() {
467 
468   }
469 
470   /**
471    * @see org.melati.poem.Table#rememberAllTroids(boolean)
472    */
473   public void testRememberAllTroids() {
474 
475   }
476 
477   /**
478    * @see org.melati.poem.Table#setCacheLimit(Integer)
479    */
480   public void testSetCacheLimit() {
481 
482   }
483 
484   /**
485    * @see org.melati.poem.Table#troidSelection(String, String, boolean)
486    */
487   public void testTroidSelectionStringStringBoolean() {
488     Enumeration<Integer> en = getDb().getUserTable().troidSelection(null, null, true);
489     assertEquals(2, EnumUtils.vectorOf(en).size());
490   }
491 
492   /**
493    * @see org.melati.poem.Table#selection()
494    */
495   public void testSelection() {
496 
497   }
498 
499   /**
500    * @see org.melati.poem.Table#selection(String)
501    */
502   public void testSelectionString() {
503 
504   }
505 
506   /**
507    * @see org.melati.poem.Table#firstSelection(String)
508    */
509   public void testFirstSelection() {
510 
511   }
512 
513   /**
514    * @see org.melati.poem.Table#selection(String, String, boolean)
515    */
516   public void testSelectionStringStringBoolean() {
517 
518   }
519 
520   /**
521    * @see org.melati.poem.Table#selection(Persistent)
522    */
523   public void testSelectionPersistent() {
524     User exemplar = (User)getDb().getUserTable().newPersistent();
525     Enumeration<User> found  = getDb().getUserTable().selection(exemplar);
526     int count = 0;
527     User outcome = null;
528     while (found.hasMoreElements()) {
529       count++;
530       outcome = found.nextElement();
531       //System.err.println(result);
532     }
533     assertNotNull(outcome);
534     assertEquals(2, count);
535     exemplar.setLogin("_administrator_");
536     outcome = null;
537     count = 0;
538     found  = getDb().getUserTable().selection(exemplar, 
539         getDb().getUserTable().getNameColumn().fullQuotedName());
540     while (found.hasMoreElements()) {
541       count++;
542       outcome = (User)found.nextElement();
543       //System.err.println(result);
544     }
545     assertNotNull(outcome);
546     assertEquals(1, count);
547 
548     exemplar.setLogin("notSet");
549     outcome = null;
550     count = 0;
551     found  = getDb().getUserTable().selection(exemplar);
552     while (found.hasMoreElements()) {
553       count++;
554       outcome = (User)found.nextElement();
555      //System.err.println(result);
556     }
557     assertNull(outcome);
558     assertEquals(0, count);
559   }
560 
561   /**
562    * @see org.melati.poem.Table#selection(Persistent, String)
563    */
564   public void testSelectionPersistentString() {
565 
566   }
567 
568   /**
569    * @see org.melati.poem.Table#selection(Persistent, String, boolean, boolean)
570    */
571   public void testSelectionPersistentStringBooleanBoolean() {
572 
573   }
574   /**
575    * @see org.melati.poem.Table#countSQL(String)
576    */
577   public void testCountSQLString() {
578 
579   }
580 
581   /**
582    * @see org.melati.poem.Table#countSQL(String, String, boolean, boolean)
583    */
584   public void testCountSQLStringStringBooleanBoolean() {
585 
586   }
587 
588   /**
589    * @see org.melati.poem.Table#count(String, boolean, boolean)
590    */
591   public void testCountStringBooleanBoolean() {
592 
593   }
594 
595   /**
596    * @see org.melati.poem.Table#count(String, boolean)
597    */
598   public void testCountStringBoolean() {
599 
600   }
601 
602   /**
603    * @see org.melati.poem.Table#count(String)
604    */
605   public void testCountString() {
606 
607   }
608 
609   /**
610    * @see org.melati.poem.Table#count()
611    */
612   public void testCount() {
613     assertEquals(2, getDb().getUserTable().count());
614 
615   }
616 
617   /**
618    * @see org.melati.poem.Table#exists(String)
619    */
620   public void testExistsString() {
621 
622   }
623 
624   /**
625    * @see org.melati.poem.Table#exists(Persistent)
626    */
627   public void testExistsPersistent() {
628 
629   }
630 
631   /**
632    * @see org.melati.poem.Table#appendWhereClause(StringBuffer, Persistent)
633    */
634   public void testAppendWhereClause() {
635 
636   }
637 
638   /**
639    * @see org.melati.poem.Table#whereClause(Persistent)
640    */
641   public void testWhereClausePersistent() {
642 
643   }
644 
645   /**
646    * @see org.melati.poem.Table#whereClause(Persistent, boolean, boolean)
647    */
648   public void testWhereClausePersistentBooleanBoolean() {
649 
650   }
651 
652   /**
653    * @see org.melati.poem.Table#cnfWhereClause(Enumeration)
654    */
655   public void testCnfWhereClauseEnumeration() {
656     String cnf = getDb().getUserTable().cnfWhereClause(
657             getDb().getUserTable().selection());
658     String expected = "((" +  getDb().getDbms().getQuotedName("user") +"." + getDb().getDbms().getQuotedName("id") + 
659     " = 0 AND " +
660     getDb().getDbms().caseInsensitiveRegExpSQL(
661             getDb().getDbms().getQuotedName("user") + "." + getDb().getDbms().getQuotedName("name"), "Melati guest user") + 
662             " AND " +
663     getDb().getDbms().caseInsensitiveRegExpSQL(
664             getDb().getDbms().getQuotedName("user") + "." + getDb().getDbms().getQuotedName("login"),"_guest_") + 
665             " AND " +
666     getDb().getDbms().caseInsensitiveRegExpSQL(
667             getDb().getDbms().getQuotedName("user") + "." + getDb().getDbms().getQuotedName("password"),"guest") +
668     ") OR" +
669     " (" + getDb().getDbms().getQuotedName("user") + "." + getDb().getDbms().getQuotedName("id") + " = 1 AND " +
670     getDb().getDbms().caseInsensitiveRegExpSQL(
671             getDb().getDbms().getQuotedName("user") + "." + getDb().getDbms().getQuotedName("name"),"Melati database administrator") + " AND " +
672     getDb().getDbms().caseInsensitiveRegExpSQL(
673             getDb().getDbms().getQuotedName("user") + "." + getDb().getDbms().getQuotedName("login"),"_administrator_") + " AND " +
674     getDb().getDbms().caseInsensitiveRegExpSQL(
675             getDb().getDbms().getQuotedName("user") + "." + getDb().getDbms().getQuotedName("password"),"FIXME") + "))";
676     assertEquals(expected, cnf);
677     cnf = getDb().getUserTable().cnfWhereClause(
678             new EmptyEnumeration<User>());
679     assertEquals("", cnf);
680     Vector<User> v = new Vector<User>();
681     v.addElement((User)getDb().getUserTable().newPersistent());
682     cnf = getDb().getUserTable().cnfWhereClause(
683             v.elements());
684     assertEquals("", cnf);
685     //getDb().getUserTable().selection(cnf);
686     
687     
688   }
689 
690   /**
691    * @see org.melati.poem.Table#cnfWhereClause(Enumeration, boolean, boolean)
692    */
693   public void testCnfWhereClauseEnumerationBooleanBoolean() {
694 
695   }
696 
697   /**
698    * @see org.melati.poem.Table#referencesTo(Persistent)
699    */
700   public void testReferencesToPersistent() {
701 
702   }
703 
704   /**
705    * @see org.melati.poem.Table#referencesTo(Table)
706    */
707   public void testReferencesToTable() {
708 
709   }
710 
711   /**
712    * @see org.melati.poem.Table#troidFor(Persistent)
713    */
714   public void testTroidFor() {
715 
716   }
717 
718   /**
719    * @see org.melati.poem.Table#create(Persistent)
720    */
721   public void testCreatePersistent() {
722 
723   }
724 
725   /**
726    * @see org.melati.poem.Table#create(Initialiser)
727    */
728   public void testCreateInitialiser() {
729 
730   }
731 
732   /**
733    * @see org.melati.poem.Table#newPersistent()
734    */
735   public void testNewPersistent() {
736 
737   }
738 
739   /**
740    * Looks like you can sucessfully delete 
741    * the same record twice.
742    * @see org.melati.poem.Table#delete_unsafe(String)
743    */
744   public void testDelete_unsafe() {
745     User tester = (User)getDb().getUserTable().newPersistent();
746     tester.setName("tester");
747     tester.setLogin("tester");
748     tester.setPassword("pwd");
749     tester.makePersistent();
750     getDb().getUserTable().delete_unsafe(
751             getDb().getUserTable().getNameColumn().fullQuotedName()
752             + " = 'tester'"
753             );
754     PoemThread.commit();
755     //System.err.println(tester.dump());
756     tester.delete();
757     tester = (User)getDb().getUserTable().getNameColumn().firstWhereEq("tester");
758     assertNull(tester);
759   }
760 
761   /**
762    * @see org.melati.poem.Table#extrasCount()
763    */
764   public void testExtrasCount() {
765 
766   }
767 
768   /**
769    * @see org.melati.poem.Table#getDefaultCanRead()
770    */
771   public void testGetDefaultCanRead() {
772 
773   }
774 
775   /**
776    * @see org.melati.poem.Table#getDefaultCanWrite()
777    */
778   public void testGetDefaultCanWrite() {
779 
780   }
781 
782   /**
783    * @see org.melati.poem.Table#getDefaultCanDelete()
784    */
785   public void testGetDefaultCanDelete() {
786 
787   }
788 
789   /**
790    * @see org.melati.poem.Table#getCanCreate()
791    */
792   public void testGetCanCreate() {
793 
794   }
795 
796   /**
797    * @see org.melati.poem.Table#canReadColumn()
798    */
799   public void testCanReadColumn() {
800 
801   }
802 
803   /**
804    * @see org.melati.poem.Table#canSelectColumn()
805    */
806   public void testCanSelectColumn() {
807 
808   }
809 
810   /**
811    * @see org.melati.poem.Table#canWriteColumn()
812    */
813   public void testCanWriteColumn() {
814 
815   }
816 
817   /**
818    * @see org.melati.poem.Table#canDeleteColumn()
819    */
820   public void testCanDeleteColumn() {
821 
822   }
823 
824   /**
825    * @see DynamicTableTest#testAddColumnAndCommitTroid()
826    * @see org.melati.poem.Table#addColumnAndCommit(ColumnInfo)
827    */
828   public void testAddColumnAndCommitTroid() {
829   }
830 
831   /**
832    * @see DynamicTableTest#testAddColumnAndCommitDeleted()
833    * @see org.melati.poem.Table#addColumnAndCommit(ColumnInfo)
834    */
835   public void testAddColumnAndCommitDeleted() throws Exception {
836   }
837 
838   /**
839    * @see DynamicTableTest#testAddColumnAndCommitType()
840    * @see org.melati.poem.Table#addColumnAndCommit(ColumnInfo)
841    */
842   public void testAddColumnAndCommitType() {
843   }
844 
845   /**
846    * @see DynamicTableTest#testAddColumnAndCommitBoolean()
847    * @see org.melati.poem.Table#addColumnAndCommit(ColumnInfo)
848    */
849   public void testAddColumnAndCommitBoolean() {
850   }
851 
852   /**
853    * @see DynamicTableTest#testAddColumnAndCommitInteger()
854    * @see org.melati.poem.Table#addColumnAndCommit(ColumnInfo)
855    */
856   public void testAddColumnAndCommitInteger() {
857   }
858   /**
859    * @see DynamicTableTest#testAddColumnAndCommitNullableInteger()
860    * @see org.melati.poem.Table#addColumnAndCommit(ColumnInfo)
861    */
862   public void testAddColumnAndCommitNullableInteger() {
863   }
864 
865   /**
866    * @see DynamicTableTest#testAddColumnAndCommitDouble()
867    * @see org.melati.poem.Table#addColumnAndCommit(ColumnInfo)
868    */
869   public void testAddColumnAndCommitDouble() {
870   }
871 
872   /**
873    * @see DynamicTableTest#testAddColumnAndCommitLong()
874    * @see org.melati.poem.Table#addColumnAndCommit(ColumnInfo)
875    */
876   public void testAddColumnAndCommitLong() {
877   }
878 
879   /**
880    * @see DynamicTableTest#testAddColumnAndCommitBigDecimal()
881    * @see org.melati.poem.Table#addColumnAndCommit(ColumnInfo)
882    */
883   public void testAddColumnAndCommitBigDecimal() {
884   }
885 
886   /**
887    * @see DynamicTableTest#testAddColumnAndCommitString()
888    * @see org.melati.poem.Table#addColumnAndCommit(ColumnInfo)
889    */
890   public void testAddColumnAndCommitString() {
891   }
892 
893   /**
894    * @see DynamicTableTest#testAddColumnAndCommitPassword()
895    * @see org.melati.poem.Table#addColumnAndCommit(ColumnInfo)
896    */
897   public void testAddColumnAndCommitPassword() {
898   }
899 
900   /**
901    * @see DynamicTableTest#testAddColumnAndCommitDate()
902    * @see org.melati.poem.Table#addColumnAndCommit(ColumnInfo)
903    */
904   public void testAddColumnAndCommitDate() {
905   }
906 
907   /**
908    * @see DynamicTableTest#testAddColumnAndCommitTimestamp()
909    * @see org.melati.poem.Table#addColumnAndCommit(ColumnInfo)
910    */
911   public void testAddColumnAndCommitTimestamp() {
912   }
913 
914   /**
915    * @see DynamicTableTest#testAddColumnAndCommitBinary()
916    * @see org.melati.poem.Table#addColumnAndCommit(ColumnInfo)
917    */
918   public void testAddColumnAndCommitBinary() {
919   }
920 
921   /**
922    * @see org.melati.poem.Table#addColumnAndCommit(ColumnInfo)
923    */
924   public void testAddColumnAndCommitDisplaylevel() {
925   }
926 
927   /**
928    * @see DynamicTableTest#testAddColumnAndCommitSearchability()
929    * @see org.melati.poem.Table#addColumnAndCommit(ColumnInfo)
930    */
931   public void testAddColumnAndCommitSearchability() {
932   }
933 
934   /**
935    * @see DynamicTableTest#testAddColumnAndCommitIntegrityfix()
936    * @see org.melati.poem.Table#addColumnAndCommit(ColumnInfo)
937    */
938   public void testAddColumnAndCommitIntegrityfix() {
939   }
940 
941   /**
942    * @see org.melati.poem.Table#toString()
943    */
944   public void testToString() {
945     Table<User> ut = getDb().getUserTable();
946     assertEquals("user (from the data structure definition)", ut.toString());
947 
948   }
949 
950   /**
951    * @see org.melati.poem.Table#dumpCacheAnalysis()
952    */
953   public void testDumpCacheAnalysis() {
954 
955   }
956 
957   /**
958    * @see org.melati.poem.Table#dump()
959    */
960   public void testDump() {
961     ByteArrayOutputStream baos = new ByteArrayOutputStream();
962     PrintStream ps = new PrintStream(baos);
963     getDb().getUserTable().dump(ps);
964     System.err.println(baos.toString());
965     assertTrue(baos.toString().startsWith("=== table user (tableinfo id 0"));
966   }
967 
968   /**
969    * @see org.melati.poem.Table#cachedSelection(String, String)
970    */
971   public void testCachedSelection() {
972 
973   }
974 
975   /**
976    * @see org.melati.poem.Table#cachedCount(String, boolean)
977    */
978   public void testCachedCountStringBoolean() {
979 
980   }
981 
982   /**
983    * @see org.melati.poem.Table#cachedCount(String, boolean, boolean)
984    */
985   public void testCachedCountStringBooleanBoolean() {
986   }
987 
988   /**
989    * Ensure that sqlBooleanValue is tested.
990    * @see org.melati.poem.Table#cachedCount(Persistent, boolean, boolean)
991    */
992   public void testCachedCountPersistentBooleanBoolean() {
993     TableInfo ti = (TableInfo)getDb().getTableInfoTable().newPersistent();
994     // A count of all table info records
995     CachedCount cached = getDb().getTableInfoTable().cachedCount(ti,false,false); 
996     if (getDb().getDbms().canDropColumns()) 
997       assertEquals(9, cached.count());
998     ti.setSeqcached(true);
999     // A count of all records with seqCached true 
1000     cached = getDb().getTableInfoTable().cachedCount(ti,false,false); 
1001     assertEquals(7, cached.count());
1002   }
1003   
1004 
1005   /**
1006    * @see org.melati.poem.Table#cachedCount(String)
1007    */
1008   public void testCachedCountString() {
1009 
1010   }
1011 
1012   /**
1013    * @see org.melati.poem.Table#cachedCount(Persistent)
1014    */
1015   public void testCachedCountPersistent() {
1016     TableInfo ti = (TableInfo)getDb().getTableInfoTable().newPersistent();
1017     CachedCount cached = getDb().getTableInfoTable().cachedCount(ti); 
1018     if (getDb().getDbms().canDropColumns())
1019       assertEquals(9, cached.count());
1020     ti.setSeqcached(true);
1021     cached = getDb().getTableInfoTable().cachedCount(ti); 
1022     assertEquals(7, cached.count());
1023   }
1024 
1025   /**
1026    * @see org.melati.poem.Table#cachedExists(String)
1027    */
1028   public void testCachedExists() {
1029     CachedExists cached = getDb().getUserTable().cachedExists(null); 
1030     assertEquals(2, cached.count());
1031     User t = (User)getDb().getUserTable().newPersistent();
1032     t.setName("TestUser");
1033     t.setLogin("TestUser");
1034     t.setPassword("TestUser");
1035     t.makePersistent();
1036     assertEquals(3, cached.count());
1037     t.delete();
1038   }
1039 
1040   /**
1041    * @see org.melati.poem.Table#cachedSelectionType(String, String, boolean)
1042    */
1043   public void testCachedSelectionType() {
1044 
1045   }
1046 
1047   /**
1048    * @see org.melati.poem.Table#cachedSelectionField(String, String, boolean,
1049    *      Integer, String)
1050    */
1051   public void testCachedSelectionField() {
1052     // getDb().setLogSQL(true);
1053     String whereClause = getDb().getTableInfoTable().getDisplayorderColumn().fullQuotedName() + 
1054     "  <3000 AND " + getDb().getTableInfoTable().getDisplayorderColumn().fullQuotedName() + "  > 2000";
1055     Field<?> userTableFields = getDb().getTableInfoTable()
1056         .cachedSelectionField(whereClause, null,
1057             true, null, "userTables");
1058     Enumeration<?> them = userTableFields.getPossibilities();
1059     assertEquals("userTables: ", them.nextElement().toString());
1060     assertEquals("userTables: User", them.nextElement().toString());
1061     assertEquals("userTables: Group", them.nextElement().toString());
1062     assertEquals("userTables: Capability",them.nextElement().toString());
1063     assertEquals("userTables: Group membership",them.nextElement().toString());
1064     assertEquals("userTables: Group capability",them.nextElement().toString());
1065     assertFalse(them.hasMoreElements());
1066     assertEquals(null, userTableFields.getRaw());
1067 
1068     // with order by
1069     userTableFields = getDb().getTableInfoTable()
1070     .cachedSelectionField(whereClause, 
1071             getDb().getTableInfoTable().getDisplaynameColumn().fullQuotedName(), true, null, "userTables");
1072     them = userTableFields.getPossibilities();
1073     assertEquals(them.nextElement().toString(), "userTables: ");
1074     assertEquals(them.nextElement().toString(), "userTables: Capability");
1075     assertEquals(them.nextElement().toString(), "userTables: Group");
1076     assertEquals(them.nextElement().toString(), "userTables: Group capability");
1077     assertEquals(them.nextElement().toString(), "userTables: Group membership");
1078     assertEquals(them.nextElement().toString(), "userTables: User");
1079     assertFalse(them.hasMoreElements());
1080     assertEquals(null, userTableFields.getRaw());
1081 
1082     // without null option
1083     userTableFields = getDb().getTableInfoTable().cachedSelectionField(
1084         whereClause,
1085         getDb().getTableInfoTable().getDisplaynameColumn().fullQuotedName(), false, null, "userTables");
1086     them = userTableFields.getPossibilities();
1087     assertEquals(them.nextElement().toString(), "userTables: Capability");
1088     assertEquals(them.nextElement().toString(), "userTables: Group");
1089     assertEquals(them.nextElement().toString(), "userTables: Group capability");
1090     assertEquals(them.nextElement().toString(), "userTables: Group membership");
1091     assertEquals(them.nextElement().toString(), "userTables: User");
1092     assertFalse(them.hasMoreElements());
1093     assertEquals(null, userTableFields.getRaw());
1094 
1095     // with a troid
1096     userTableFields = getDb().getTableInfoTable().cachedSelectionField(
1097         whereClause,
1098         getDb().getTableInfoTable().getDisplaynameColumn().fullQuotedName(), false, new Integer(0), "userTables");
1099     them = userTableFields.getPossibilities();
1100     assertEquals(them.nextElement().toString(), "userTables: Capability");
1101     assertEquals(them.nextElement().toString(), "userTables: Group");
1102     assertEquals(them.nextElement().toString(), "userTables: Group capability");
1103     assertEquals(them.nextElement().toString(), "userTables: Group membership");
1104     assertEquals(them.nextElement().toString(), "userTables: User");
1105     assertFalse(them.hasMoreElements());
1106     assertEquals(new Integer(0), userTableFields.getRaw());
1107   }
1108 
1109 
1110   /**
1111    * @see org.melati.poem.Table#defineColumn(Column)
1112    */
1113   public void testDefineColumnColumn() {
1114 
1115   }
1116 
1117   /**
1118    * @see org.melati.poem.Table#setTableInfo(TableInfo)
1119    */
1120   public void testSetTableInfo() {
1121 
1122   }
1123 
1124   /**
1125    * @see org.melati.poem.Table#getTableInfo()
1126    */
1127   public void testGetTableInfo() {
1128 
1129   }
1130 
1131   /**
1132    * @see org.melati.poem.Table#defaultDisplayName()
1133    */
1134   public void testDefaultDisplayName() {
1135 
1136   }
1137 
1138   /**
1139    * @see org.melati.poem.Table#defaultDisplayOrder()
1140    */
1141   public void testDefaultDisplayOrder() {
1142 
1143   }
1144 
1145   /**
1146    * @see org.melati.poem.Table#defaultDescription()
1147    */
1148   public void testDefaultDescription() {
1149 
1150   }
1151 
1152   /**
1153    * @see org.melati.poem.Table#defaultCacheLimit()
1154    */
1155   public void testDefaultCacheLimit() {
1156 
1157   }
1158 
1159   /**
1160    * @see org.melati.poem.Table#defaultRememberAllTroids()
1161    */
1162   public void testDefaultRememberAllTroids() {
1163 
1164   }
1165 
1166   /**
1167    * @see org.melati.poem.Table#defaultCategory()
1168    */
1169   public void testDefaultCategory() {
1170 
1171   }
1172 
1173   /**
1174    * @see org.melati.poem.Table#createTableInfo()
1175    */
1176   public void testCreateTableInfo() {
1177 
1178   }
1179 
1180   /**
1181    * @see org.melati.poem.Table#unifyWithColumnInfo()
1182    */
1183   public void testUnifyWithColumnInfo() {
1184 
1185   }
1186 
1187   /**
1188    * @see org.melati.poem.Table#init()
1189    */
1190   public void testInit() {
1191 
1192   }
1193 
1194   /**
1195    * @see org.melati.poem.Table#hashCode()
1196    */
1197   public void testHashCode() {
1198     Table<User> ut = getDb().getUserTable();
1199     Table<User> ut2 = getDb().getUserTable();
1200     assertTrue(ut.equals(ut2));
1201     assertEquals(ut.hashCode(), ut2.hashCode());
1202   }
1203 
1204   /**
1205    * @see org.melati.poem.Table#equals(Object)
1206    */
1207   public void testEqualsObject() {
1208     Table<User> ut = getDb().getUserTable();
1209     Table<Capability> ct = getDb().getCapabilityTable();
1210     assertFalse(ut.equals(ct));
1211     Table<User> ut2 = getDb().getUserTable();
1212     assertTrue(ut.equals(ut2));
1213     assertTrue(ut2.equals(ut));
1214     assertTrue(ut.equals(ut));
1215     assertFalse(ut.equals(null));
1216     assertFalse(ut.equals(new Object()));
1217 
1218   }
1219 
1220 }