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 }