1 package org.melati.poem.test;
2
3 import java.io.PrintStream;
4 import java.text.DateFormat;
5 import java.util.Enumeration;
6
7 import org.melati.poem.AccessPoemException;
8 import org.melati.poem.BaseFieldAttributes;
9 import org.melati.poem.Field;
10 import org.melati.poem.FieldAttributes;
11 import org.melati.poem.IntegerPoemType;
12 import org.melati.poem.PoemLocale;
13 import org.melati.poem.ReferencePoemType;
14 import org.melati.poem.StringPoemType;
15 import org.melati.poem.User;
16
17
18
19
20
21 public class FieldTest extends PoemTestCase {
22
23 Field<String> stringField = null;
24 Field<Integer> integerField = null;
25
26 public FieldTest(String name) {
27 super(name);
28 }
29
30 protected void setUp()
31 throws Exception {
32 super.setUp();
33 stringField = new Field<String>("stringfield", new BaseFieldAttributes<String>("stringName",
34 "String Display Name", "String description",
35 StringPoemType.nullableInstance,
36 20,
37 1,
38 null,
39 false,
40 true,
41 true
42 ));
43 integerField = new Field<Integer>(new Integer(1), new BaseFieldAttributes<Integer>("integerName",
44 "Integer Display Name", "Integer description",
45 IntegerPoemType.nullableInstance,
46 20,
47 1,
48 null,
49 false,
50 true,
51 true
52 ));
53 }
54
55 protected void tearDown()
56 throws Exception {
57 super.tearDown();
58 }
59
60
61
62
63 public void testFieldObjectFieldAttributes() {
64
65 }
66
67
68
69
70
71 @SuppressWarnings({ "unchecked"})
72 public void testFieldAccessPoemExceptionFieldAttributes() {
73 @SuppressWarnings("rawtypes")
74 Field f = new Field<String>(new AccessPoemException(), stringField);
75 try {
76 f.getRaw();
77 fail("Should have blown up");
78 } catch (AccessPoemException e) {
79 e = null;
80 }
81 try {
82 f.getRawString();
83 fail("Should have blown up");
84 } catch (AccessPoemException e) {
85 e = null;
86 }
87 try {
88 f.getCooked();
89 fail("Should have blown up");
90 } catch (AccessPoemException e) {
91 e = null;
92 }
93 try {
94 f.getCookedString(PoemLocale.HERE, DateFormat.MEDIUM);
95 fail("Should have blown up");
96 } catch (AccessPoemException e) {
97 e = null;
98 }
99 try {
100 f.sameRawAs(integerField);
101 fail("Should have blown up");
102 } catch (AccessPoemException e) {
103 e = null;
104 }
105 }
106
107
108
109
110 @SuppressWarnings("unchecked")
111 public void testClone() {
112 Field<String> s2 = (Field<String>)stringField.clone();
113 assertFalse(s2.equals(stringField));
114 assertEquals(stringField.getName(), s2.getName());
115
116 Field<Integer> i2 = (Field<Integer>)integerField.clone();
117 assertFalse(i2.equals(integerField));
118 assertEquals(integerField.getName(), i2.getName());
119 }
120
121
122
123
124 public void testGetName() {
125 assertEquals("stringName", stringField.getName());
126 assertEquals("integerName", integerField.getName());
127 }
128
129
130
131
132 public void testGetDisplayName() {
133 assertEquals("String Display Name", stringField.getDisplayName());
134 assertEquals("Integer Display Name", integerField.getDisplayName());
135 }
136
137
138
139
140 public void testGetDescription() {
141 assertEquals("String description", stringField.getDescription());
142 assertEquals("Integer description", integerField.getDescription());
143
144 }
145
146
147
148
149 public void testGetType() {
150 assertEquals(StringPoemType.nullableInstance, stringField.getType());
151 assertEquals(IntegerPoemType.nullableInstance, integerField.getType());
152
153 }
154
155
156
157
158 public void testGetIndexed() {
159 assertFalse(stringField.getIndexed());
160 assertFalse(integerField.getIndexed());
161 }
162
163
164
165
166 public void testGetUserEditable() {
167 assertTrue(stringField.getUserEditable());
168 assertTrue(integerField.getUserEditable());
169 }
170
171
172
173
174 public void testGetUserCreateable() {
175 assertTrue(stringField.getUserCreateable());
176 assertTrue(integerField.getUserCreateable());
177 }
178
179
180
181
182 public void testGetWidth() {
183 assertEquals(20, stringField.getWidth());
184 assertEquals(20, integerField.getWidth());
185 }
186
187
188
189
190 public void testGetHeight() {
191 assertEquals(1, stringField.getHeight());
192 assertEquals(1, integerField.getHeight());
193 }
194
195
196
197
198 public void testGetRenderInfo() {
199 assertNull(stringField.getRenderInfo());
200 assertNull(integerField.getRenderInfo());
201 }
202
203
204
205
206 public void testGetRaw() {
207 assertEquals("stringfield", stringField.getRaw());
208 assertEquals(new Integer(1), integerField.getRaw());
209 }
210
211
212
213
214 public void testGetRawString() {
215 assertEquals("stringfield", stringField.getRawString());
216 assertEquals("1", integerField.getRawString());
217 }
218
219
220
221
222 public void testGetCooked() {
223 assertEquals("stringfield", stringField.getCooked());
224 assertEquals(new Integer(1), integerField.getCooked());
225 }
226
227
228
229
230 public void testGetCookedString() {
231 assertEquals("stringfield", stringField.getCookedString(PoemLocale.HERE, DateFormat.MEDIUM));
232 assertEquals("1", integerField.getCookedString(PoemLocale.HERE, DateFormat.MEDIUM));
233 }
234
235
236
237
238 public void testWithRaw() {
239 Field<String> stringField2 = stringField.withRaw("stringField2");
240 assertEquals("stringField2", (String)stringField2.getRaw());
241
242 Field<Integer> integerField2 = integerField.withRaw(new Integer(2));
243 assertEquals(new Integer(2), integerField2.getRaw());
244 }
245
246
247
248
249 public void testWithNullable() {
250 assertTrue(stringField.getType().getNullable());
251 Field<String> stringField2 = stringField.withNullable(false);
252 assertFalse(stringField2.getType().getNullable());
253
254 assertTrue(integerField.getType().getNullable());
255 Field<Integer> integerField2 = integerField.withNullable(false);
256 assertFalse(integerField2.getType().getNullable());
257 }
258
259
260
261
262 public void testWithName() {
263 Field<String> stringField2 = stringField.withName("stringField2");
264 assertEquals("stringField2", stringField2.getName());
265 Field<Integer> integerField2 = integerField.withName("integerField2");
266 assertEquals("integerField2", integerField2.getName());
267 }
268
269
270
271
272 public void testWithDescription() {
273 Field<String> stringField2 = stringField.withDescription("stringField2");
274 assertEquals("stringField2", stringField2.getDescription());
275 Field<Integer> integerField2 = integerField.withDescription("integerField2");
276 assertEquals("integerField2", integerField2.getDescription());
277 }
278
279
280
281
282 public void testGetPossibilities() {
283 Enumeration<?> en = stringField.getPossibilities();
284 assertNull(en);
285 en = integerField.getPossibilities();
286 assertNull(en);
287 }
288
289
290
291
292 public void testGetFirst1000Possibilities() {
293 Enumeration<?> en = stringField.getFirst1000Possibilities();
294 assertNull(en);
295 en = integerField.getFirst1000Possibilities();
296 assertNull(en);
297
298 Field<?> tableCategoryField = getDb().getTableInfoTable().getCategoryColumn().asEmptyField();
299 Enumeration<?> possibleCategories = tableCategoryField.getFirst1000Possibilities();
300 int counter = 0;
301 while (possibleCategories.hasMoreElements()) {
302 counter++;
303 possibleCategories.nextElement();
304 }
305 assertEquals(3, counter);
306 }
307
308
309
310
311 public void testSameRawAs() {
312 Field<String> stringField2 = stringField.withRaw("stringField2");
313 assertFalse(stringField.sameRawAs(stringField2));
314 stringField2 = stringField2.withRaw("stringfield");
315 assertTrue(stringField.sameRawAs(stringField2));
316 Field<Integer> integerField2 = integerField.withRaw(new Integer(2));
317 assertFalse(integerField.sameRawAs(integerField2));
318 integerField2 = integerField2.withRaw(new Integer(1));
319 assertTrue(integerField.sameRawAs(integerField2));
320 }
321
322
323
324
325 public void testDump() {
326
327 }
328
329
330
331
332 public void testToString() {
333
334 }
335
336
337
338
339 @SuppressWarnings({ "rawtypes", "unchecked" })
340 public void testBasic() {
341 Field f1 = Field.basic("basicField", "basicField", StringPoemType.nullableInstance);
342 Field f2 = Field.string("basicField", "basicField");
343 assertTrue(f1.sameRawAs(f2));
344 }
345
346
347
348
349 public void testString() {
350
351 }
352
353
354
355
356 @SuppressWarnings({ "rawtypes", "unchecked" })
357 public void testInteger() {
358 Field f1 = Field.basic(new Integer(13), "integerField", IntegerPoemType.nullableInstance);
359 Field f2 = Field.integer(new Integer(13), "integerField");
360 assertTrue(f1.sameRawAs(f2));
361 }
362
363
364
365
366 @SuppressWarnings({ "rawtypes", "unchecked" })
367 public void testReferencePersistentString() {
368 User u = getDb().guestUser();
369 Field f1 = Field.basic(u.getTroid(), "referenceField",
370 new ReferencePoemType(getDb().getUserTable(), true));
371 Field f2 = Field.reference(u, "referenceField");
372 assertTrue(f1.sameRawAs(f2));
373 }
374
375
376
377
378 @SuppressWarnings({ "rawtypes", "unchecked" })
379 public void testReferenceTableString() {
380 Field f1 = Field.basic(null, "referenceField",
381 new ReferencePoemType(getDb().getUserTable(), true));
382 Field f2 = Field.reference(getDb().getUserTable(), "referenceField");
383 assertTrue(f1.sameRawAs(f2));
384 }
385
386
387
388
389 public void testHashCode() {
390
391 }
392
393
394
395
396 public void testEquals() {
397
398 }
399
400 }