1   package org.codehaus.metaclass.io;
2   
3   import java.util.Properties;
4   
5   import junit.framework.TestCase;
6   import org.xml.sax.ContentHandler;
7   import org.xml.sax.helpers.AttributesImpl;
8   import org.codehaus.metaclass.model.Attribute;
9   import org.codehaus.metaclass.model.ParameterDescriptor;
10  import org.codehaus.metaclass.model.MethodDescriptor;
11  import org.codehaus.metaclass.model.FieldDescriptor;
12  import org.codehaus.metaclass.model.ClassDescriptor;
13  import org.jmock.Mock;
14  import org.jmock.C;
15  import org.jmock.InvocationMatcher;
16  import org.jmock.Constraint;
17  import org.jmock.matcher.ArgumentsMatcher;
18  
19  public class SAXMetaClassSerializerTestCase
20      extends TestCase
21  {
22      public void testSerializeText()
23          throws Exception
24      {
25          final Mock mockHandler = new Mock( ContentHandler.class );
26  
27          final String text = "blah";
28          mockHandler.expect( "characters", C.args( C.IS_ANYTHING, C.eq( 0 ), C.eq( text.length() ) ) );
29  
30          final ContentHandler handler = (ContentHandler)mockHandler.proxy();
31          final SAXMetaClassSerializer serializer = new SAXMetaClassSerializer();
32          serializer.text( handler, text );
33          mockHandler.verify();
34      }
35  
36      public void testSerializeAttributeParams()
37          throws Exception
38      {
39          final String name = "X";
40          final String value = "Y";
41  
42          final Mock mockHandler = new Mock( ContentHandler.class );
43  
44          final AttributesImpl attrs = new AttributesImpl();
45          add( attrs, MetaClassIOXml.NAME_ATTRIBUTE, name );
46          add( attrs, MetaClassIOXml.VALUE_ATTRIBUTE, value );
47          start( mockHandler, MetaClassIOXml.PARAM_ELEMENT, attrs );
48          end( mockHandler, MetaClassIOXml.PARAM_ELEMENT );
49  
50          final ContentHandler handler = (ContentHandler)mockHandler.proxy();
51  
52          final SAXMetaClassSerializer serializer = new SAXMetaClassSerializer();
53  
54          final Properties parameters = new Properties();
55          parameters.put( name, value );
56          final Attribute attribute = new Attribute( "ignored", parameters );
57          serializer.serializeAttributeParams( handler, attribute );
58  
59          mockHandler.verify();
60      }
61  
62      public void testSerializeAttributes()
63          throws Exception
64      {
65          final Mock mockHandler = new Mock( ContentHandler.class );
66  
67          start( mockHandler, MetaClassIOXml.ATTRIBUTES_ELEMENT, new AttributesImpl() );
68          final String attributeName = "blah";
69  
70          final AttributesImpl attributeAttrs = new AttributesImpl();
71          add( attributeAttrs, MetaClassIOXml.NAME_ATTRIBUTE, attributeName );
72  
73          start( mockHandler, MetaClassIOXml.ATTRIBUTE_ELEMENT, attributeAttrs );
74          end( mockHandler, MetaClassIOXml.ATTRIBUTE_ELEMENT );
75          end( mockHandler, MetaClassIOXml.ATTRIBUTES_ELEMENT );
76  
77          final ContentHandler handler = (ContentHandler)mockHandler.proxy();
78  
79          final SAXMetaClassSerializer serializer = new SAXMetaClassSerializer();
80  
81          final Attribute attribute = new Attribute( attributeName );
82          serializer.serializeAttributes( handler, new Attribute[]{attribute} );
83  
84          mockHandler.verify();
85      }
86  
87      public void testSerializeMethodParameters()
88          throws Exception
89      {
90          final String name = "X";
91          final String value = "Y";
92  
93          final Mock mockHandler = new Mock( ContentHandler.class );
94  
95          final AttributesImpl attrs = new AttributesImpl();
96          add( attrs, MetaClassIOXml.NAME_ATTRIBUTE, name );
97          add( attrs, MetaClassIOXml.TYPE_ATTRIBUTE, value );
98          start( mockHandler, MetaClassIOXml.PARAMETERS_ELEMENT, new AttributesImpl() );
99          start( mockHandler, MetaClassIOXml.PARAMETER_ELEMENT, attrs );
100         end( mockHandler, MetaClassIOXml.PARAMETER_ELEMENT );
101         end( mockHandler, MetaClassIOXml.PARAMETERS_ELEMENT );
102 
103         final ContentHandler handler = (ContentHandler)mockHandler.proxy();
104 
105         final SAXMetaClassSerializer serializer = new SAXMetaClassSerializer();
106 
107         final ParameterDescriptor[] parameters = new ParameterDescriptor[]
108         {
109             new ParameterDescriptor( name, value )
110         };
111         serializer.serializeParameters( handler, parameters );
112 
113         mockHandler.verify();
114     }
115 
116     public void testSerializeMethods()
117         throws Exception
118     {
119         final String name = "X";
120         final String type = "Y";
121 
122         final Mock mockHandler = new Mock( ContentHandler.class );
123 
124         start( mockHandler, MetaClassIOXml.METHODS_ELEMENT, new AttributesImpl() );
125         final AttributesImpl attrs = new AttributesImpl();
126         add( attrs, MetaClassIOXml.NAME_ATTRIBUTE, name );
127         add( attrs, MetaClassIOXml.TYPE_ATTRIBUTE, type );
128         start( mockHandler, MetaClassIOXml.METHOD_ELEMENT, attrs );
129         end( mockHandler, MetaClassIOXml.METHOD_ELEMENT );
130         end( mockHandler, MetaClassIOXml.METHODS_ELEMENT );
131 
132         final ContentHandler handler = (ContentHandler)mockHandler.proxy();
133 
134         final SAXMetaClassSerializer serializer = new SAXMetaClassSerializer();
135         final MethodDescriptor[] methods = new MethodDescriptor[]
136         {
137             new MethodDescriptor( name,
138                                   type,
139                                   ParameterDescriptor.EMPTY_SET,
140                                   Attribute.EMPTY_SET,
141                                   Attribute.EMPTY_SET )
142         };
143         serializer.serializeMethods( handler, methods );
144 
145         mockHandler.verify();
146     }
147 
148     public void testSerializeFields()
149         throws Exception
150     {
151         final String name = "X";
152         final String type = "Y";
153 
154         final Mock mockHandler = new Mock( ContentHandler.class );
155 
156         start( mockHandler, MetaClassIOXml.FIELDS_ELEMENT, new AttributesImpl() );
157         final AttributesImpl attrs = new AttributesImpl();
158         add( attrs, MetaClassIOXml.NAME_ATTRIBUTE, name );
159         add( attrs, MetaClassIOXml.TYPE_ATTRIBUTE, type );
160         start( mockHandler, MetaClassIOXml.FIELD_ELEMENT, attrs );
161         end( mockHandler, MetaClassIOXml.FIELD_ELEMENT );
162         end( mockHandler, MetaClassIOXml.FIELDS_ELEMENT );
163 
164         final ContentHandler handler = (ContentHandler)mockHandler.proxy();
165 
166         final SAXMetaClassSerializer serializer = new SAXMetaClassSerializer();
167         final FieldDescriptor[] fields = new FieldDescriptor[]
168         {
169             new FieldDescriptor( name, type, Attribute.EMPTY_SET, Attribute.EMPTY_SET )
170         };
171         serializer.serializeFields( handler, fields );
172 
173         mockHandler.verify();
174     }
175 
176     public void testSerializeClass()
177         throws Exception
178     {
179         final String type = "Y";
180 
181         final Mock mockHandler = new Mock( ContentHandler.class );
182 
183         final AttributesImpl attrs = new AttributesImpl();
184         add( attrs, MetaClassIOXml.TYPE_ATTRIBUTE, type );
185         add( attrs, MetaClassIOXml.VERSION_ATTRIBUTE, MetaClassIOXml.VERSION );
186         start( mockHandler, MetaClassIOXml.CLASS_ELEMENT, attrs );
187         end( mockHandler, MetaClassIOXml.CLASS_ELEMENT );
188 
189         final ContentHandler handler = (ContentHandler)mockHandler.proxy();
190 
191         final SAXMetaClassSerializer serializer = new SAXMetaClassSerializer();
192         final ClassDescriptor descriptor =
193             new ClassDescriptor( type,
194                                  Attribute.EMPTY_SET,
195                                  Attribute.EMPTY_SET,
196                                  FieldDescriptor.EMPTY_SET,
197                                  MethodDescriptor.EMPTY_SET );
198         serializer.serializeClass( handler, descriptor );
199 
200         mockHandler.verify();
201     }
202 
203     public void testSerializeClassAsDocument()
204         throws Exception
205     {
206         final String type = "Y";
207 
208         final Mock mockHandler = new Mock( ContentHandler.class );
209 
210         final AttributesImpl attrs = new AttributesImpl();
211         add( attrs, MetaClassIOXml.TYPE_ATTRIBUTE, type );
212         add( attrs, MetaClassIOXml.VERSION_ATTRIBUTE, MetaClassIOXml.VERSION );
213         mockHandler.expect( "startDocument", C.NO_ARGS );
214         start( mockHandler, MetaClassIOXml.CLASS_ELEMENT, attrs );
215         end( mockHandler, MetaClassIOXml.CLASS_ELEMENT );
216         mockHandler.expect( "endDocument", C.NO_ARGS );
217 
218         final ContentHandler handler = (ContentHandler)mockHandler.proxy();
219 
220         final SAXMetaClassSerializer serializer = new SAXMetaClassSerializer();
221         final ClassDescriptor descriptor =
222             new ClassDescriptor( type,
223                                  Attribute.EMPTY_SET,
224                                  Attribute.EMPTY_SET,
225                                  FieldDescriptor.EMPTY_SET,
226                                  MethodDescriptor.EMPTY_SET );
227         serializer.serialize( handler, descriptor );
228 
229         mockHandler.verify();
230     }
231 
232     private void end( final Mock mockHandler, final String name )
233     {
234         mockHandler.expect( "endElement", END( name ) );
235     }
236 
237     private void start( final Mock mockHandler,
238                         final String name,
239                         final AttributesImpl attrs )
240     {
241         mockHandler.expect( "startElement", ST( name, attrs ) );
242     }
243 
244     private static InvocationMatcher END( final String name )
245     {
246         final Constraint[] constraints = new Constraint[]
247         {
248             C.eq( "" ), C.eq( name ), C.eq( name )
249         };
250         return new ArgumentsMatcher( constraints );
251     }
252 
253     private static InvocationMatcher ST( final String name,
254                                          final AttributesImpl attr )
255     {
256         final Constraint[] constraints = new Constraint[]
257         {
258             C.eq( "" ), C.eq( name ), C.eq( name ), AT( attr )
259         };
260         return new ArgumentsMatcher( constraints );
261     }
262 
263     private static Constraint AT( final AttributesImpl attr )
264     {
265         return new EqAttributesConstraint( attr );
266     }
267 
268     private void add( final AttributesImpl atts,
269                       final String name,
270                       final String value )
271     {
272         atts.addAttribute( "", name, name, "CDATA", value );
273     }
274 }