001: /*
002: * BEGIN_HEADER - DO NOT EDIT
003: *
004: * The contents of this file are subject to the terms
005: * of the Common Development and Distribution License
006: * (the "License"). You may not use this file except
007: * in compliance with the License.
008: *
009: * You can obtain a copy of the license at
010: * https://open-esb.dev.java.net/public/CDDLv1.0.html.
011: * See the License for the specific language governing
012: * permissions and limitations under the License.
013: *
014: * When distributing Covered Code, include this CDDL
015: * HEADER in each file and include the License file at
016: * https://open-esb.dev.java.net/public/CDDLv1.0.html.
017: * If applicable add the following below this CDDL HEADER,
018: * with the fields enclosed by brackets "[]" replaced with
019: * your own identifying information: Portions Copyright
020: * [year] [name of copyright owner]
021: */
022:
023: /*
024: * @(#)TestInOut.java
025: * Copyright 2004-2007 Sun Microsystems, Inc. All Rights Reserved.
026: *
027: * END_HEADER - DO NOT EDIT
028: */
029: package com.sun.jbi.messaging;
030:
031: import javax.jbi.messaging.ExchangeStatus;
032: import javax.jbi.messaging.Fault;
033: import javax.jbi.messaging.InOut;
034: import javax.jbi.messaging.MessageExchange;
035: import javax.jbi.messaging.MessageExchangeFactory;
036: import javax.jbi.messaging.NormalizedMessage;
037:
038: import javax.jbi.servicedesc.ServiceEndpoint;
039:
040: import javax.xml.namespace.QName;
041:
042: /**
043: * Test InOut Message Exchange.
044: * @author Sun Microsystems, Inc.
045: */
046: public class TestInOut extends junit.framework.TestCase {
047: private static final QName SERVICE = new QName("InOutService");
048: private static final String ENDPOINT = "InOutEndpoint";
049: private static final QName OPERATION = new QName("foobar");
050:
051: private MessageService mMsgSvc;
052: private MessageExchangeFactory mFactory;
053: /** NMR Environment Context */
054: private NMRContext mContext;
055:
056: /**
057: * The constructor for this testcase, forwards the test name to
058: * the jUnit TestCase base class.
059: * @param aTestName String with the name of this test.
060: */
061: public TestInOut(String aTestName) throws Exception {
062: super (aTestName);
063: mMsgSvc = new MessageService();
064: mFactory = new ExchangeFactory(mMsgSvc);
065: mContext = new NMRContext(mMsgSvc);
066: }
067:
068: /**
069: * Setup for the test.
070: * @throws Exception when set up fails for any reason.
071: */
072: public void setUp() throws Exception {
073: super .setUp();
074:
075: mMsgSvc.initService(mContext);
076: mMsgSvc.startService();
077: }
078:
079: /**
080: * Cleanup for the test.
081: * @throws Exception when tearDown fails for any reason.
082: */
083: public void tearDown() throws Exception {
084: super .tearDown();
085:
086: mMsgSvc.stopService();
087: mContext.reset();
088: }
089:
090: // ============================= test methods ================================
091:
092: /**
093: * Happy path test for an InOut exchange with status
094: * @throws Exception test failed
095: */
096: public void testExchangeGood() throws Exception {
097: Binding binding;
098: Engine engine;
099:
100: binding = new HappyBinding(mMsgSvc.activateChannel("binding",
101: null));
102: engine = new HappyEngine(mMsgSvc
103: .activateChannel("engine", null));
104:
105: engine.init(SERVICE, ENDPOINT, ExchangePattern.IN_OUT
106: .toString());
107: binding.init(SERVICE);
108:
109: Framework.runTest(binding, engine);
110:
111: // check for binding or engine failure
112: binding.checkError();
113: engine.checkError();
114:
115: binding.stop();
116: engine.stop();
117: }
118:
119: /**
120: * Happy path test for an InOut exchange with fault
121: * @throws Exception test failed
122: */
123: public void testExchangeGood2() throws Exception {
124: Binding binding;
125: Engine engine;
126:
127: binding = new HappyBinding2(mMsgSvc.activateChannel("binding",
128: null));
129: engine = new HappyEngine2(mMsgSvc.activateChannel("engine",
130: null));
131:
132: engine.init(SERVICE, ENDPOINT, ExchangePattern.IN_OUT
133: .toString());
134: binding.init(SERVICE);
135:
136: Framework.runTest(binding, engine);
137:
138: // check for binding or engine failure
139: binding.checkError();
140: engine.checkError();
141:
142: binding.stop();
143: engine.stop();
144: }
145:
146: /**
147: * Happy path test for an InOut exchange with error status
148: * @throws Exception test failed
149: */
150: public void testExchangeGood3() throws Exception {
151: Binding binding;
152: Engine engine;
153:
154: binding = new HappyBinding3(mMsgSvc.activateChannel("binding",
155: null));
156: engine = new HappyEngine3(mMsgSvc.activateChannel("engine",
157: null));
158:
159: engine.init(SERVICE, ENDPOINT, ExchangePattern.IN_OUT
160: .toString());
161: binding.init(SERVICE);
162:
163: Framework.runTest(binding, engine);
164:
165: // check for binding or engine failure
166: binding.checkError();
167: engine.checkError();
168:
169: binding.stop();
170: engine.stop();
171: }
172:
173: /**
174: * Happy path test for an InOut exchange with error status
175: * @throws Exception test failed
176: */
177: public void testExchangeBindingSynch() throws Exception {
178: Binding binding;
179: Engine engine;
180:
181: binding = new HappySynchBinding(mMsgSvc.activateChannel(
182: "binding", null));
183: engine = new HappyEngine(mMsgSvc
184: .activateChannel("engine", null));
185:
186: engine.init(SERVICE, ENDPOINT, ExchangePattern.IN_OUT
187: .toString());
188: binding.init(SERVICE);
189:
190: Framework.runTest(binding, engine);
191:
192: // check for binding or engine failure
193: binding.checkError();
194: engine.checkError();
195:
196: binding.stop();
197: engine.stop();
198: }
199:
200: public void testExchangeEngineSynch() throws Exception {
201: Binding binding;
202: Engine engine;
203:
204: binding = new HappyBinding(mMsgSvc.activateChannel("binding",
205: null));
206: engine = new HappySynchEngine(mMsgSvc.activateChannel("engine",
207: null));
208:
209: engine.init(SERVICE, ENDPOINT, ExchangePattern.IN_OUT
210: .toString());
211: binding.init(SERVICE);
212:
213: Framework.runTest(binding, engine);
214:
215: // check for binding or engine failure
216: binding.checkError();
217: engine.checkError();
218:
219: binding.stop();
220: engine.stop();
221: }
222:
223: public void testExchangeGoodBothSynch() throws Exception {
224: Binding binding;
225: Engine engine;
226:
227: binding = new HappySynchBinding(mMsgSvc.activateChannel(
228: "binding", null));
229: engine = new HappySynchEngine(mMsgSvc.activateChannel("engine",
230: null));
231:
232: engine.init(SERVICE, ENDPOINT, ExchangePattern.IN_OUT
233: .toString());
234: binding.init(SERVICE);
235:
236: Framework.runTest(binding, engine);
237:
238: // check for binding or engine failure
239: binding.checkError();
240: engine.checkError();
241:
242: binding.stop();
243: engine.stop();
244: }
245:
246: /**
247: * Attempt to do bad things with an InOut exchange.
248: * @throws Exception test failed
249: */
250: public void testExchangeFailure() throws Exception {
251: Binding binding;
252: Engine engine;
253:
254: binding = new HappyBinding(mMsgSvc.activateChannel("binding",
255: null));
256: engine = new BadEngine(mMsgSvc.activateChannel("engine", null));
257:
258: engine.init(SERVICE, ENDPOINT, ExchangePattern.IN_OUT
259: .toString());
260: binding.init(SERVICE);
261:
262: Framework.runTest(binding, engine);
263:
264: // check for binding or engine failure
265: binding.checkError();
266: engine.checkError();
267:
268: binding.stop();
269: engine.stop();
270: }
271:
272: // ============================ internal stuff ================================
273:
274: class HappyBinding extends Binding {
275: HappyBinding(DeliveryChannelImpl channel) {
276: super (channel);
277: }
278:
279: public void start() throws Exception {
280: NormalizedMessage inMsg;
281: InOut inOut;
282:
283: // create the exchange
284: inOut = mFactory.createInOutExchange();
285: inMsg = inOut.createMessage();
286: assertEquals(inOut.getPattern().toString(),
287: ExchangePattern.IN_OUT.toString());
288: assertEquals(ExchangeStatus.ACTIVE, inOut.getStatus());
289: assertEquals(MessageExchange.Role.CONSUMER, inOut.getRole());
290:
291: // set the stuff we know & check that they are set.
292: inOut.setEndpoint(mEndpoint);
293: assertEquals(mEndpoint, inOut.getEndpoint());
294:
295: inOut.setOperation(OPERATION);
296: assertEquals(OPERATION, inOut.getOperation());
297:
298: // set the payload
299: Payload.setPayload(inMsg);
300:
301: // set message on exchange
302: inOut.setInMessage(inMsg);
303: assertEquals(inMsg, inOut.getInMessage());
304:
305: // send the exchange
306: mChannel.send(inOut);
307: assertEquals(MessageExchange.Role.CONSUMER, inOut.getRole());
308:
309: // Check that settings are ignored while ownership is elsewhere.
310:
311: inOut.setEndpoint(null);
312: assertEquals(mEndpoint, inOut.getEndpoint());
313:
314: inOut.setOperation(null);
315: assertEquals(OPERATION, inOut.getOperation());
316:
317: // receive the response
318: inOut = (InOut) mChannel.accept();
319: assertEquals(MessageExchange.Role.CONSUMER, inOut.getRole());
320:
321: assertEquals(ExchangeStatus.ACTIVE, inOut.getStatus());
322: assertTrue(inOut.getFault() == null);
323:
324: // Check that settings are ignored while still ACTIVE.
325:
326: inOut.setEndpoint(null);
327: assertEquals(mEndpoint, inOut.getEndpoint());
328:
329: inOut.setOperation(null);
330: assertEquals(OPERATION, inOut.getOperation());
331:
332: inOut.setStatus(ExchangeStatus.DONE);
333:
334: // Try create a fault after status has been set.
335: try {
336: inOut.createFault();
337: setFailure("Able to create a fault after status set.");
338: } catch (Exception ex) {
339: }
340:
341: mChannel.send(inOut);
342: assertEquals(MessageExchange.Role.CONSUMER, inOut.getRole());
343:
344: // Check that settings are ignored while still ACTIVE.
345:
346: inOut.setEndpoint(null);
347: assertEquals(mEndpoint, inOut.getEndpoint());
348:
349: inOut.setOperation(null);
350: assertEquals(OPERATION, inOut.getOperation());
351: }
352: }
353:
354: class HappyBinding2 extends Binding {
355: HappyBinding2(DeliveryChannelImpl channel) {
356: super (channel);
357: }
358:
359: public void start() throws Exception {
360: NormalizedMessage inMsg;
361: InOut inOut;
362:
363: // create the exchange
364: inOut = mFactory.createInOutExchange();
365: inMsg = inOut.createMessage();
366: assertEquals(MessageExchange.Role.CONSUMER, inOut.getRole());
367:
368: // set the stuff we know & check that they are set.
369: inOut.setEndpoint(mEndpoint);
370: assertEquals(mEndpoint, inOut.getEndpoint());
371:
372: inOut.setOperation(OPERATION);
373: assertEquals(OPERATION, inOut.getOperation());
374:
375: // set the payload
376: Payload.setPayload(inMsg);
377:
378: // set message on exchange
379: inOut.setInMessage(inMsg);
380: assertEquals(inMsg, inOut.getInMessage());
381:
382: // send the exchange
383: mChannel.send(inOut);
384: assertEquals(MessageExchange.Role.CONSUMER, inOut.getRole());
385:
386: // Check that settings are ignored while ownership is elsewhere.
387:
388: inOut.setEndpoint(null);
389: assertEquals(mEndpoint, inOut.getEndpoint());
390:
391: inOut.setOperation(null);
392: assertEquals(OPERATION, inOut.getOperation());
393:
394: // receive the response
395: inOut = (InOut) mChannel.accept();
396:
397: assertEquals(ExchangeStatus.ACTIVE, inOut.getStatus());
398: assertTrue(inOut.getFault() != null);
399:
400: // Check that settings are ignored when ACTIVE.
401:
402: inOut.setEndpoint(null);
403: assertEquals(mEndpoint, inOut.getEndpoint());
404:
405: inOut.setOperation(null);
406: assertEquals(OPERATION, inOut.getOperation());
407:
408: inOut.setStatus(ExchangeStatus.ERROR);
409: mChannel.send(inOut);
410: assertEquals(MessageExchange.Role.CONSUMER, inOut.getRole());
411:
412: // Check that settings are ignored while still ERROR.
413: inOut.setEndpoint(null);
414: assertEquals(mEndpoint, inOut.getEndpoint());
415:
416: inOut.setOperation(null);
417: assertEquals(OPERATION, inOut.getOperation());
418: }
419: }
420:
421: class HappyBinding3 extends Binding {
422: HappyBinding3(DeliveryChannelImpl channel) {
423: super (channel);
424: }
425:
426: public void start() throws Exception {
427: NormalizedMessage inMsg;
428: InOut inOut;
429:
430: // create the exchange
431: inOut = mFactory.createInOutExchange();
432: inMsg = inOut.createMessage();
433: assertEquals(MessageExchange.Role.CONSUMER, inOut.getRole());
434:
435: // set the stuff we know & check that they are set.
436: inOut.setEndpoint(mEndpoint);
437: assertEquals(mEndpoint, inOut.getEndpoint());
438:
439: inOut.setOperation(OPERATION);
440: assertEquals(OPERATION, inOut.getOperation());
441:
442: // set the payload
443: Payload.setPayload(inMsg);
444:
445: // set message on exchange
446: inOut.setInMessage(inMsg);
447: assertEquals(inMsg, inOut.getInMessage());
448:
449: // send the exchange
450: mChannel.send(inOut);
451: assertEquals(MessageExchange.Role.CONSUMER, inOut.getRole());
452:
453: // Check that settings are ignored while ownership is elsewhere.
454:
455: inOut.setEndpoint(null);
456: assertEquals(mEndpoint, inOut.getEndpoint());
457:
458: inOut.setOperation(null);
459: assertEquals(OPERATION, inOut.getOperation());
460:
461: // receive the response
462: inOut = (InOut) mChannel.accept();
463: assertEquals(MessageExchange.Role.CONSUMER, inOut.getRole());
464: assertEquals(ExchangeStatus.ERROR, inOut.getStatus());
465: }
466: }
467:
468: class HappySynchBinding extends Binding {
469: HappySynchBinding(DeliveryChannelImpl channel) {
470: super (channel);
471: }
472:
473: public void start() throws Exception {
474: NormalizedMessage inMsg;
475: InOut inOut;
476:
477: // create the exchange
478: inOut = mFactory.createInOutExchange();
479: inMsg = inOut.createMessage();
480: assertEquals(inOut.getPattern().toString(),
481: ExchangePattern.IN_OUT.toString());
482: assertEquals(ExchangeStatus.ACTIVE, inOut.getStatus());
483: assertEquals(MessageExchange.Role.CONSUMER, inOut.getRole());
484:
485: // set the stuff we know & check that they are set.
486: inOut.setEndpoint(mEndpoint);
487: assertEquals(mEndpoint, inOut.getEndpoint());
488:
489: inOut.setOperation(OPERATION);
490: assertEquals(OPERATION, inOut.getOperation());
491:
492: // set the payload
493: Payload.setPayload(inMsg);
494:
495: // set message on exchange
496: inOut.setInMessage(inMsg);
497: assertEquals(inMsg, inOut.getInMessage());
498:
499: // send the exchange and wait for response
500: assertTrue(mChannel.sendSync(inOut));
501: assertEquals(MessageExchange.Role.CONSUMER, inOut.getRole());
502: assertEquals(ExchangeStatus.ACTIVE, inOut.getStatus());
503: assertTrue(inOut.getFault() == null);
504:
505: // Check that settings are ignored while still ACTIVE.
506:
507: inOut.setEndpoint(null);
508: assertEquals(mEndpoint, inOut.getEndpoint());
509:
510: inOut.setOperation(null);
511: assertEquals(OPERATION, inOut.getOperation());
512:
513: inOut.setStatus(ExchangeStatus.DONE);
514:
515: // Try create a fault after status has been set.
516: try {
517: inOut.createFault();
518: setFailure("Able to create a fault after status set.");
519: } catch (Exception ex) {
520: }
521:
522: // Try sendSync
523: try {
524: mChannel.sendSync(inOut);
525: setFailure("Able to sendSync when not legal");
526: } catch (Exception ex) {
527: }
528: ;
529: mChannel.send(inOut);
530: assertEquals(MessageExchange.Role.CONSUMER, inOut.getRole());
531:
532: // Check that settings are ignored while still ACTIVE.
533:
534: inOut.setEndpoint(null);
535: assertEquals(mEndpoint, inOut.getEndpoint());
536:
537: inOut.setOperation(null);
538: assertEquals(OPERATION, inOut.getOperation());
539: }
540: }
541:
542: class HappyEngine extends Engine {
543: HappyEngine(DeliveryChannelImpl channel) {
544: super (channel);
545: }
546:
547: public void start() throws Exception {
548: InOut inOut;
549: NormalizedMessage outMsg;
550:
551: inOut = (InOut) mChannel.accept();
552: assertEquals(inOut.getPattern().toString(),
553: ExchangePattern.IN_OUT.toString());
554: assertEquals(MessageExchange.Role.PROVIDER, inOut.getRole());
555: outMsg = inOut.createMessage();
556:
557: // Check that settings are ignored after message is ACTIVE.
558:
559: inOut.setEndpoint(null);
560: assertNotSame("Allowed to set endpoint after ACTIVE", null,
561: inOut.getEndpoint());
562:
563: inOut.setOperation(null);
564: assertNotSame("Allowed to set operation after ACTIVE",
565: null, inOut.getOperation());
566:
567: // Check that we can't set DONE status.
568: try {
569: inOut.setStatus(ExchangeStatus.DONE);
570: setFailure("Able to set DONE on InOut Exchange as provider.");
571: } catch (Exception Ex) {
572: }
573:
574: // verify in message is present
575: if (inOut.getInMessage() == null) {
576: setFailure("In message is null!");
577: return;
578: }
579:
580: inOut.setOutMessage(outMsg);
581: mChannel.send(inOut);
582: assertEquals(MessageExchange.Role.PROVIDER, inOut.getRole());
583:
584: // Check that settings are ignored after message is DONE.
585:
586: inOut.setEndpoint(null);
587: assertNotSame("Allowed to set endpoint after done", null,
588: inOut.getEndpoint());
589:
590: inOut.setOperation(null);
591: assertNotSame("Allowed to set operation after done", null,
592: inOut.getOperation());
593:
594: inOut = (InOut) mChannel.accept();
595: assertEquals(ExchangeStatus.DONE, inOut.getStatus());
596: assertEquals(MessageExchange.Role.PROVIDER, inOut.getRole());
597: }
598: }
599:
600: class HappySynchEngine extends Engine {
601: HappySynchEngine(DeliveryChannelImpl channel) {
602: super (channel);
603: }
604:
605: public void start() throws Exception {
606: InOut inOut;
607: NormalizedMessage outMsg;
608:
609: inOut = (InOut) mChannel.accept();
610: assertEquals(inOut.getPattern().toString(),
611: ExchangePattern.IN_OUT.toString());
612: assertEquals(MessageExchange.Role.PROVIDER, inOut.getRole());
613: outMsg = inOut.createMessage();
614:
615: // Check that settings are ignored after message is ACTIVE.
616:
617: inOut.setEndpoint(null);
618: assertNotSame("Allowed to set endpoint after ACTIVE", null,
619: inOut.getEndpoint());
620:
621: inOut.setOperation(null);
622: assertNotSame("Allowed to set operation after ACTIVE",
623: null, inOut.getOperation());
624:
625: // verify in message is present
626: if (inOut.getInMessage() == null) {
627: setFailure("In message is null!");
628: return;
629: }
630:
631: inOut.setOutMessage(outMsg);
632: assertTrue(mChannel.sendSync(inOut));
633: assertEquals(ExchangeStatus.DONE, inOut.getStatus());
634: assertEquals(MessageExchange.Role.PROVIDER, inOut.getRole());
635: }
636: }
637:
638: class HappyEngine2 extends Engine {
639: HappyEngine2(DeliveryChannelImpl channel) {
640: super (channel);
641: }
642:
643: public void start() throws Exception {
644: InOut inOut;
645:
646: inOut = (InOut) mChannel.accept();
647: assertEquals(MessageExchange.Role.PROVIDER, inOut.getRole());
648:
649: // Check that settings are ignored after message is ACTIVE.
650:
651: inOut.setEndpoint(null);
652: assertNotSame("Allowed to set endpoint after ACTIVE", null,
653: inOut.getEndpoint());
654:
655: inOut.setOperation(null);
656: assertNotSame("Allowed to set operation after ACTIVE",
657: null, inOut.getOperation());
658:
659: // verify in message is present
660: if (inOut.getInMessage() == null) {
661: setFailure("In message is null!");
662: return;
663: }
664:
665: inOut.setFault(inOut.createFault());
666: mChannel.send(inOut);
667: assertEquals(MessageExchange.Role.PROVIDER, inOut.getRole());
668:
669: // Check that settings are ignored after message is DONE.
670:
671: inOut.setEndpoint(null);
672: assertNotSame("Allowed to set endpoint after done", null,
673: inOut.getEndpoint());
674:
675: inOut.setOperation(null);
676: assertNotSame("Allowed to set operation after done", null,
677: inOut.getOperation());
678:
679: inOut = (InOut) mChannel.accept();
680: assertEquals(ExchangeStatus.ERROR, inOut.getStatus());
681: assertEquals(MessageExchange.Role.PROVIDER, inOut.getRole());
682: }
683: }
684:
685: class HappyEngine3 extends Engine {
686: HappyEngine3(DeliveryChannelImpl channel) {
687: super (channel);
688: }
689:
690: public void start() throws Exception {
691: InOut inOut;
692: NormalizedMessage outMsg;
693:
694: inOut = (InOut) mChannel.accept();
695: assertEquals(MessageExchange.Role.PROVIDER, inOut.getRole());
696:
697: // Check that settings are ignored after message is ACTIVE.
698:
699: inOut.setEndpoint(null);
700: assertNotSame("Allowed to set endpoint after ACTIVE", null,
701: inOut.getEndpoint());
702:
703: inOut.setOperation(null);
704: assertNotSame("Allowed to set operation after ACTIVE",
705: null, inOut.getOperation());
706:
707: // verify in message is present
708: if (inOut.getInMessage() == null) {
709: setFailure("In message is null!");
710: return;
711: }
712:
713: // Check that Error status can be set after an OUT message has been set and that
714: // the OUT message is null'ed after ERROR is set.'
715:
716: outMsg = inOut.createMessage();
717: inOut.setOutMessage(outMsg);
718: inOut.setStatus(ExchangeStatus.ERROR);
719: assertSame("Out message not null after ERROR set", inOut
720: .getOutMessage(), null);
721: try {
722: inOut.setOutMessage(outMsg);
723: setFailure("Can set OUT message after ERROR has been set.");
724: } catch (Exception e) {
725: }
726:
727: mChannel.send(inOut);
728: assertEquals(MessageExchange.Role.PROVIDER, inOut.getRole());
729:
730: // Check that settings are ignored after message is DONE.
731:
732: inOut.setEndpoint(null);
733: assertNotSame("Allowed to set endpoint after done", null,
734: inOut.getEndpoint());
735:
736: inOut.setOperation(null);
737: assertNotSame("Allowed to set operation after done", null,
738: inOut.getOperation());
739: }
740: }
741:
742: class BadEngine extends Engine {
743: BadEngine(DeliveryChannelImpl channel) {
744: super (channel);
745: }
746:
747: public void start() throws Exception {
748: InOut inOut;
749: Fault fault;
750: NormalizedMessage msg;
751:
752: inOut = (InOut) mChannel.accept();
753: assertEquals(MessageExchange.Role.PROVIDER, inOut.getRole());
754:
755: // Try and set in message from engine
756: try {
757: msg = inOut.createMessage();
758: inOut.setInMessage(msg);
759: setFailure("Able to set in message from engine");
760: return;
761: } catch (Exception ex1) {
762: }
763: ;
764:
765: // complete the exchange normally
766: msg = inOut.createMessage();
767: inOut.setOutMessage(msg);
768: mChannel.send(inOut);
769: assertEquals(MessageExchange.Role.PROVIDER, inOut.getRole());
770:
771: // Try and set out after DONE.
772: try {
773: msg = inOut.createMessage();
774: inOut.setOutMessage(msg);
775: setFailure("Able to set out message after send from engine.");
776: return;
777: } catch (Exception ex1) {
778: }
779: ;
780:
781: // Try and set a status.
782: try {
783: inOut.setStatus(ExchangeStatus.DONE);
784: setFailure("Able to set status.");
785: } catch (Exception ex1) {
786: }
787: ;
788:
789: inOut = (InOut) mChannel.accept();
790: assertEquals(MessageExchange.Role.PROVIDER, inOut.getRole());
791: }
792: }
793: }
|