|
1
24
25 package org.objectweb.jtests.jms.conform.message;
26
27 import org.objectweb.jtests.jms.framework.PTPTestCase;
28 import org.objectweb.jtests.jms.framework.TestConfig;
29 import junit.framework.Test;
30 import junit.framework.TestSuite;
31 import javax.jms.*;
32 import java.util.Vector  ;
33 import java.util.Enumeration ;
34
35
54 public class MessageTypeTest extends PTPTestCase {
55
56
62 public void testStreamMessage_2() {
63 try {
64 StreamMessage message = senderSession.createStreamMessage();
65 message.writeString("pi");
66 message.writeDouble(3.14159);
67 sender.send(message);
68
69 Message m = receiver.receive(TestConfig.TIMEOUT);
70 assertTrue("The message should be an instance of StreamMessage.\n",
71 m instanceof StreamMessage);
72 StreamMessage msg = (StreamMessage)m;
73 assertEquals("pi", msg.readString());
74 assertEquals(3.14159, msg.readDouble(), 0);
75 } catch (JMSException e) {
76 fail(e);
77 }
78 }
79
80
86 public void testStreamMessage_1() {
87 try {
88 StreamMessage message = senderSession.createStreamMessage();
89 sender.send(message);
90
91 Message msg = receiver.receive(TestConfig.TIMEOUT);
92 assertTrue("The message should be an instance of StreamMessage.\n",
93 msg instanceof StreamMessage);
94 } catch (JMSException e) {
95 fail(e);
96 }
97 }
98
99
103 public void testMapMessageConversion() {
104 try {
105 MapMessage message = senderSession.createMapMessage();
106 message.setDouble("pi", 3.14159);
107 sender.send(message);
108
109 Message m = receiver.receive(TestConfig.TIMEOUT);
110 assertTrue("The message should be an instance of MapMessage.\n",
111 m instanceof MapMessage);
112 MapMessage msg = (MapMessage)m;
113 assertTrue(msg.getObject("pi") instanceof Double );
114 assertEquals(3.14159, ((Double )msg.getObject("pi")).doubleValue(), 0);
115 assertEquals(3.14159, msg.getDouble("pi"), 0);
116 } catch (JMSException e) {
117 fail(e);
118 }
119 }
120
121
127 public void testNullInSetMethodsForMapMessage() {
128 try {
129 MapMessage message = senderSession.createMapMessage();
130 message.setBoolean(null, true);
131 fail("Should throw an IllegalArgumentException");
132 } catch (IllegalArgumentException e) {
133 } catch (JMSException e) {
134 fail("Should throw an IllegalArgumentException, not a" +e);
135 }
136 }
137
138
144 public void testEmptyStringInSetMethodsForMapMessage() {
145 try {
146 MapMessage message = senderSession.createMapMessage();
147 message.setBoolean("", true);
148 fail("Should throw an IllegalArgumentException");
149 } catch (IllegalArgumentException e) {
150 } catch (JMSException e) {
151 fail("Should throw an IllegalArgumentException, not a" +e);
152 }
153 }
154
155
161 public void testgetMapNames() {
162 try {
163 MapMessage message = senderSession.createMapMessage();
164 Enumeration e = message.getMapNames();
165 assertTrue("No map yet defined.\n",
166 !e.hasMoreElements());
167 message.setDouble("pi", 3.14159);
168 e = message.getMapNames();
169 assertEquals("pi", (String )(e.nextElement()));
170 } catch (JMSException e) {
171 fail(e);
172 }
173 }
174
175
181 public void testMapMessage_2() {
182 try {
183 MapMessage message = senderSession.createMapMessage();
184 message.setString("name", "pi");
185 message.setDouble("value",3.14159);
186 sender.send(message);
187
188 Message m = receiver.receive(TestConfig.TIMEOUT);
189 assertTrue("The message should be an instance of MapMessage.\n",
190 m instanceof MapMessage);
191 MapMessage msg = (MapMessage)m;
192 assertEquals("pi", msg.getString("name"));
193 assertEquals(3.14159, msg.getDouble("value"), 0);
194 } catch (JMSException e) {
195 fail(e);
196 }
197 }
198
199
205 public void testMapMessage_1() {
206 try {
207 MapMessage message = senderSession.createMapMessage();
208 sender.send(message);
209
210 Message msg = receiver.receive(TestConfig.TIMEOUT);
211 assertTrue("The message should be an instance of MapMessage.\n",
212 msg instanceof MapMessage);
213 } catch (JMSException e) {
214 fail(e);
215 }
216 }
217
218
224 public void testObjectMessage_2() {
225 try {
226 Vector vector = new Vector ();
227 vector.add("pi");
228 vector.add(new Double (3.14159));
229
230 ObjectMessage message = senderSession.createObjectMessage();
231 message.setObject(vector);
232 sender.send(message);
233
234 Message m = receiver.receive(TestConfig.TIMEOUT);
235 assertTrue("The message should be an instance of ObjectMessage.\n",
236 m instanceof ObjectMessage);
237 ObjectMessage msg = (ObjectMessage)m;
238 assertEquals(vector, msg.getObject());
239 } catch (JMSException e) {
240 fail(e);
241 }
242 }
243
244
250 public void testObjectMessage_1() {
251 try {
252 ObjectMessage message = senderSession.createObjectMessage();
253 sender.send(message);
254
255 Message msg = receiver.receive(TestConfig.TIMEOUT);
256 assertTrue("The message should be an instance of ObjectMessage.\n",
257 msg instanceof ObjectMessage);
258 } catch (JMSException e) {
259 fail(e);
260 }
261 }
262
263
269 public void testBytesMessage_2() {
270 try {
271 byte[] bytes = new String ("pi").getBytes();
272 BytesMessage message = senderSession.createBytesMessage();
273 message.writeBytes(bytes);
274 message.writeDouble(3.14159);
275 sender.send(message);
276
277 Message m = receiver.receive(TestConfig.TIMEOUT);
278 assertTrue("The message should be an instance of BytesMessage.\n",
279 m instanceof BytesMessage);
280 BytesMessage msg = (BytesMessage)m;
281 byte[] receivedBytes = new byte[bytes.length];
282 msg.readBytes(receivedBytes);
283 assertEquals(new String (bytes), new String (receivedBytes));
284 assertEquals(3.14159, msg.readDouble(), 0);
285 } catch (JMSException e) {
286 fail(e);
287 }
288 }
289
290
296 public void testBytesMessage_1() {
297 try {
298 BytesMessage message = senderSession.createBytesMessage();
299 sender.send(message);
300
301 Message msg = receiver.receive(TestConfig.TIMEOUT);
302 assertTrue("The message should be an instance of BytesMessage.\n",
303 msg instanceof BytesMessage);
304 } catch (JMSException e) {
305 fail(e);
306 }
307 }
308
309
315 public void testTextMessage_2() {
316 try {
317 TextMessage message = senderSession.createTextMessage();
318 message.setText("testTextMessage_2");
319 sender.send(message);
320
321 Message m = receiver.receive(TestConfig.TIMEOUT);
322 assertTrue("The message should be an instance of TextMessage.\n",
323 m instanceof TextMessage);
324 TextMessage msg = (TextMessage)m;
325 assertEquals("testTextMessage_2", msg.getText());
326 } catch (JMSException e) {
327 fail(e);
328 }
329 }
330
331
337 public void testTextMessage_1() {
338 try {
339 TextMessage message = senderSession.createTextMessage();
340 sender.send(message);
341
342 Message msg = receiver.receive(TestConfig.TIMEOUT);
343 assertTrue("The message should be an instance of TextMessage.\n",
344 msg instanceof TextMessage);
345 } catch (JMSException e) {
346 fail(e);
347 }
348 }
349
350
353 public static Test suite() {
354 return new TestSuite(MessageTypeTest.class);
355 }
356
357 public MessageTypeTest(String name) {
358 super(name);
359 }
360 }
361 |
Popular Tags |
Java API By Example, From Geeks To Geeks.