KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > presumo > jms > message > MessageTests


1 /**
2  * This file is part of Presumo.
3  *
4  * Presumo is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation; either version 2 of the License, or
7  * (at your option) any later version.
8  *
9  * Presumo is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with Presumo; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17  *
18  *
19  * Copyright 2001 Dan Greff
20  */

21 package com.presumo.jms.message;
22
23 import java.io.ByteArrayInputStream JavaDoc;
24 import java.io.ByteArrayOutputStream JavaDoc;
25 import java.io.DataInputStream JavaDoc;
26 import java.io.DataOutputStream JavaDoc;
27 import java.io.Externalizable JavaDoc;
28 import java.io.ObjectOutputStream JavaDoc;
29 import java.io.ObjectInputStream JavaDoc;
30 import java.lang.reflect.Constructor JavaDoc;
31
32 import junit.framework.Test;
33 import junit.framework.TestCase;
34 import junit.framework.TestSuite;
35
36 /**
37  * Unit Tests for the implementations of JMS' message types
38  *
39  * @author Dan Greff
40  */

41 public class MessageTests extends TestCase
42 {
43   private static final boolean VERBOSE = true;
44   
45   public MessageTests(String JavaDoc name)
46   {
47     super(name);
48   }
49  
50   public static Test suite()
51   {
52     TestSuite suite = new TestSuite(MessageTests.class);
53     return suite;
54   }
55
56     /////////////////////////////////////////////////////////////////////////
57
// Tests cases //
58
/////////////////////////////////////////////////////////////////////////
59
/**
60    * UnitTest for PrimitiveMap
61    */

62   public void testPrimitiveMap() throws Exception JavaDoc
63   {
64     PrimitiveMap map = new PrimitiveMap();
65     
66     map.setBoolean("blah1", true);
67     map.setByte("blah2", (byte)32);
68     map.setBytes("blah3", new byte[30]);
69     map.setBytes("blah4", new byte[30], 10, 10);
70     map.setChar("blah5", 'x');
71     map.setShort("blah6", (short) 2);
72     map.setInt("blah7", 3);
73     map.setFloat("blah8", (float) 3.33);
74     map.setDouble("blah9", 4.44);
75     map.setBytes("blah10", new byte [] {0, 1, 2, 3, 4, 5});
76     map.setBytes("blah11", new byte [] {0, 1, 2, 3, 4, 5}, 1, 5);
77     map.setString("blah12", "testing");
78     
79     assertNotNull(map.toString());
80
81     assertEquals(true, map.getBoolean("blah1"));
82     assertEquals((byte)32, map.getByte("blah2"));
83     assertEquals(30, map.getBytes("blah3").length);
84     assertEquals(10, map.getBytes("blah4").length);
85     assertEquals('x', map.getChar("blah5"));
86     assertEquals((short)2, map.getShort("blah6"));
87     assertEquals(3, map.getInt("blah7"));
88     assertEquals((float)3.33, map.getFloat("blah8"), (float)0.0);
89     assertEquals(4.44, map.getDouble("blah9"), 0.0);
90     assertEquals((byte)5, map.getBytes("blah10")[5]);
91     assertEquals((byte)5, map.getBytes("blah11")[4]);
92     assertEquals("testing", map.getString("blah12"));
93     
94     map = (PrimitiveMap) convertObject(map, false);
95     
96     assertEquals(true, map.getBoolean("blah1"));
97     assertEquals((byte)32, map.getByte("blah2"));
98     assertEquals(30, map.getBytes("blah3").length);
99     assertEquals(10, map.getBytes("blah4").length);
100     assertEquals('x', map.getChar("blah5"));
101     assertEquals((short)2, map.getShort("blah6"));
102     assertEquals(3, map.getInt("blah7"));
103     assertEquals((float)3.33, map.getFloat("blah8"), (float)0.0);
104     assertEquals(4.44, map.getDouble("blah9"), 0.0);
105     assertEquals((byte)5, map.getBytes("blah10")[5]);
106     assertEquals((byte)5, map.getBytes("blah11")[4]);
107     assertEquals("testing", map.getString("blah12"));
108     
109     map.toString();
110     
111     assertEquals(true, map.getBoolean("blah1"));
112     assertEquals((byte)32, map.getByte("blah2"));
113     assertEquals(30, map.getBytes("blah3").length);
114     assertEquals(10, map.getBytes("blah4").length);
115     assertEquals('x', map.getChar("blah5"));
116     assertEquals((short)2, map.getShort("blah6"));
117     assertEquals(3, map.getInt("blah7"));
118     assertEquals((float)3.33, map.getFloat("blah8"), (float)0.0);
119     assertEquals(4.44, map.getDouble("blah9"), 0.0);
120     assertEquals((byte)5, map.getBytes("blah10")[5]);
121     assertEquals((byte)5, map.getBytes("blah11")[4]);
122     assertEquals("testing", map.getString("blah12"));
123     
124   }
125   
126   /**
127    * Verifies that a null message header's marshalled size is only two bytes.
128    */

129   public void testNullMessageHeader() throws Exception JavaDoc
130   {
131     MessageHeader header = new MessageHeader();
132     ByteArrayOutputStream JavaDoc byteOutStream = new ByteArrayOutputStream JavaDoc();
133     DataOutputStream JavaDoc dataOutStream = new DataOutputStream JavaDoc(byteOutStream);
134     header.marshal(dataOutStream);
135     byte [] bytes = byteOutStream.toByteArray();
136     assertEquals(2, bytes.length);
137   }
138   
139   public void testMessage() throws Exception JavaDoc
140   {
141     JmsMessage msg = new JmsMessage("test");
142     fillMessageHeader(msg);
143     msg = (JmsMessage) convertObject(msg, true);
144     testMessageHeader(msg);
145   }
146
147   public void testTextMessage() throws Exception JavaDoc
148   {
149     JmsTextMessage msg = new JmsTextMessage("test");
150     fillMessageHeader(msg);
151     msg.setText("asdfasdfasdfasdfasdfsdffjfjjfjfjfjfjjsdlfksjdf;asldfj;asdf");
152     msg.setText("this value should take");
153     msg = (JmsTextMessage) convertObject(msg, true);
154     testMessageHeader(msg);
155     assertEquals("this value should take", msg.getText());
156   }
157   
158   public void testObjectMessage() throws Exception JavaDoc
159   {
160     JmsObjectMessage msg = new JmsObjectMessage("test");
161     fillMessageHeader(msg);
162     msg.setObject("asdfasdfasdfasdfasdfsdffjfjjfjfjfjfjjsdlfksjdf;asldfj;asdf");
163     msg.setObject("this value should take");
164     msg = (JmsObjectMessage) convertObject(msg, true);
165     testMessageHeader(msg);
166     assertEquals("this value should take", msg.getObject());
167   }
168
169   public void testMapMessage() throws Exception JavaDoc
170   {
171     // TODO:: add tests specific to MapMessage
172
JmsMapMessage msg = new JmsMapMessage("test");
173     fillMessageHeader(msg);
174     msg = (JmsMapMessage) convertObject(msg, true);
175     testMessageHeader(msg);
176   }
177   
178   public void testBytesMessage() throws Exception JavaDoc
179   {
180     // TODO:: add tests specific to BytesMessage
181
JmsBytesMessage msg = new JmsBytesMessage("test");
182     fillMessageHeader(msg);
183     msg = (JmsBytesMessage) convertObject(msg, true);
184     testMessageHeader(msg);
185   }
186
187   public void testStreamMessage() throws Exception JavaDoc
188   {
189     // TODO:: add tests specific to SteamMessage
190
JmsStreamMessage msg = new JmsStreamMessage("test");
191     fillMessageHeader(msg);
192     msg = (JmsStreamMessage) convertObject(msg, true);
193     testMessageHeader(msg);
194   }
195
196     /////////////////////////////////////////////////////////////////////////
197
// Test helper methods //
198
/////////////////////////////////////////////////////////////////////////
199

200   private void fillMessageHeader(JmsMessage msg) throws Exception JavaDoc
201   {
202     msg.setBooleanProperty("blah1", true);
203     msg.setByteProperty("blah2", (byte)32);
204     msg.setShortProperty("blah6", (short) 2);
205     msg.setIntProperty("blah7", 3);
206     msg.setFloatProperty("blah8", (float) 3.33);
207     msg.setDoubleProperty("blah9", 4.44);
208     msg.setStringProperty("blah12", "testing");
209     msg.setJMSDestination(new com.presumo.jms.client.JmsTopic("test"));
210   }
211   
212   private void testMessageHeader(JmsMessage msg) throws Exception JavaDoc
213   {
214     assertEquals(true, msg.getBooleanProperty("blah1"));
215     assertEquals((byte)32, msg.getByteProperty("blah2"));
216     assertEquals((short)2, msg.getShortProperty("blah6"));
217     assertEquals(3, msg.getIntProperty("blah7"));
218     assertEquals((float)3.33, msg.getFloatProperty("blah8"), (float)0.0);
219     assertEquals(4.44, msg.getDoubleProperty("blah9"), 0.0);
220     assertEquals("testing", msg.getStringProperty("blah12"));
221     assertEquals("topic:test", msg.getJMSDestination().toString());
222     verbose("message after conversion ------------->");
223     verbose(msg);
224   }
225
226   /**
227    * Excercises every conversion path and returns a logically Equivelant object
228    */

229   private Externalizable JavaDoc convertObject(Externalizable JavaDoc object, boolean isMessage)
230     throws Exception JavaDoc
231   {
232     byte [] marshalledData;
233     ByteArrayOutputStream JavaDoc byteOutStream;
234     ByteArrayInputStream JavaDoc byteInStream;
235     ObjectOutputStream JavaDoc objOutStream;
236     ObjectInputStream JavaDoc objInStream;
237     DataOutputStream JavaDoc dataOutStream;
238     DataInputStream JavaDoc dataInStream;
239     
240     // First test if standard serialization works
241
byteOutStream = new ByteArrayOutputStream JavaDoc();
242     objOutStream = new ObjectOutputStream JavaDoc(byteOutStream);
243     objOutStream.writeObject(object);
244     objOutStream.flush();
245     objOutStream.close();
246     marshalledData = byteOutStream.toByteArray();
247     
248     byteInStream = new ByteArrayInputStream JavaDoc(marshalledData);
249     objInStream = new ObjectInputStream JavaDoc(byteInStream);
250     object = (Externalizable JavaDoc) objInStream.readObject();
251     objInStream.close();
252     byteInStream.close();
253     
254     verbose("Serialized data size: " + marshalledData.length);
255     verbose(object);
256     
257     // Now see if custom marshaling alone works
258
byteOutStream = new ByteArrayOutputStream JavaDoc();
259     dataOutStream = new DataOutputStream JavaDoc(byteOutStream);
260     if (isMessage)
261       ( (JmsMessage) object).marshal(dataOutStream);
262     else
263       ( (PrimitiveMap) object).marshal(dataOutStream);
264  
265     dataOutStream.flush();
266     dataOutStream.close();
267     marshalledData = byteOutStream.toByteArray();
268     
269     byteInStream = new ByteArrayInputStream JavaDoc(marshalledData);
270     dataInStream = new DataInputStream JavaDoc(byteInStream);
271     object = (Externalizable JavaDoc) object.getClass().newInstance();
272     if (isMessage)
273       ( (JmsMessage)object).unmarshal(dataInStream);
274     else
275       ( (PrimitiveMap)object).unmarshal(dataInStream);
276   
277     dataInStream.close();
278     byteInStream.close();
279     
280     verbose("Marshal data length: " + marshalledData.length);
281     verbose(object);
282     
283     // See if byte array conversions work
284
if (isMessage)
285       marshalledData = ( (JmsMessage) object).toByteArray();
286     else
287       marshalledData = ( (PrimitiveMap) object).toByteArray();
288       
289     Constructor JavaDoc c = object.getClass().getConstructor(new Class JavaDoc[]
290                             {byte[].class, Integer.TYPE, Integer.TYPE});
291     object = (Externalizable JavaDoc) c.newInstance(new Object JavaDoc [] { marshalledData,
292                                             new Integer JavaDoc(0),
293                                             new Integer JavaDoc(marshalledData.length) });
294
295     
296     verbose("toByteArray data length: "+marshalledData.length);
297     verbose(object);
298     
299     // Finally mix and match
300
byteOutStream = new ByteArrayOutputStream JavaDoc();
301     dataOutStream = new DataOutputStream JavaDoc(byteOutStream);
302     if (isMessage)
303       ( (JmsMessage) object).marshal(dataOutStream);
304     else
305       ( (PrimitiveMap) object).marshal(dataOutStream);
306       
307     dataOutStream.flush();
308     dataOutStream.close();
309     marshalledData = byteOutStream.toByteArray();
310     
311     object = (Externalizable JavaDoc) c.newInstance(new Object JavaDoc [] { marshalledData,
312                                            new Integer JavaDoc(0),
313                                            new Integer JavaDoc(marshalledData.length) });
314         
315     verbose("Externalized data length: "+marshalledData.length);
316     verbose(object);
317     // returned object should be logically equivelant to what was passed in
318
return object;
319   }
320   
321   private void verbose(Object JavaDoc obj)
322   {
323     if (VERBOSE) {
324       System.out.println(obj.toString());
325     }
326   }
327   
328   public static void main(String JavaDoc [] args)
329   {
330     junit.awtui.TestRunner.run(MessageTests.class);
331   }
332 }
333
Popular Tags