1   /*
2    * Copyright 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.strategy;
18  
19  
20  import java.io.StringWriter;
21  
22  import org.apache.commons.betwixt.AbstractTestCase;
23  import org.apache.commons.betwixt.ElementDescriptor;
24  import org.apache.commons.betwixt.XMLBeanInfo;
25  import org.apache.commons.betwixt.io.BeanWriter;
26  
27  
28  /***
29   * Tests for mixed content encoding.
30   * Mixed content encoding is the process by which body content
31   * is written out (in an escaped form) into a textual output stream. 
32   * @author <a href='http://jakarta.apache.org/'>Apache Commons Team</a>
33   * @version $Revision: 1.3 $
34   */
35  public class TestMixedContentEncoding extends AbstractTestCase {
36  
37      /*** Concrete subclass used for testing */
38      static class TestBaseMixedContentEncoding extends BaseMixedContentEncodingStrategy {
39          boolean encode = false;
40          ElementDescriptor element = null;
41          
42          TestBaseMixedContentEncoding(boolean encode) {
43              this.encode = encode;
44          }
45          
46          protected boolean encodeAsCDATA(ElementDescriptor element) {
47              this.element = element;
48              return encode;
49          }
50      }
51      
52      public TestMixedContentEncoding(String testName) {
53          super(testName);
54      }
55      
56      public void testBaseMixedEscapeCharacters() {
57          BaseMixedContentEncodingStrategy mceStrategy = new TestBaseMixedContentEncoding(false);
58          assertEquals("Check basic escaping", "ab&lt;&gt;&amp;ba", mceStrategy.escapeCharacters("ab<>&ba"));
59      }
60      
61      public void testBaseMixedCDATAEncoding() {
62          BaseMixedContentEncodingStrategy mceStrategy = new TestBaseMixedContentEncoding(false);
63          assertEquals("Check basic escaping", "<![CDATA[<greeting>ab]]&gt;ba</greeting>]]>", mceStrategy.encodeInCDATA("<greeting>ab]]>ba</greeting>"));
64      }
65      
66      public void testBaseMixedEncode() {
67          ElementDescriptor descriptor = new ElementDescriptor();
68          TestBaseMixedContentEncoding mceStrategy = new TestBaseMixedContentEncoding(false);
69          assertEquals(
70                          "Using character escaping", 
71                          "&lt;exclaim&gt;hello, mum&lt;/exclaim&gt;", 
72                          mceStrategy.encode("<exclaim>hello, mum</exclaim>", descriptor));
73          
74          assertEquals("Descriptor set", descriptor, mceStrategy.element);
75          mceStrategy = new TestBaseMixedContentEncoding(true);
76          assertEquals(
77                          "Using CDATA encoding", 
78                          "<![CDATA[<exclaim>hello, mum</exclaim>]]>", 
79                          mceStrategy.encode("<exclaim>hello, mum</exclaim>", descriptor));
80          
81          assertEquals("Descriptor set", descriptor, mceStrategy.element);
82      }
83      
84      public void testDefaultImplementation() {
85          ElementDescriptor descriptor = new ElementDescriptor();
86          assertEquals(
87              "Default implementation uses character escaping",
88              "&lt;proclaim&gt;The King Is Dead, Long Live The King&lt;/proclaim&gt;",
89              MixedContentEncodingStrategy.DEFAULT.encode("<proclaim>The King Is Dead, Long Live The King</proclaim>", descriptor));
90      }
91      
92      public void testEscapedCharactersImplementation() {
93          ElementDescriptor descriptor = new ElementDescriptor();
94          assertEquals(
95              "Default implementation uses character escaping",
96              "&lt;proclaim&gt;The King Is Dead, Long Live The King&lt;/proclaim&gt;",
97              MixedContentEncodingStrategy.ESCAPED_CHARACTERS.encode("<proclaim>The King Is Dead, Long Live The King</proclaim>", descriptor));
98      }
99      
100     public void testCDATAImplementation() {
101         ElementDescriptor descriptor = new ElementDescriptor();
102         assertEquals(
103             "Default implementation uses character escaping",
104             "<![CDATA[<proclaim>The King Is Dead, Long Live The King</proclaim>]]>",
105             MixedContentEncodingStrategy.CDATA.encode("<proclaim>The King Is Dead, Long Live The King</proclaim>", descriptor));
106     }
107     
108     public void testDefaultOutput() throws Exception {
109         Element element = new Element();
110         element.setValue("<greeting>What Ho Jeeves!</greeting>");
111         
112         StringWriter out = new StringWriter();
113         out.write("<?xml version='1.0'?>");
114         BeanWriter writer = new BeanWriter(out);
115         writer.getXMLIntrospector().setAttributesForPrimitives(false);
116         writer.write(element);
117         
118         String expected = "<?xml version='1.0'?><Element>\n<value>&lt;greeting&gt;What Ho Jeeves!&lt;/greeting&gt;</value>\n</Element>\n";
119         String xml = out.getBuffer().toString();
120          
121         assertEquals(expected,xml); 
122                             
123     }
124     
125     /*** Unit test for default output when CDATA option is set */
126     public void testDefaultOutputWithCDATAOption() throws Exception {
127         Element element = new Element();
128         element.setValue("<greeting>What Ho Jeeves!</greeting>");
129         
130         StringWriter out = new StringWriter();
131         out.write("<?xml version='1.0'?>");
132         BeanWriter writer = new BeanWriter(out);
133         writer.getXMLIntrospector().setAttributesForPrimitives(false);
134         XMLBeanInfo elementInfo = writer.getXMLIntrospector().introspect(Element.class);
135         elementInfo.getElementDescriptor().getElementDescriptors()[0]
136             .getOptions().addOption(MixedContentEncodingStrategy.ENCODING_OPTION_NAME, "CDATA");  
137          
138         writer.write(element);
139         
140         String expected = "<?xml version='1.0'?><Element>\n<value><![CDATA[<greeting>What Ho Jeeves!</greeting>]]></value>\n</Element>\n";
141         String xml = out.getBuffer().toString();
142          
143         assertEquals(expected,xml); 
144                             
145     }
146     
147     /*** Unit test for default output when character escaping option is set */
148     public void testDefaultOutputWithCharacterEscapingOption() throws Exception {
149         Element element = new Element();
150         element.setValue("<greeting>What Ho Jeeves!</greeting>");
151         
152         StringWriter out = new StringWriter();
153         out.write("<?xml version='1.0'?>");
154         BeanWriter writer = new BeanWriter(out);
155         writer.getXMLIntrospector().setAttributesForPrimitives(false);
156         XMLBeanInfo elementInfo = writer.getXMLIntrospector().introspect(Element.class);
157         elementInfo.getElementDescriptor().getElementDescriptors()[0]
158             .getOptions().addOption("org.apache.commons.betwixt.mixed-content-encoding", "escaped");
159         writer.write(element);
160         
161         String expected = "<?xml version='1.0'?><Element>\n<value>&lt;greeting&gt;What Ho Jeeves!&lt;/greeting&gt;</value>\n</Element>\n";
162         String xml = out.getBuffer().toString();
163          
164         assertEquals(expected,xml); 
165     }
166     
167     public void testDefaultOutputWithDotBetwixtOptions() throws Exception {
168         ABCBean bean = new ABCBean();
169         bean.setA("<strong>weak</strong>");
170         bean.setB("<strong>weak</strong>");
171         bean.setC("<strong>weak</strong>");
172         
173         StringWriter out = new StringWriter();
174         out.write("<?xml version='1.0'?>");
175         BeanWriter writer = new BeanWriter(out);
176         writer.getXMLIntrospector().setAttributesForPrimitives(false);
177         writer.write(bean);
178         
179         String expected = "<?xml version='1.0'?>" +
180             "<greek-abc>\n" +
181             "<alpha><![CDATA[<strong>weak</strong>]]></alpha>\n" +
182             "<beta>&lt;strong&gt;weak&lt;/strong&gt;</beta>\n" +
183             "<gamma>&lt;strong&gt;weak&lt;/strong&gt;</gamma>\n" +
184             "</greek-abc>\n";
185         String xml = out.getBuffer().toString();
186          
187         assertEquals(expected,xml); 
188     }
189     
190     public void testEscapedOutput() throws Exception {
191         Element element = new Element();
192         element.setValue("<greeting>What Ho Jeeves!</greeting>");
193         
194         StringWriter out = new StringWriter();
195         out.write("<?xml version='1.0'?>");
196         BeanWriter writer = new BeanWriter(out);
197         writer.getXMLIntrospector().setAttributesForPrimitives(false);
198         writer.setMixedContentEncodingStrategy(new TestBaseMixedContentEncoding(false));
199         writer.write(element);
200         
201         String expected = "<?xml version='1.0'?><Element>\n<value>&lt;greeting&gt;What Ho Jeeves!&lt;/greeting&gt;</value>\n</Element>\n";
202         String xml = out.getBuffer().toString();
203          
204         assertEquals(expected,xml); 
205                             
206     }
207     
208     public void testCDATAEncodedOutput() throws Exception {
209         Element element = new Element();
210         element.setValue("<greeting>What Ho Jeeves!</greeting>");
211         
212         StringWriter out = new StringWriter();
213         out.write("<?xml version='1.0'?>");
214         BeanWriter writer = new BeanWriter(out);
215         writer.getXMLIntrospector().setAttributesForPrimitives(false);
216         writer.setMixedContentEncodingStrategy(new TestBaseMixedContentEncoding(true));
217         writer.write(element);
218         
219         String expected = "<?xml version='1.0'?><Element>\n<value><![CDATA[<greeting>What Ho Jeeves!</greeting>]]></value>\n</Element>\n";
220         String xml = out.getBuffer().toString();
221          
222         assertEquals(expected,xml);      
223     }
224 }