1   /*
2    wsmo4j - a WSMO API and Reference Implementation
3   
4    Copyright (c) 2005 University of Innsbruck, Austria  
5   
6    This library is free software; you can redistribute it and/or modify it under
7    the terms of the GNU Lesser General Public License as published by the Free
8    Software Foundation; either version 2.1 of the License, or (at your option)
9    any later version.
10   This library is distributed in the hope that it will be useful, but WITHOUT
11   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
12   FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
13   details.
14   You should have received a copy of the GNU Lesser General Public License along
15   with this library; if not, write to the Free Software Foundation, Inc.,
16   59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17   */
18  package test.wsmo4j.factory;
19  
20  import java.math.BigDecimal;
21  import java.math.BigInteger;
22  import java.util.*;
23  
24  import org.omwg.ontology.*;
25  
26  import test.wsmo4j.Wsmo4jTestCase;
27  
28  /**
29   * Interface or class description
30   *
31   * <pre>
32   * Created on Sep 5, 2005
33   * Committed by $Author: alex_simov $
34   * $Source$,
35   * </pre>
36   *
37   * @author holger.lausen@deri.org
38   *
39   * @version $Revision: 2258 $ $Date: 2007-11-22 15:57:06 +0200 (Thu, 22 Nov 2007) $
40   */
41  public class DataFactoryTest extends Wsmo4jTestCase {
42  
43      public void testExceptions(){
44          
45          try{
46              dataFactory.createWsmlDataType("kj");
47              fail("not supported datatype");
48          }catch (IllegalArgumentException e){
49          }
50          try{
51              dataFactory.createDataValue((ComplexDataType)dataFactory.createWsmlDataType(WsmlDataType.WSML_DOUBLE),
52                  dataFactory.createWsmlInteger(new BigInteger(""+1)));
53              fail("wrong argument type");
54          }catch (IllegalArgumentException e){}
55          dataFactory.createDataValue((ComplexDataType)dataFactory.createWsmlDataType(WsmlDataType.WSML_DATE),
56                  new SimpleDataValue[]{dataFactory.createWsmlInteger(new BigInteger(""+1)),
57                  dataFactory.createWsmlInteger(new BigInteger(""+1)),
58                  dataFactory.createWsmlInteger(new BigInteger(""+1))});
59          
60          try{
61              dataFactory.createDataValueFromJavaObject(dataFactory.createWsmlDataType(WsmlDataType.WSML_DATETIME),
62                  "some string");
63              fail("wrong argument type");
64          }catch (IllegalArgumentException e){}
65      }
66      
67      public void testDataTypes(){
68          WsmlDataType string = dataFactory.createWsmlDataType(WsmlDataType.WSML_STRING);
69          assertEquals(string.getIRI().toString(), WsmlDataType.WSML_STRING);
70          ComplexDataType gmonth = (ComplexDataType)dataFactory.createWsmlDataType(WsmlDataType.WSML_GMONTH);
71          assertEquals(gmonth.getIRI().toString(), WsmlDataType.WSML_GMONTH);
72          assertEquals(1,gmonth.getArity());
73      }
74      
75      public void testFloat(){
76          ComplexDataType floatDT = (ComplexDataType)dataFactory.createWsmlDataType(WsmlDataType.WSML_FLOAT);
77          //check if creation form java object works
78          DataValue floatDV = dataFactory.createDataValueFromJavaObject(floatDT, new Float(10));
79          assertEquals(floatDV.getValue(),new Float(10));
80          
81          //check if creation form wsml simple values works
82          DataValue floatDV2 = dataFactory.createDataValue(floatDT, 
83                  dataFactory.createWsmlString("1.0e1"));
84          assertEquals(floatDV.getValue(),new Float(10));
85          
86          //check if float create by SimpleType or JavaObject are identical
87          assertEquals(floatDV2, floatDV);
88          
89          DataValue floatDV3 = dataFactory.createWsmlFloat(new Float(10));
90          DataValue floatDV4 = dataFactory.createWsmlFloat("10");
91          
92          assertEquals(floatDV,floatDV3);
93          assertEquals(floatDV,floatDV4);
94      }
95  
96      public void testDouble(){
97          ComplexDataType datatype = (ComplexDataType)dataFactory.createWsmlDataType(WsmlDataType.WSML_DOUBLE);
98          //check if creation form java object works
99          Object javaValue = new Double(10);
100         DataValue datavalue1 = dataFactory.createDataValueFromJavaObject(datatype, javaValue);
101         assertEquals(datavalue1.getValue(),javaValue);
102         //check if creation form wsml simple values works
103         DataValue datavalue2 = dataFactory.createDataValue(datatype, 
104                 dataFactory.createWsmlString("1.0e1"));
105         assertEquals(datavalue2.getValue(),javaValue);
106         //create and check a different value
107         DataValue datavalue3 = dataFactory.createDataValue(datatype, 
108                 dataFactory.createWsmlString("11"));
109         assertEquals(datavalue2.getValue(),javaValue);        
110         //check if float create by SimpleType or JavaObject are identical
111         assertEquals(datavalue1, datavalue2);
112         assertTrue(!datavalue2.equals(datavalue3));
113         
114         DataValue doubleDV3 = dataFactory.createWsmlDouble(new Double(10));
115         DataValue doubleDV4 = dataFactory.createWsmlDouble("10");
116         
117         assertEquals(datavalue1,doubleDV3);
118         assertEquals(datavalue1,doubleDV4);
119     }
120     
121     public void testDateTime(){
122         ComplexDataType datatype = (ComplexDataType)dataFactory.createWsmlDataType(WsmlDataType.WSML_DATETIME);
123         //check if creation form java object works
124         Calendar javaValue = new GregorianCalendar(TimeZone.getTimeZone("CET"));
125         javaValue.set(1977,11,9,12,12,0);
126         javaValue.set(Calendar.MILLISECOND, 0);
127         DataValue datavalue1 = dataFactory.createDataValueFromJavaObject(datatype, javaValue);
128         
129         Calendar cal1 = (Calendar)datavalue1.getValue();
130         assertEquals(javaValue.get(Calendar.DAY_OF_YEAR), cal1.get(Calendar.DAY_OF_YEAR));
131         assertEquals(javaValue.get(Calendar.MINUTE), cal1.get(Calendar.MINUTE));
132         assertEquals(javaValue.get(Calendar.HOUR_OF_DAY), cal1.get(Calendar.HOUR_OF_DAY));
133         assertEquals(javaValue.get(Calendar.SECOND), cal1.get(Calendar.SECOND));
134 
135         //check if creation form wsml simple values works
136         DataValue datavalue2 = dataFactory.createDataValue(datatype, 
137                 new SimpleDataValue[] { 
138                         dataFactory.createWsmlInteger(new BigInteger(""+1977)),
139                         dataFactory.createWsmlInteger(new BigInteger(""+12)),
140                         dataFactory.createWsmlInteger(new BigInteger(""+9)),
141                         dataFactory.createWsmlInteger(new BigInteger(""+12)),
142                         dataFactory.createWsmlInteger(new BigInteger(""+12)),
143                         dataFactory.createWsmlDecimal(new BigDecimal(""+0.0)),
144                         dataFactory.createWsmlInteger(new BigInteger(""+60)),
145                         dataFactory.createWsmlInteger(new BigInteger(""+0))});
146         Calendar cal2 = (Calendar)datavalue1.getValue();
147         assertEquals(javaValue.get(Calendar.DAY_OF_YEAR), cal2.get(Calendar.DAY_OF_YEAR));
148         assertEquals(javaValue.get(Calendar.MINUTE), cal2.get(Calendar.MINUTE));
149         assertEquals(javaValue.get(Calendar.HOUR_OF_DAY), cal2.get(Calendar.HOUR_OF_DAY));
150         assertEquals(javaValue.get(Calendar.SECOND), cal2.get(Calendar.SECOND));
151 
152         //create and check a different value
153         DataValue datavalue3 = dataFactory.createDataValueFromJavaObject(datatype, 
154                 new GregorianCalendar(2003,1,1));
155         assertTrue(!datavalue2.equals(datavalue3));
156         
157         //check if values are identical
158         assertEquals(datavalue1, datavalue2);
159         
160         DataValue datavalue4 = dataFactory.createWsmlDateTime(1977,12,9,12,12,0.0F,60,0);
161         assertEquals(datavalue1, datavalue4);
162         
163     } 
164     
165     public void testDate(){
166         WsmlDataType datatype = dataFactory.createWsmlDataType(WsmlDataType.WSML_DATE);
167         //check if creation form java object works
168         Calendar javaValue = new GregorianCalendar(TimeZone.getTimeZone("GMT"));
169         javaValue.set(1977,11,9);
170         DataValue datavalue1 = dataFactory.createDataValueFromJavaObject(datatype, javaValue);
171         
172 //        System.out.println("javaValue: "+javaValue.getTime());
173 //        System.out.println("DataValue: "+((Calendar)datavalue1.getValue()).getTime());
174 //        for (int i=0;i<((ComplexDataValue)datavalue1).getArity();i++)
175 //            System.out.println(i+": "+((ComplexDataValue)datavalue1).getArgumentValue((byte)i));
176         
177         Calendar cal1 = (Calendar)datavalue1.getValue();
178         assertEquals(javaValue.get(Calendar.DAY_OF_YEAR), cal1.get(Calendar.DAY_OF_YEAR));
179 
180         //check if creation form wsml simple values works
181         DataValue datavalue2 = dataFactory.createDataValue((ComplexDataType)datatype, 
182                 new SimpleDataValue[] { 
183                         dataFactory.createWsmlInteger(new BigInteger(""+1977)),
184                         dataFactory.createWsmlInteger(new BigInteger(""+12)),
185                         dataFactory.createWsmlInteger(new BigInteger(""+9)),
186                         dataFactory.createWsmlInteger(new BigInteger(""+0)),
187                         dataFactory.createWsmlInteger(new BigInteger(""+0))});
188         assertEquals(((Calendar)datavalue2.getValue()).get(Calendar.DAY_OF_YEAR),
189                 ((Calendar)datavalue2.getValue()).get(Calendar.DAY_OF_YEAR));
190         //create and check a different value
191         DataValue datavalue3 = dataFactory.createDataValueFromJavaObject(datatype, 
192                 new GregorianCalendar(2003,1,1));
193         assertTrue(((Calendar)datavalue2.getValue()).get(Calendar.DAY_OF_YEAR) !=
194                 ((Calendar)datavalue3.getValue()).get(Calendar.DAY_OF_YEAR));
195         
196         //check if values are identical
197         assertEquals(datavalue1, datavalue2);
198         DataValue datavalue4 = dataFactory.createWsmlDate(1977,12,9,0,0);
199         assertEquals(datavalue1, datavalue4);    
200     } 
201     
202     public void testTime(){
203         WsmlDataType datatype = dataFactory.createWsmlDataType(WsmlDataType.WSML_TIME);
204         //check if creation form java object works
205         Calendar javaValue = new GregorianCalendar(TimeZone.getTimeZone("GMT"));
206         javaValue.set(1970,1,1,12,12,00);
207         DataValue datavalue1 = dataFactory.createDataValueFromJavaObject(datatype, javaValue);
208         
209 //        System.out.println("javaValue: "+javaValue.getTime());
210 //        System.out.println("DataValue: "+((Calendar)datavalue1.getValue()).getTime());
211 //        for (int i=0;i<((ComplexDataValue)datavalue1).getArity();i++)
212 //            System.out.println(i+": "+((ComplexDataValue)datavalue1).getArgumentValue((byte)i));
213 //        System.out.println("HOUR"+javaValue.get(Calendar.HOUR_OF_DAY)+"-"+ 
214 //                ((Calendar)datavalue1.getValue()).get(Calendar.HOUR_OF_DAY));
215         
216         assertEquals(javaValue.get(Calendar.HOUR_OF_DAY), 
217                 ((Calendar)datavalue1.getValue()).get(Calendar.HOUR_OF_DAY));
218         assertEquals(javaValue.get(Calendar.MINUTE), 
219                 ((Calendar)datavalue1.getValue()).get(Calendar.MINUTE));
220         assertEquals(javaValue.get(Calendar.SECOND), 
221                 ((Calendar)datavalue1.getValue()).get(Calendar.SECOND));
222 
223         //check if creation form wsml simple values works
224         DataValue datavalue2 = dataFactory.createDataValue((ComplexDataType)datatype, 
225                 new SimpleDataValue[] { 
226                         dataFactory.createWsmlInteger(new BigInteger(""+12)),
227                         dataFactory.createWsmlInteger(new BigInteger(""+12)),
228                         dataFactory.createWsmlDecimal(new BigDecimal(""+0)),
229                         dataFactory.createWsmlInteger(new BigInteger(""+60)),
230                         dataFactory.createWsmlInteger(new BigInteger(""+0))});
231         assertEquals(javaValue.get(Calendar.HOUR_OF_DAY), 
232                 ((Calendar)datavalue2.getValue()).get(Calendar.HOUR_OF_DAY));
233         assertEquals(javaValue.get(Calendar.MINUTE), 
234                 ((Calendar)datavalue2.getValue()).get(Calendar.MINUTE));
235         assertEquals(javaValue.get(Calendar.SECOND), 
236                 ((Calendar)datavalue2.getValue()).get(Calendar.SECOND));
237 
238         //create and check a different value
239         DataValue datavalue3 = dataFactory.createDataValueFromJavaObject(datatype, 
240                 new GregorianCalendar(2003,1,1,1,1,1));
241         assertTrue(((Calendar)datavalue2.getValue()).get(Calendar.HOUR_OF_DAY) !=
242                 ((Calendar)datavalue3.getValue()).get(Calendar.HOUR_OF_DAY));
243         assertTrue(((Calendar)datavalue2.getValue()).get(Calendar.MINUTE) !=
244             ((Calendar)datavalue3.getValue()).get(Calendar.MINUTE));
245         assertTrue(((Calendar)datavalue2.getValue()).get(Calendar.SECOND) !=
246             ((Calendar)datavalue3.getValue()).get(Calendar.SECOND));
247         
248         
249         DataValue datavalue4 = dataFactory.createWsmlTime(12,12,0,60,0);
250         assertEquals(datavalue2, datavalue4);    
251 
252     } 
253 
254     public void testBoolean(){
255         ComplexDataType datatype = (ComplexDataType)dataFactory.createWsmlDataType(WsmlDataType.WSML_BOOLEAN);
256         //check if creation form java object works
257         Object javaValue = new Boolean("true");
258         DataValue datavalue1 = dataFactory.createDataValueFromJavaObject(datatype, javaValue);
259         assertEquals(datavalue1.getValue(),javaValue);
260         //check if creation form wsml simple values works
261         DataValue datavalue2 = dataFactory.createDataValue(datatype, 
262                 dataFactory.createWsmlString("true"));
263         assertEquals(datavalue2.getValue(),javaValue);
264         //create and check a different value
265         DataValue datavalue3 = dataFactory.createDataValue(datatype, 
266                 dataFactory.createWsmlString("false"));
267         assertEquals(datavalue2.getValue(),javaValue);        
268         //check if float create by SimpleType or JavaObject are identical
269         assertEquals(datavalue1, datavalue2);
270         assertTrue(!datavalue2.equals(datavalue3));
271         
272         DataValue datavalue4 = dataFactory.createWsmlBoolean("true");
273         assertEquals(datavalue2, datavalue4);    
274 
275         DataValue datavalue5 = dataFactory.createWsmlBoolean(new Boolean("true"));
276         assertEquals(datavalue2, datavalue5);    
277     } 
278     
279     public void testGYear(){
280         ComplexDataType datatype = (ComplexDataType)dataFactory.createWsmlDataType(WsmlDataType.WSML_GYEAR);
281         //check if creation form java object works
282         Integer javaValue = new Integer("2005");
283         DataValue datavalue1 = dataFactory.createDataValueFromJavaObject(datatype, javaValue);
284         assertEquals(datavalue1.getValue(),javaValue);
285         //check if creation form wsml simple values works
286         DataValue datavalue2 = dataFactory.createDataValue(datatype, 
287                 dataFactory.createWsmlInteger(new BigInteger(""+javaValue)));
288         assertEquals(datavalue2.getValue(),javaValue);
289         //create and check a different value
290         DataValue datavalue3 = dataFactory.createDataValue(datatype, 
291                 dataFactory.createWsmlInteger(new BigInteger("100")));
292         assertTrue(!datavalue2.equals(datavalue3));
293 
294         DataValue datavalue5 = dataFactory.createWsmlGregorianYear("2005");
295         assertEquals(datavalue2, datavalue5);    
296     }
297 }