001/*
002 * Copyright (c) 2004-2012, Willem Cazander
003 * All rights reserved.
004 *
005 * Redistribution and use in source and binary forms, with or without modification, are permitted provided
006 * that the following conditions are met:
007 * 
008 * * Redistributions of source code must retain the above copyright notice, this list of conditions and the
009 *   following disclaimer.
010 * * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
011 *   the following disclaimer in the documentation and/or other materials provided with the distribution.
012 * 
013 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
014 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
015 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
016 * THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
017 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
018 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
019 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
020 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
021 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
022 */
023
024package org.x4o.xml.conv;
025
026import java.net.MalformedURLException;
027import java.net.URL;
028import java.util.Locale;
029
030import org.x4o.xml.conv.text.ClassConverter;
031import org.x4o.xml.conv.text.EnumConverter;
032import org.x4o.xml.conv.text.URLConverter;
033import org.x4o.xml.core.X4OPhase;
034
035import junit.framework.TestCase;
036
037/**
038 * DefaultObjectConverterProviderTest test some basic converters.
039 * 
040 * @author Willem Cazander
041 * @version 1.0 Jul 24, 2006
042 */
043public class DefaultObjectConverterProviderTest extends TestCase {
044        
045        Locale locale = Locale.getDefault();
046
047        public void testConverterClone() throws Exception {
048                DefaultObjectConverterProvider p = new DefaultObjectConverterProvider(true);
049                for (ObjectConverter conv:p.getObjectConverters()) {
050                        assertNotNull(conv);
051                        ObjectConverter clone = conv.clone();
052                        assertNotNull(clone);
053                }
054        }
055        
056        public void testConverterBoolean() throws Exception {
057                DefaultObjectConverterProvider p = new DefaultObjectConverterProvider(true);
058                ObjectConverter conv = p.getObjectConverterForClass(Boolean.class);
059                assertNotNull(conv);
060                Object result = conv.convertTo("true", locale);
061                assertNotNull(result);
062                assertEquals("Result is not Boolean.class", Boolean.class,result.getClass());
063                assertEquals("Result is not true", true,result);
064                Object resultBack = conv.convertBack(result, locale);
065                assertNotNull(resultBack);
066                assertEquals("resultBack is not String.class", String.class,resultBack.getClass());
067                assertEquals("resultBack is not true", "true",resultBack);
068        }
069        
070        public void testConverterInteger() throws Exception {
071                DefaultObjectConverterProvider p = new DefaultObjectConverterProvider(true);
072                ObjectConverter conv = p.getObjectConverterForClass(Integer.class);
073                assertNotNull(conv);
074                Object result = conv.convertTo("123", locale);
075                assertNotNull(result);
076                assertEquals("Result is not Integer.class", Integer.class,result.getClass());
077                assertEquals("Result is not 123", 123,result);
078                Object resultBack = conv.convertBack(result, locale);
079                assertNotNull(resultBack);
080                assertEquals("resultBack is not String.class", String.class,resultBack.getClass());
081                assertEquals("resultBack is not 123", "123",resultBack);
082        }
083        
084        public void testConverterFloat() throws Exception {
085                DefaultObjectConverterProvider p = new DefaultObjectConverterProvider(true);
086                ObjectConverter conv = p.getObjectConverterForClass(Float.class);
087                assertNotNull(conv);
088                Object result = conv.convertTo("123.23", locale);
089                assertNotNull(result);
090                assertEquals("Result is not Float.class", Float.class,result.getClass());
091                assertEquals("Result is not 123.23", 123.23F,result);
092                Object resultBack = conv.convertBack(result, locale);
093                assertNotNull(resultBack);
094                assertEquals("resultBack is not String.class", String.class,resultBack.getClass());
095                assertEquals("resultBack is not 123.23", "123.23",resultBack);
096        }
097        
098        public void testConverterLong() throws Exception {
099                DefaultObjectConverterProvider p = new DefaultObjectConverterProvider(true);
100                ObjectConverter conv = p.getObjectConverterForClass(Long.class);
101                assertNotNull(conv);
102                Object result = conv.convertTo("12323", locale);
103                assertNotNull(result);
104                assertEquals("Result is not Long.class", Long.class,result.getClass());
105                assertEquals("Result is not 12323", 12323L,result);
106                Object resultBack = conv.convertBack(result, locale);
107                assertNotNull(resultBack);
108                assertEquals("resultBack is not String.class", String.class,resultBack.getClass());
109                assertEquals("resultBack is not 12323", "12323",resultBack);
110        }
111        
112        public void testConverterDouble() throws Exception {
113                DefaultObjectConverterProvider p = new DefaultObjectConverterProvider(true);
114                ObjectConverter conv = p.getObjectConverterForClass(Double.class);
115                assertNotNull(conv);
116                Object result = conv.convertTo("1232.3", locale);
117                assertNotNull(result);
118                assertEquals("Result is not Double.class", Double.class,result.getClass());
119                assertEquals("Result is not 1232.3", 1232.3D,result);
120                Object resultBack = conv.convertBack(result, locale);
121                assertNotNull(resultBack);
122                assertEquals("resultBack is not String.class", String.class,resultBack.getClass());
123                assertEquals("resultBack is not 1232.3", "1232.3",resultBack);
124        }
125        
126        public void testConverterUrl() throws Exception {
127                DefaultObjectConverterProvider p = new DefaultObjectConverterProvider(true);
128                ObjectConverter conv = p.getObjectConverterForClass(URL.class);
129                assertNotNull(conv);
130                Object result = conv.convertTo("http://www.x4o.org", locale);
131                assertNotNull(result);
132                assertEquals("Result is not Url.class", URL.class,result.getClass());
133                assertEquals("Result is not http://www.x4o.org", new URL("http://www.x4o.org"),result);
134                Object resultBack = conv.convertBack(result, locale);
135                assertNotNull(resultBack);
136                assertEquals("resultBack is not String.class", String.class,resultBack.getClass());
137                assertEquals("resultBack is not http://www.x4o.org", "http://www.x4o.org",resultBack);
138        }
139        
140        public void testConverterUrlException() throws Exception {
141                URLConverter conv = new URLConverter();
142                Exception e = null;
143                try {
144                        conv.convertStringTo("error2::s/sdf//sd!@#$%#", locale);
145                } catch (Exception catchE) {
146                        e = catchE;
147                }
148                assertNotNull(e);
149                assertNotNull(e.getCause());
150                assertEquals(ObjectConverterException.class, e.getClass());
151                assertEquals(MalformedURLException.class, e.getCause().getClass());
152                assertTrue("Error message string is missing error",e.getMessage().contains("error"));
153        }
154        
155        
156        public void testConverterEnum() throws Exception {
157                EnumConverter convOrg = new EnumConverter();
158                convOrg.setEnumClass(X4OPhase.class.getName());
159                ObjectConverter conv = convOrg.clone();
160                Object result = conv.convertTo("runAttributesPhase", locale);
161                assertNotNull(result);
162                assertEquals("runAttributesPhase", result.toString());
163                Object resultBack = conv.convertBack(result, locale);
164                assertEquals("runAttributesPhase", resultBack.toString());
165        }
166        
167        public void testConverterEnumError() throws Exception {
168                EnumConverter convOrg = new EnumConverter();
169                convOrg.setEnumClass(X4OPhase.class.getName());
170                ObjectConverter conv = convOrg.clone();
171                
172                Exception e = null;
173                try {
174                         conv.convertTo("nonEnumError", locale);
175                } catch (Exception catchE) {
176                        e = catchE;
177                }
178                assertNotNull(e);
179                assertEquals(ObjectConverterException.class, e.getClass());
180                assertTrue(e.getMessage().contains("EnumError"));
181        }
182        
183        public void testConverterEnumNullError() throws Exception {
184                EnumConverter conv = new EnumConverter();
185                Exception e = null;
186                try {
187                         conv.convertTo("nonEnumError", locale);
188                } catch (Exception catchE) {
189                        e = catchE;
190                }
191                assertNotNull(e);
192                assertEquals(ObjectConverterException.class, e.getClass());
193                assertTrue(e.getMessage().contains("enumClass"));
194        }
195        
196        public void testConverterClass() throws Exception {
197                ClassConverter classOrg = new ClassConverter();
198                ObjectConverter conv = classOrg.clone();
199                Object result = conv.convertTo("java.lang.Object", locale);
200                assertNotNull(result);
201                assertEquals(Object.class, result);
202                Object resultBack = conv.convertBack(result, locale);
203                assertEquals("java.lang.Object", resultBack.toString());
204        }
205        
206        public void testConverterClassError() throws Exception {
207                ClassConverter classOrg = new ClassConverter();
208                ObjectConverter conv = classOrg.clone();
209                
210                Exception e = null;
211                try {
212                        conv.convertTo("java.lang.ObjectError", locale);
213                } catch (Exception catchE) {
214                        e = catchE;
215                }
216                assertNotNull(e);
217                assertEquals(ObjectConverterException.class, e.getClass());
218                assertTrue(e.getMessage().contains("ObjectError"));
219        }
220}