FilledNodeTest


1   /*
2   
3   This software is OSI Certified Open Source Software.
4   OSI Certified is a certification mark of the Open Source Initiative.
5   
6   The license (Mozilla version 1.0) can be read at the MMBase site.
7   See http://www.MMBase.org/license
8   
9   */
10  
11  package org.mmbase.bridge;
12  
13  import java.text.*;
14  import java.util.*;
15  import org.w3c.dom.Document  ;
16  
17  import org.mmbase.util.Casting;
18  import org.mmbase.datatypes.*;
19  
20  /**
21   * Test class <code>Node</code> from the bridge package. The tests are done on
22   * a filled node.
23   *
24   * @author Jaco de Groot
25   * @author Michiel Meeuwissen
26   */
27  public class FilledNodeTest extends NodeTest {
28  
29      protected long TEST_TIME = (long) 20 * 356 * 24 * 60 * 60 * 1000;
30      protected Date TEST_DATE = new Date(TEST_TIME);
31  
32      public FilledNodeTest(String   name) {
33          super(name);
34      }
35  
36      protected Document   getEmptyDocument() {
37          try {
38              javax.xml.parsers.DocumentBuilderFactory   dfactory = javax.xml.parsers.DocumentBuilderFactory.newInstance();
39              dfactory.setNamespaceAware(true);
40              javax.xml.parsers.DocumentBuilder     documentBuilder = dfactory.newDocumentBuilder();
41              org.mmbase.bridge.util.xml.Generator generator = new org.mmbase.bridge.util.xml.Generator(documentBuilder);
42              return generator.getDocument();
43          } catch (Exception   e) {
44              throw new RuntimeException  (e);
45          }
46      }
47      protected String   getNodeManager() {
48          return "aa";
49      }
50  
51      public void setUp() {
52          // Create a test node.
53          Cloud cloud = getCloud();
54          cloud.setLocale(Locale.US);
55          node = cloud.getNodeManager(getNodeManager()).createNode();
56          Node typedefNode = cloud.getNodeManager("bb");
57          assertTrue(typedefNode != null);
58          byte[] bytes = { 72, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100, 33 };
59          node.setValue("bytefield", bytes);
60          node.setValue("doublefield", new Double  (Double.MAX_VALUE));
61          node.setValue("floatfield", new Float  (Float.MAX_VALUE));
62          node.setValue("intfield", new Integer  (Integer.MAX_VALUE));
63          node.setValue("longfield", new Long  (Long.MAX_VALUE));
64          node.setValue("stringfield", "Bridge testing!");
65          node.setValue("xmlfield", getEmptyDocument());
66          node.setValue("nodefield", typedefNode);
67          org.mmbase.datatypes.DataType dt = node.getNodeManager().getField("datetimefield").getDataType();
68          //assertTrue("Not a datetime-datatype but " + dt.getClass(), dt.getClass().equals(org.mmbase.datatypes.DateTimeDataType.class)); // would give error in Node#setValue otherwise
69  
70          node.setValue("datetimefield", TEST_DATE);
71          node.setValue("booleanfield", Boolean.TRUE);
72          List list = new ArrayList();
73          list.add(Boolean.TRUE);
74          list.add(Boolean.TRUE);
75          //node.setValue("listfield", list);
76          node.commit();
77      }
78  
79      public void tearDown() {
80          // Remove test node.
81          node.delete();
82      }
83  
84      public void testGetValue() {
85          for (int i = 0; i < fieldTypes.length; i++) {
86              Object   object = node.getValue(fieldTypes[i] + "field");
87              if (fieldTypes[i].equals("byte")) {
88                  byte[] bytes = (byte[])object;
89                  assertTrue("getValue on byte field should give 'Hello World!' but gave '" + new String  (bytes) + "'",
90                      "Hello world!".equals(new String  (bytes)));
91              } else if (fieldTypes[i].equals("double")) {
92                  assertTrue("getValue on double field should give " +  Double.MAX_VALUE + " but gave " + object,
93                      new Double  (Double.MAX_VALUE).compareTo((Double  )object) == 0);
94              } else if (fieldTypes[i].equals("float")) {
95                  assertTrue("getValue on float field should give " +  Float.MAX_VALUE + " but gave " + object,
96                      new Float  (Float.MAX_VALUE).compareTo((Float  )object) == 0);
97              } else if (fieldTypes[i].equals("int")) {
98                  assertTrue("getValue on int field should give " +  Integer.MAX_VALUE + " but gave " + object,
99                      new Integer  (Integer.MAX_VALUE).compareTo((Integer  )object) == 0);
100             } else if (fieldTypes[i].equals("long")) {
101                 assertTrue("getValue on long field should give " +  Long.MAX_VALUE + " but gave " + object,
102                     new Long  (Long.MAX_VALUE).compareTo((Long  )object) == 0);
103             } else if (fieldTypes[i].equals("string")) {
104                 assertTrue("getValue on string field should give \"Bridge testing!\" but gave " + object,
105                     "Bridge testing!".equals(object));
106             } else if (fieldTypes[i].equals("xml")) {
107                 //   assertTrue(getEmptyDocument().isEqualNode((org.w3c.dom.Node)object)); java 1.5
108                 assertTrue("getValue on xml field should give ??? but gave ",
109                     Casting.toString(getEmptyDocument()).equals(Casting.toString(object)));
110             } else if (fieldTypes[i].equals("node")) {
111                 Node typedefNode = getCloud().getNodeManager("bb");
112                 assertTrue("getValue on node field should give " + typedefNode.getNumber() +" but gave " + ((Node) object).getNumber(),
113                       ((Node) object).getNumber() == typedefNode.getNumber());
114             } else if (fieldTypes[i].equals("datetime")) {
115                 assertTrue("getValue on datetime field should give " + TEST_DATE +" but gave " + object,
116                     TEST_DATE.equals(object));
117             } else if (fieldTypes[i].equals("boolean")) {
118                 assertTrue("getValue on boolean field should give TRUE but gave " + object,object.equals(Boolean.TRUE));
119             } else if (fieldTypes[i].equals("list")) {
120                 assertTrue("getValue on list field should give [TRUE,TRUE] but gave " + object,
121                     object instanceof List && ((List)object).size()==2 &&
122                     ((List)object).get(0).equals(Boolean.TRUE) &&
123                     ((List)object).get(1).equals(Boolean.TRUE));
124             } else {
125                 fail();
126             }
127         }
128     }
129 
130     public void testGetByteValue() {
131         for (int i = 0; i < fieldTypes.length; i++) {
132             byte[] bytes = node.getByteValue(fieldTypes[i] + "field");
133             if (fieldTypes[i].equals("byte")) {
134                 byte[] check = { 72, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100, 33 };
135                 for (int j = 0; j < bytes.length; j++) {
136                     assertTrue(bytes[j] == check[j]);
137                 }
138             } else if (fieldTypes[i].equals("double")) {
139                 assertTrue(bytes.length == 0);
140             } else if (fieldTypes[i].equals("float")) {
141                 assertTrue(bytes.length == 0);
142             } else if (fieldTypes[i].equals("int")) {
143                 assertTrue(bytes.length == 0);
144             } else if (fieldTypes[i].equals("long")) {
145                 assertTrue(bytes.length == 0);
146             } else if (fieldTypes[i].equals("string")) {
147                 assertTrue("Bridge testing!".equals(new String  (bytes)));
148             } else if (fieldTypes[i].equals("xml")) {
149                 assertTrue(bytes.length == 0);
150             } else if (fieldTypes[i].equals("node")) {
151                 assertTrue(bytes.length == 0);
152             } else if (fieldTypes[i].equals("boolean")) {
153                 assertTrue(bytes.length == 0);
154             } else if (fieldTypes[i].equals("datetime")) {
155                 assertTrue(bytes.length == 0);
156             } else if (fieldTypes[i].equals("list")) {
157                 assertTrue(bytes.length == 0);
158             } else {
159                 fail();
160             }
161         }
162     }
163 
164     public void testGetDoubleValue() {
165         for (int i = 0; i < fieldTypes.length; i++) {
166             double d = node.getDoubleValue(fieldTypes[i] + "field");
167             if (fieldTypes[i].equals("byte")) {
168                 assertTrue(d == -1);
169             } else if (fieldTypes[i].equals("double")) {
170                 assertTrue(d == Double.MAX_VALUE);
171             } else if (fieldTypes[i].equals("float")) {
172                 assertTrue(d == Float.MAX_VALUE);
173             } else if (fieldTypes[i].equals("int")) {
174                 assertTrue(d == Integer.MAX_VALUE);
175             } else if (fieldTypes[i].equals("long")) {
176                 assertTrue(d == Long.MAX_VALUE);
177             } else if (fieldTypes[i].equals("string")) {
178                 assertTrue(d == -1);
179             } else if (fieldTypes[i].equals("xml")) {
180                 assertTrue(d == -1);
181             } else if (fieldTypes[i].equals("node")) {
182                 assertTrue(d == getCloud().getNodeManager("bb").getNumber());
183             } else if (fieldTypes[i].equals("boolean")) {
184                 assertTrue(d == 1);
185             } else if (fieldTypes[i].equals("datetime")) {
186                 assertTrue(fieldTypes[i] + "field queried as double did not return " + (double)TEST_TIME/1000 + " but " + d,
187                         d == (double)TEST_TIME/1000);
188             } else if (fieldTypes[i].equals("list")) {
189                 assertTrue(d == -1);
190             } else {
191                 fail();
192             }
193         }
194     }
195 
196     public void testGetFloatValue() {
197         for (int i = 0; i < fieldTypes.length; i++) {
198             float f = node.getFloatValue(fieldTypes[i] + "field");
199             if (fieldTypes[i].equals("byte")) {
200                 assertTrue(f == -1);
201             } else if (fieldTypes[i].equals("double")) {
202                 assertTrue("Infinity".equals(String.valueOf(f)));
203             } else if (fieldTypes[i].equals("float")) {
204                 assertTrue(f == Float.MAX_VALUE);
205             } else if (fieldTypes[i].equals("int")) {
206                 assertTrue(f == Integer.MAX_VALUE);
207             } else if (fieldTypes[i].equals("long")) {
208                 assertTrue(f == Long.MAX_VALUE);
209             } else if (fieldTypes[i].equals("string")) {
210                 assertTrue(f == -1);
211             } else if (fieldTypes[i].equals("xml")) {
212                 assertTrue(f == -1);
213             } else if (fieldTypes[i].equals("node")) {
214                 assertTrue(f == getCloud().getNodeManager("bb").getNumber());
215             } else if (fieldTypes[i].equals("boolean")) {
216                 assertTrue(f == 1);
217             } else if (fieldTypes[i].equals("datetime")) {
218                 assertTrue(fieldTypes[i] + "field queried as float did not return " + (float)TEST_TIME/1000 + " but " + f,
219                         f == (float)TEST_TIME/1000);
220             } else if (fieldTypes[i].equals("list")) {
221                 assertTrue(f == -1);
222             } else {
223                 fail();
224             }
225         }
226     }
227 
228     public void testGetIntValue() {
229         for (int i = 0; i < fieldTypes.length; i++) {
230             int integer = node.getIntValue(fieldTypes[i] + "field");
231             if (fieldTypes[i].equals("byte")) {
232                 assertTrue(integer == -1);
233             } else if (fieldTypes[i].equals("double")) {
234                 assertTrue(integer == Integer.MAX_VALUE);
235             } else if (fieldTypes[i].equals("float")) {
236                 assertTrue(integer == Integer.MAX_VALUE);
237             } else if (fieldTypes[i].equals("int")) {
238                 assertTrue(integer == Integer.MAX_VALUE);
239             } else if (fieldTypes[i].equals("long")) {
240                 assertTrue(integer == Integer.MAX_VALUE);
241             } else if (fieldTypes[i].equals("string")) {
242                 assertTrue(integer == -1);
243             } else if (fieldTypes[i].equals("xml")) {
244                 assertTrue(integer == -1);
245             } else if (fieldTypes[i].equals("node")) {
246                 assertTrue(integer == getCloud().getNodeManager("bb").getNumber());
247             } else if (fieldTypes[i].equals("boolean")) {
248                 assertTrue(integer == 1);
249             } else if (fieldTypes[i].equals("datetime")) {
250                 assertTrue(fieldTypes[i] + "field queried as double did not return " + TEST_TIME / 1000 + " but " + integer,
251                         integer == (int) (TEST_TIME / 1000));
252             } else if (fieldTypes[i].equals("list")) {
253                 assertTrue(integer == -1);
254             } else {
255                 fail();
256             }
257         }
258     }
259 
260     public void testGetLongValue() {
261         for (int i = 0; i < fieldTypes.length; i++) {
262             long l = node.getLongValue(fieldTypes[i] + "field");
263             if (fieldTypes[i].equals("byte")) {
264                 assertTrue(l == -1);
265             } else if (fieldTypes[i].equals("double")) {
266                 assertTrue(l == Long.MAX_VALUE);
267             } else if (fieldTypes[i].equals("float")) {
268                 assertTrue(l == Long.MAX_VALUE);
269             } else if (fieldTypes[i].equals("int")) {
270                 assertTrue(l == Integer.MAX_VALUE);
271             } else if (fieldTypes[i].equals("long")) {
272                 assertTrue(l == Long.MAX_VALUE);
273             } else if (fieldTypes[i].equals("string")) {
274                 assertTrue(l == -1);
275             } else if (fieldTypes[i].equals("xml")) {
276                 assertTrue(l == -1);
277             } else if (fieldTypes[i].equals("node")) {
278                 assertTrue(l == getCloud().getNodeManager("bb").getNumber());
279             } else if (fieldTypes[i].equals("boolean")) {
280                 assertTrue(l == 1);
281             } else if (fieldTypes[i].equals("datetime")) {
282                 assertTrue(fieldTypes[i] + "field queried as double did not return " + TEST_TIME/1000 + " but " + l,
283                     l == TEST_TIME/1000);
284             } else if (fieldTypes[i].equals("list")) {
285                 assertTrue(l == -1);
286             } else {
287                 fail();
288             }
289         }
290     }
291 
292     public void testGetStringValue() {
293         for (int i = 0; i < fieldTypes.length; i++) {
294             String   string = node.getStringValue(fieldTypes[i] + "field");
295             if (fieldTypes[i].equals("byte")) {
296                 assertTrue(fieldTypes[i] + "field queried as string did not return \"Hello world!\" but " + string, "Hello world!".equals(string));
297             } else if (fieldTypes[i].equals("double")) {
298                 assertTrue(fieldTypes[i] + "field queried as string did not return " + Double.MAX_VALUE + " but " + string,
299                     String.valueOf(Double.MAX_VALUE).equals(string));
300             } else if (fieldTypes[i].equals("float")) {
301                 // SQLDB causes some problems when rounding floats, which it stores internally as Doubles.
302                 // so compare the resulting string to both Float.MAX_VALUE and Double(Float.MAX_VALUE )
303                 // to cover this. Note that this somehow only applies when comparing strings.
304                 assertTrue(fieldTypes[i] + "field queried as string did not return " + Float.MAX_VALUE + " but " + string,
305                     String.valueOf(new Double  (Float.MAX_VALUE)).equals(string) || String.valueOf(Float.MAX_VALUE).equals(string));
306             } else if (fieldTypes[i].equals("int")) {
307                 assertTrue(fieldTypes[i] + "field queried as string did not return " + Integer.MAX_VALUE + " but " + string,
308                     String.valueOf(Integer.MAX_VALUE).equals(string));
309             } else if (fieldTypes[i].equals("long")) {
310                 assertTrue(fieldTypes[i] + "field queried as string did not return " + Long.MAX_VALUE + " but " + string,
311                     String.valueOf(Long.MAX_VALUE).equals(string));
312             } else if (fieldTypes[i].equals("string")) {
313                 assertTrue(fieldTypes[i] + "field queried as string did not return \"Bridge testing!\" but " + string,
314                     "Bridge testing!".equals(string));
315             } else if (fieldTypes[i].equals("xml")) {
316                 assertTrue(fieldTypes[i] + "field" +" field queried as string did not return empty document but " + string,
317                     Casting.toString(getEmptyDocument()).equals(string));
318             } else if (fieldTypes[i].equals("node")) {
319                 int number = getCloud().getNodeManager("bb").getNumber();
320                 assertTrue(fieldTypes[i] + "field queried as string did not return " + number + " but " + string,
321                     String.valueOf(number).equals(string));
322             } else if (fieldTypes[i].equals("boolean")) {
323                 assertTrue(fieldTypes[i] + "field queried as string did not return " + Boolean.TRUE + " but " + string,
324                            String.valueOf(Boolean.TRUE).equals(string));
325             } else if (fieldTypes[i].equals("datetime")) {
326                 Field field = node.getNodeManager().getField(fieldTypes[i] + "field");
327                 String   formatted;
328                 if (field.getDataType() instanceof DateTimeDataType) {
329                     DateTimePattern pattern = ((DateTimeDataType)field.getDataType()).getPattern();
330                     DateFormat dateFormat = pattern.getDateFormat(Locale.US);
331                     formatted = dateFormat.format(TEST_DATE);
332                 } else {
333                     formatted = Casting.toString(TEST_DATE);
334                 }
335                 assertTrue(fieldTypes[i] + "field of '" + getNodeManager() + "' queried as string did not return " + formatted + " but " + string,
336                            formatted.equals(string));
337             } else if (fieldTypes[i].equals("list")) {
338                 assertTrue(fieldTypes[i] + "field queried as string did not return \"true,true\" but " + string,
339                     "true,true".equals(string));
340             } else {
341                 fail();
342             }
343         }
344     }
345 
346     public void testGetXMLValue() {
347         for (int i = 0; i < fieldTypes.length; i++) {
348            if (fieldTypes[i].equals("xml") || fieldTypes[i].equals("string")) {
349                Document   document = node.getXMLValue(fieldTypes[i] + "field");
350                assertTrue(fieldTypes[i] + " field queried as XML returns null", document !=null);
351            }
352         }
353     }
354 
355    public void testGetNodeValue() {
356         Node nodeValue = node.getNodeValue("nodefield");
357         assertTrue(nodeValue != null);
358         assertTrue(nodeValue.getNumber() == getCloud().getNodeManager("bb").getNumber());
359         // getNodeValue on other types not defined (according to javadoc), so not tested here.
360     }
361 
362 
363     public void testGetBooleanValue() {
364         for (int i = 0; i < fieldTypes.length; i++) {
365            boolean bool = node.getBooleanValue(fieldTypes[i] + "field");
366            if (fieldTypes[i].equals("list") || fieldTypes[i].equals("xml") || fieldTypes[i].equals("string")
367                 || fieldTypes[i].equals("byte")) {
368                assertTrue(fieldTypes[i] + " field queried as boolean returns TRUE", !bool);
369            } else {
370                assertTrue(fieldTypes[i] + " field queried as boolean returns FALSE", bool);
371            }
372         }
373     }
374 
375     public void testGetDateTimeValue() {
376         for (int i = 0; i < fieldTypes.length; i++) {
377             Date value = null;
378             if (fieldTypes[i].equals("node")) {
379                 value = node.getDateValue(fieldTypes[i] + "field");
380                 assertTrue(fieldTypes[i] + " field queried as datetime did not return "+new Date(-1)+", but " + value,
381                             value.getTime()==-1);
382             } else if (fieldTypes[i].equals("datetime")) {
383                 value = node.getDateValue(fieldTypes[i] + "field");
384                 assertTrue(fieldTypes[i] + " field queried as datetime did not return "+new Date(TEST_TIME)+", but " + value,
385                             value.getTime()==TEST_TIME);
386             } else if (fieldTypes[i].equals("double")) {
387                 value = node.getDateValue(fieldTypes[i] + "field");
388                 long time = new Double  (Double.MAX_VALUE).longValue() * 1000;
389                 assertTrue(fieldTypes[i] + " field queried as datetime did not return "+new Date(time)+", but " + value,
390                             value.getTime()==time);
391             } else if (fieldTypes[i].equals("float")) {
392                 value = node.getDateValue(fieldTypes[i] + "field");
393                 long time = new Float  (Float.MAX_VALUE).longValue() * 1000;
394                 assertTrue(fieldTypes[i] + " field queried as datetime did not return "+new Date(time)+", but " + value,
395                             value.getTime()==time);
396             } else if (fieldTypes[i].equals("int")) {
397                 value = node.getDateValue(fieldTypes[i] + "field");
398                 long time = new Integer  (Integer.MAX_VALUE).longValue()*1000;
399                 assertTrue(fieldTypes[i] + " field queried as datetime did not return "+new Date(time)+", but " + value,
400                             value.getTime()==time);
401             } else if (fieldTypes[i].equals("long")) {
402                 value = node.getDateValue(fieldTypes[i] + "field");
403                 long time = Long.MAX_VALUE*1000; // oddd..
404                 assertTrue(fieldTypes[i] + " field queried as datetime did not return "+new Date(time) + ", but " + value,
405                             value.getTime()==time);
406             } else {
407                 try {
408                     value = node.getDateValue(fieldTypes[i] + "field");
409                     fail(fieldTypes[i] + " field 's value '" + node.getStringValue(fieldTypes[i] + "field") + "' cannot be queried as a date, should have thrown exception");
410                 } catch (Throwable   e) {
411                     return;
412                 }
413             }
414             assertTrue(fieldTypes[i] + " field queried as datetime returned null", value != null);
415        }
416     }
417 
418     public void testGetListValue() {
419         for (int i = 0; i < fieldTypes.length; i++) {
420             List value = node.getListValue(fieldTypes[i] + "field");
421             assertTrue(fieldTypes[i] + " field queried as list returned null", value!=null);
422             if (fieldTypes[i].equals("list")) {
423                 assertTrue(fieldTypes[i] + " field queried as list did not return [TRUE,TRUE], but " + value,
424                     value.size()==2 && value.get(0).equals(Boolean.TRUE) && value.get(1).equals(Boolean.TRUE));
425            } else {
426                 assertTrue(fieldTypes[i] + " field queried as list did not return [<node>], but " + value,
427                             value.size() == 1);
428             }
429        }
430     }
431 
432 }
433
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags