1   /*
2    * Copyright 2001-2004 The Apache Software Foundation.
3    * 
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    * 
8    *      http://www.apache.org/licenses/LICENSE-2.0
9    * 
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   */ 
16   
17  package org.apache.commons.betwixt.schema;
18  
19  import java.io.StringReader;
20  import java.io.StringWriter;
21  import java.io.Writer;
22  
23  import junit.framework.Test;
24  import junit.framework.TestSuite;
25  
26  import org.apache.commons.betwixt.AbstractTestCase;
27  import org.apache.commons.betwixt.XMLIntrospector;
28  import org.apache.commons.betwixt.io.BeanReader;
29  import org.apache.commons.betwixt.io.BeanWriter;
30  import org.apache.commons.betwixt.registry.DefaultXMLBeanInfoRegistry;
31  import org.apache.commons.betwixt.strategy.DecapitalizeNameMapper;
32  import org.apache.commons.betwixt.strategy.HyphenatedNameMapper;
33  
34  //import org.apache.commons.logging.impl.SimpleLog;
35  //import org.apache.commons.betwixt.io.BeanRuleSet;
36  
37  /***
38   * This will test betwixt on handling a different kind of xml file, without
39   * a "collection" tag.
40   * 
41   * @author <a href="mailto:martin@mvdb.net">Martin van den Bemt</a>
42   * @version $Id: TestSchema.java,v 1.11 2004/06/13 21:32:48 rdonkin Exp $
43   */
44  public class TestSchema extends AbstractTestCase
45  {
46      
47      public static Test suite()
48      {
49          return new TestSuite(TestSchema.class);
50      }
51  
52      
53      public TestSchema(String testName)
54      {
55          super(testName);
56      }
57      
58      /***
59       * Test the roundtrip with an xml file that doesn't have
60       * collection elements, writes it with collection elements
61       * and then compares the 2 object, which should end up
62       * equal..
63       */
64      public void testCombinedRoundTrip()
65      throws Exception
66      {	
67  //        SimpleLog log = new SimpleLog("[CombinedRoundTrip:BeanRuleSet]");
68  //        log.setLevel(SimpleLog.LOG_LEVEL_TRACE);
69  //        BeanRuleSet.setLog(log);
70          
71  //        log = new SimpleLog("[CombinedRoundTrip]");
72  //        log.setLevel(SimpleLog.LOG_LEVEL_TRACE);
73          
74          BeanReader reader = createBeanReader();
75          
76          PhysicalSchema schema = (PhysicalSchema) reader.parse(
77              getTestFileURL("src/test/org/apache/commons/betwixt/schema/schema.xml"));
78          StringWriter buffer = new StringWriter();
79          write(schema, buffer, true);
80          
81  //        log.debug(buffer.getBuffer().toString());
82          
83          StringReader in = new StringReader(buffer.getBuffer().toString());
84          reader = createBeanReader();
85          XMLIntrospector intro = createXMLIntrospector();
86          DefaultXMLBeanInfoRegistry registry = new DefaultXMLBeanInfoRegistry();
87          intro.setRegistry(registry);
88          // we have written the xml file back with element collections,
89          // so we have to say to the reader we want to use that now
90          // (the default when creating in this test is not to use them)
91          intro.getConfiguration().setWrapCollectionsInElement(true);
92          // first flush the cash, else setting other options, doesn't
93          // end up in rereading / mapping the object model.
94          registry.flush();
95          // set the xmlIntrospector back to the reader
96          reader.setXMLIntrospector(intro);
97          reader.deregisterBeanClass(PhysicalSchema.class);
98          reader.getRules().clear();
99          reader.registerBeanClass(PhysicalSchema.class);
100         PhysicalSchema schemaSecond = (PhysicalSchema) reader.parse(in);
101         buffer.close();
102         write(schema,buffer, true);
103         assertEquals(schema, schemaSecond);
104     }
105     /***
106      * Tests we can round trip from the XML -> bean -> XML -> bean.
107      * It will test if both object are identical.
108      * For this to actually work I implemented a details equals in my
109      * Beans..
110      */
111     public void testRoundTripWithoutCollectionElement()
112     throws Exception
113     {
114         BeanReader reader = createBeanReader();
115         PhysicalSchema schema = (PhysicalSchema) reader.parse(
116             getTestFileURL("src/test/org/apache/commons/betwixt/schema/schema.xml"));
117         StringWriter buffer = new StringWriter();
118         write(schema, buffer, false);
119         StringReader in = new StringReader(buffer.getBuffer().toString());
120         PhysicalSchema schemaSecond = (PhysicalSchema) reader.parse(in);
121         assertEquals(schemaSecond, schema);
122     }
123     
124     /***
125      * Creates a beanReader
126      */
127     protected BeanReader createBeanReader()
128     throws Exception
129      {
130         BeanReader reader = new BeanReader();
131         reader.setXMLIntrospector(createXMLIntrospector());
132         // register the class which maps to the root element
133         // of the xml file (this depends on the NameMapper used.
134         reader.registerBeanClass(PhysicalSchema.class);
135         return reader;
136     } 
137     
138     /***
139      * Set up the XMLIntroSpector
140      */
141     protected XMLIntrospector createXMLIntrospector() {
142         XMLIntrospector introspector = new XMLIntrospector();
143 
144         // set elements for attributes to true
145         introspector.getConfiguration().setAttributesForPrimitives(true);
146 
147         // Since we don't want to have collectionelements 
148         // line <DBMSS>, we have to set this to false,
149         // since the default is true.
150         introspector.getConfiguration().setWrapCollectionsInElement(false);
151 
152         // We have to use the HyphenatedNameMapper
153         // Since we want the names to resolve from eg PhysicalSchema
154         // to PHYSICAL_SCHEMA.
155         // we pass to the mapper we want uppercase and use _ for name
156         // seperation.
157         // This will set our ElementMapper.
158         introspector.getConfiguration().setElementNameMapper(new HyphenatedNameMapper(true, "_"));
159         // since our attribute names will use a different 
160         // naming convention in our xml file (just all lowercase)
161         // we set another mapper for the attributes
162         introspector.getConfiguration().setAttributeNameMapper(new DecapitalizeNameMapper());
163 
164         return introspector;
165     }
166     
167     /***
168      * Opens a writer and writes an object model according to the
169      * retrieved bean
170      */
171     private void write(Object bean, Writer out, boolean wrapCollectionsInElement)
172     throws Exception
173     {
174         BeanWriter writer = new BeanWriter(out);
175         writer.setWriteEmptyElements( true );
176         writer.setXMLIntrospector(createXMLIntrospector());
177         // specifies weather to use collection elements or not.
178         writer.getXMLIntrospector().getConfiguration().setWrapCollectionsInElement(wrapCollectionsInElement);
179         // we don't want to write Id attributes to every element
180         // we just want our opbject model written nothing more..
181         writer.getBindingConfiguration().setMapIDs(false);
182         // the source has 2 spaces indention and \n as line seperator.
183         writer.setIndent("  ");
184         writer.setEndOfLine("\n");
185         writer.write(bean);
186     }
187 }
188