You are viewing a plain text version of this content. The canonical link for it is here.
Posted to java-dev@axis.apache.org by pr...@apache.org on 2007/06/27 18:46:04 UTC
svn commit: r551228 [8/23] - in /webservices/axis2/branches/java/jaxws21: ./
etc/ modules/adb-codegen/src/org/apache/axis2/schema/
modules/adb-codegen/src/org/apache/axis2/schema/template/
modules/adb-codegen/src/org/apache/axis2/schema/writer/ modules...
Modified: webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/handler/HandlerChainProcessorTests.java
URL: http://svn.apache.org/viewvc/webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/handler/HandlerChainProcessorTests.java?view=diff&rev=551228&r1=551227&r2=551228
==============================================================================
--- webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/handler/HandlerChainProcessorTests.java (original)
+++ webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/handler/HandlerChainProcessorTests.java Wed Jun 27 09:45:37 2007
@@ -27,6 +27,7 @@
import junit.framework.TestCase;
+import org.apache.axis2.jaxws.core.MEPContext;
import org.apache.axis2.jaxws.core.MessageContext;
import org.apache.axis2.jaxws.message.Protocol;
@@ -48,861 +49,966 @@
*/
public class HandlerChainProcessorTests extends TestCase {
- // String result is how we'll verify the right methods from
- // the Handler implementations were called
- private String result = new String();
-
- private enum ResultDesired { TRUE, FALSE, PROTOCOL_EXCEPTION, OTHER_EXCEPTION };
-
- // use the following to dictate how the Handler methods behave
- private ResultDesired soaphandler1_MessageResultDesired;
- private ResultDesired soaphandler1_FaultResultDesired;
- private ResultDesired soaphandler2_MessageResultDesired;
- private ResultDesired soaphandler2_FaultResultDesired;
- private ResultDesired logicalhandler1_MessageResultDesired;
- private ResultDesired logicalhandler1_FaultResultDesired;
- private ResultDesired logicalhandler2_MessageResultDesired;
- private ResultDesired logicalhandler2_FaultResultDesired;
-
- ArrayList<Handler> handlers = new ArrayList<Handler>();
-
- @Override
- protected void setUp() throws Exception {
- // HandlerChainProcessor expects a sorted chain
- handlers.add(new LogicalHandler2());
- handlers.add(new LogicalHandler1());
- handlers.add(new SOAPHandler1());
- handlers.add(new SOAPHandler2());
- }
-
- /*
- * empty list
- */
- public void testHandleMessage_empty1() {
-
- Exception local_exception = null;
-
- HandlerChainProcessor processor1 = new HandlerChainProcessor(null, Protocol.soap11);
- HandlerChainProcessor processor2 = new HandlerChainProcessor(new ArrayList<Handler>(), Protocol.soap11);
- try {
- processor1.processChain(new MessageContext(), HandlerChainProcessor.Direction.IN, HandlerChainProcessor.MEP.REQUEST, true);
- processor2.processChain(new MessageContext(), HandlerChainProcessor.Direction.IN, HandlerChainProcessor.MEP.REQUEST, true);
- } catch (Exception e) {
- local_exception = e;
- }
-
- // no exceptions!
- assertNull(local_exception);
- }
-
- /*
- * one protocol handler
- * processing expected: Logical and SOAP, reverse order, close
- */
- public void testHandleMessage_oneproto1() {
-
- // reset result
- result = "";
-
- // use a local list
- ArrayList<Handler> local_list = new ArrayList<Handler>();
- local_list.add(new SOAPHandler1());
-
- // we want all good responses:
- soaphandler1_MessageResultDesired = ResultDesired.TRUE;
- soaphandler1_FaultResultDesired = ResultDesired.TRUE;
-
- HandlerChainProcessor processor = new HandlerChainProcessor(local_list, Protocol.soap11);
-
- processor.processChain(new MessageContext(), HandlerChainProcessor.Direction.IN, HandlerChainProcessor.MEP.REQUEST, false);
-
- assertEquals("S1m:S1c:", result);
-
- }
-
- /*
- * one protocol handler in a logical context
- * no handlers will be processed
- */
- public void testHandleMessage_oneproto2() {
-
- // reset result
- result = "";
-
- // use a local list
- ArrayList<Handler> local_list = new ArrayList<Handler>();
- local_list.add(new SOAPHandler1());
-
- // we want all good responses:
- soaphandler1_MessageResultDesired = ResultDesired.TRUE;
- soaphandler1_FaultResultDesired = ResultDesired.TRUE;
-
- HandlerChainProcessor processor = new HandlerChainProcessor(local_list, Protocol.soap11);
-
- processor.processChain(new MessageContext(), HandlerChainProcessor.Direction.IN, HandlerChainProcessor.MEP.REQUEST, false);
-
- assertEquals("S1m:S1c:", result);
- }
-
- /*
- * one logical handler
- * processing expected: Logical and SOAP, reverse order, close
- */
- public void testHandleMessage_onelogical() {
-
- // reset result
- result = "";
-
- // use a local list
- ArrayList<Handler> local_list = new ArrayList<Handler>();
- local_list.add(new LogicalHandler1());
-
- // we want all good responses:
- logicalhandler1_MessageResultDesired = ResultDesired.TRUE;
- logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
-
- HandlerChainProcessor processor = new HandlerChainProcessor(local_list, Protocol.soap11);
-
- processor.processChain(new MessageContext(), HandlerChainProcessor.Direction.IN, HandlerChainProcessor.MEP.REQUEST, false);
-
- assertEquals("L1m:L1c:", result);
- }
-
- /*
- * incoming request (we must be on the server), response expected
- * processing expected: Logical and SOAP, reverse order, no closing
- */
- public void testHandleMessage_true1() {
-
- // reset result
- result = "";
-
- // we want all good responses:
- soaphandler1_MessageResultDesired = ResultDesired.TRUE;
- soaphandler1_FaultResultDesired = ResultDesired.TRUE;
- soaphandler2_MessageResultDesired = ResultDesired.TRUE;
- soaphandler2_FaultResultDesired = ResultDesired.TRUE;
- logicalhandler1_MessageResultDesired = ResultDesired.TRUE;
- logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
- logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
- logicalhandler2_FaultResultDesired = ResultDesired.TRUE;
-
- HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
-
- processor.processChain(new MessageContext(), HandlerChainProcessor.Direction.IN, HandlerChainProcessor.MEP.REQUEST, true);
-
- assertEquals("S2m:S1m:L1m:L2m:", result);
-
- }
-
- /*
- * incoming request (we must be on the server), response NOT expected
- * processing expected: Logical and SOAP, reverse order, close
- */
- public void testHandleMessage_true2() {
-
- // reset result
- result = "";
-
- // we want all good responses:
- soaphandler1_MessageResultDesired = ResultDesired.TRUE;
- soaphandler1_FaultResultDesired = ResultDesired.TRUE;
- soaphandler2_MessageResultDesired = ResultDesired.TRUE;
- soaphandler2_FaultResultDesired = ResultDesired.TRUE;
- logicalhandler1_MessageResultDesired = ResultDesired.TRUE;
- logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
- logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
- logicalhandler2_FaultResultDesired = ResultDesired.TRUE;
-
- HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
-
- processor.processChain(new MessageContext(), HandlerChainProcessor.Direction.IN, HandlerChainProcessor.MEP.REQUEST, false);
-
- assertEquals("S2m:S1m:L1m:L2m:L2c:L1c:S1c:S2c:", result);
-
- }
-
- /*
- * incoming response (we must be on the client), response expected (ignored)
- * processing expected: Logical and SOAP, reverse order, close
- */
- public void testHandleMessage_true3() {
-
- // reset result
- result = "";
-
- // we want all good responses:
- soaphandler1_MessageResultDesired = ResultDesired.TRUE;
- soaphandler1_FaultResultDesired = ResultDesired.TRUE;
- soaphandler2_MessageResultDesired = ResultDesired.TRUE;
- soaphandler2_FaultResultDesired = ResultDesired.TRUE;
- logicalhandler1_MessageResultDesired = ResultDesired.TRUE;
- logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
- logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
- logicalhandler2_FaultResultDesired = ResultDesired.TRUE;
-
- HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
-
- processor.processChain(new MessageContext(), HandlerChainProcessor.Direction.IN, HandlerChainProcessor.MEP.RESPONSE, true);
-
- /*
- * since this is client inbound response, the original outbound invocation
- * would have been L2m:L1m:S1m:S2m, so the closes would be S2c:S1c:L1c:L2c
- */
-
- assertEquals("S2m:S1m:L1m:L2m:S2c:S1c:L1c:L2c:", result);
-
- }
-
- /*
- * outgoing request (we must be on the client), response expected
- * processing expected: Logical and SOAP, normal order, no closing
- */
- public void testHandleMessage_true4() {
-
- // reset result
- result = "";
-
- // we want all good responses:
- soaphandler1_MessageResultDesired = ResultDesired.TRUE;
- soaphandler1_FaultResultDesired = ResultDesired.TRUE;
- soaphandler2_MessageResultDesired = ResultDesired.TRUE;
- soaphandler2_FaultResultDesired = ResultDesired.TRUE;
- logicalhandler1_MessageResultDesired = ResultDesired.TRUE;
- logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
- logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
- logicalhandler2_FaultResultDesired = ResultDesired.TRUE;
-
- HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
-
- processor.processChain(new MessageContext(), HandlerChainProcessor.Direction.OUT, HandlerChainProcessor.MEP.REQUEST, true);
-
- assertEquals("L2m:L1m:S1m:S2m:", result);
- }
-
- /*
- * outgoing request (we must be on the client), response NOT expected
- * processing expected: Logical and SOAP, normal order, close
- */
- public void testHandleMessage_true5() {
-
- // reset result
- result = "";
-
- // we want all good responses:
- soaphandler1_MessageResultDesired = ResultDesired.TRUE;
- soaphandler1_FaultResultDesired = ResultDesired.TRUE;
- soaphandler2_MessageResultDesired = ResultDesired.TRUE;
- soaphandler2_FaultResultDesired = ResultDesired.TRUE;
- logicalhandler1_MessageResultDesired = ResultDesired.TRUE;
- logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
- logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
- logicalhandler2_FaultResultDesired = ResultDesired.TRUE;
-
- HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
-
- processor.processChain(new MessageContext(), HandlerChainProcessor.Direction.OUT, HandlerChainProcessor.MEP.REQUEST, false);
-
- assertEquals("L2m:L1m:S1m:S2m:S2c:S1c:L1c:L2c:", result);
- }
-
- /*
- * outgoing response (we must be on the server), response expected (ignored)
- * processing expected: Logical and SOAP, normal order, close
- */
- public void testHandleMessage_true6() {
-
- // reset result
- result = "";
-
- // we want all good responses:
- soaphandler1_MessageResultDesired = ResultDesired.TRUE;
- soaphandler1_FaultResultDesired = ResultDesired.TRUE;
- soaphandler2_MessageResultDesired = ResultDesired.TRUE;
- soaphandler2_FaultResultDesired = ResultDesired.TRUE;
- logicalhandler1_MessageResultDesired = ResultDesired.TRUE;
- logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
- logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
- logicalhandler2_FaultResultDesired = ResultDesired.TRUE;
-
- HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
-
- processor.processChain(new MessageContext(), HandlerChainProcessor.Direction.OUT, HandlerChainProcessor.MEP.RESPONSE, true);
-
- /*
- * since this is server outbound response, the original inbound invocation
- * would have been S2m:S1m:L1m:L2m, so the closes would be L2c:L1c:S1c:S2c
- */
-
- assertEquals("L2m:L1m:S1m:S2m:L2c:L1c:S1c:S2c:", result);
- }
-
- /*
- * At this point we know the sorting and closing logic is all good,
- * all that's left is to make sure the SOAP handlers are excluded when
- * we're in a LogicalMessageContext.
- *
- * outgoing response (we must be on the server), response expected (ignored)
- * processing expected: Logical only, normal order, close
- */
- public void testHandleMessage_true7() {
-
- // reset result
- result = "";
-
- // we want all good responses:
- soaphandler1_MessageResultDesired = ResultDesired.TRUE;
- soaphandler1_FaultResultDesired = ResultDesired.TRUE;
- soaphandler2_MessageResultDesired = ResultDesired.TRUE;
- soaphandler2_FaultResultDesired = ResultDesired.TRUE;
- logicalhandler1_MessageResultDesired = ResultDesired.TRUE;
- logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
- logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
- logicalhandler2_FaultResultDesired = ResultDesired.TRUE;
-
- HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
-
- processor.processChain(new MessageContext(), HandlerChainProcessor.Direction.OUT, HandlerChainProcessor.MEP.RESPONSE, true);
-
- /*
- * since this is server outbound response, the original invocation
- * would have been S2m:S1m:L1m:L2m, so the closes would be L2c:L1c:S1c:S2c
- */
-
- assertEquals("L2m:L1m:S1m:S2m:L2c:L1c:S1c:S2c:", result);
- }
-
- /*
- * incoming request (we must be on the server), response expected
- * a middle Handler.handleMessage returns false
- * processing expected: Logical and SOAP, reverse order, message reversed, close
- */
- public void testHandleMessage_false1() {
-
- // reset result
- result = "";
-
- // we want one false response:
- soaphandler1_MessageResultDesired = ResultDesired.TRUE;
- soaphandler1_FaultResultDesired = ResultDesired.TRUE;
- soaphandler2_MessageResultDesired = ResultDesired.TRUE;
- soaphandler2_FaultResultDesired = ResultDesired.TRUE;
- logicalhandler1_MessageResultDesired = ResultDesired.FALSE;
- logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
- logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
- logicalhandler2_FaultResultDesired = ResultDesired.TRUE;
-
- HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
- processor.processChain(new MessageContext(), HandlerChainProcessor.Direction.IN, HandlerChainProcessor.MEP.REQUEST, true);
-
- assertEquals("S2m:S1m:L1m:S1m:S2m:L1c:S1c:S2c:", result);
- }
-
- /*
- * outgoing request (we must be on the client), response expected
- * a middle Handler.handleMessage returns false
- * processing expected: Logical and SOAP, normal order, message reversed, close
- */
- public void testHandleMessage_false2() {
-
- // reset result
- result = "";
-
- // we want one false response:
- soaphandler1_MessageResultDesired = ResultDesired.TRUE;
- soaphandler1_FaultResultDesired = ResultDesired.TRUE;
- soaphandler2_MessageResultDesired = ResultDesired.TRUE;
- soaphandler2_FaultResultDesired = ResultDesired.TRUE;
- logicalhandler1_MessageResultDesired = ResultDesired.FALSE;
- logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
- logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
- logicalhandler2_FaultResultDesired = ResultDesired.TRUE;
-
- HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
- processor.processChain(new MessageContext(), HandlerChainProcessor.Direction.OUT, HandlerChainProcessor.MEP.REQUEST, true);
-
- assertEquals("L2m:L1m:L2m:L1c:L2c:", result);
- }
-
- /*
- * outgoing request (we must be on the client), response NOT expected
- * a middle Handler.handleMessage returns false
- * processing expected: Logical and SOAP, normal order, message NOT reversed, close
- */
- public void testHandleMessage_false3() {
-
- // reset result
- result = "";
-
- // we want one false response:
- soaphandler1_MessageResultDesired = ResultDesired.TRUE;
- soaphandler1_FaultResultDesired = ResultDesired.TRUE;
- soaphandler2_MessageResultDesired = ResultDesired.TRUE;
- soaphandler2_FaultResultDesired = ResultDesired.TRUE;
- logicalhandler1_MessageResultDesired = ResultDesired.FALSE;
- logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
- logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
- logicalhandler2_FaultResultDesired = ResultDesired.TRUE;
-
- HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
- processor.processChain(new MessageContext(), HandlerChainProcessor.Direction.OUT, HandlerChainProcessor.MEP.REQUEST, false);
-
- assertEquals("L2m:L1m:L1c:L2c:", result);
- }
-
- /*
- * incoming request (we must be on the server), response expected
- * a middle Handler.handleMessage throws ProtocolException
- * processing expected: Logical and SOAP, reverse order, message reversed, handleFault, close
- */
- public void testHandleMessage_protocolex_true1() {
-
- // reset result
- result = "";
-
- // we want one false response:
- soaphandler1_MessageResultDesired = ResultDesired.TRUE;
- soaphandler1_FaultResultDesired = ResultDesired.TRUE;
- soaphandler2_MessageResultDesired = ResultDesired.TRUE;
- soaphandler2_FaultResultDesired = ResultDesired.TRUE;
- logicalhandler1_MessageResultDesired = ResultDesired.PROTOCOL_EXCEPTION;
- logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
- logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
- logicalhandler2_FaultResultDesired = ResultDesired.TRUE;
-
- HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
- processor.processChain(new MessageContext(), HandlerChainProcessor.Direction.IN, HandlerChainProcessor.MEP.REQUEST, true);
-
- // handleFault processing
- assertEquals("S2m:S1m:L1m:S1f:S2f:L1c:S1c:S2c:", result);
- }
-
- /*
- * incoming request (we must be on the server), response NOT expected
- * a middle Handler.handleMessage throws ProtocolException
- * processing expected: Logical and SOAP, reverse order, message NOT reversed, close
- */
- public void testHandleMessage_protocolex_true2() {
-
- // reset result
- result = "";
-
- // we want one false response:
- soaphandler1_MessageResultDesired = ResultDesired.TRUE;
- soaphandler1_FaultResultDesired = ResultDesired.TRUE;
- soaphandler2_MessageResultDesired = ResultDesired.TRUE;
- soaphandler2_FaultResultDesired = ResultDesired.TRUE;
- logicalhandler1_MessageResultDesired = ResultDesired.PROTOCOL_EXCEPTION;
- logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
- logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
- logicalhandler2_FaultResultDesired = ResultDesired.TRUE;
-
- HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
- processor.processChain(new MessageContext(), HandlerChainProcessor.Direction.IN, HandlerChainProcessor.MEP.REQUEST, false);
-
- // no handleFault calls
- assertEquals("S2m:S1m:L1m:L1c:S1c:S2c:", result);
- }
-
- /*
- * incoming request (we must be on the server), response expected
- * a middle Handler.handleMessage throws RuntimeException
- * processing expected: Logical and SOAP, reverse order, message reversed, (no handleFault), close
- */
- public void testHandleMessage_runtimeex_true() {
-
- // reset result
- result = "";
-
- // we want one false response:
- soaphandler1_MessageResultDesired = ResultDesired.TRUE;
- soaphandler1_FaultResultDesired = ResultDesired.TRUE;
- soaphandler2_MessageResultDesired = ResultDesired.TRUE;
- soaphandler2_FaultResultDesired = ResultDesired.TRUE;
- logicalhandler1_MessageResultDesired = ResultDesired.OTHER_EXCEPTION;
- logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
- logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
- logicalhandler2_FaultResultDesired = ResultDesired.TRUE;
-
- HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
- Exception e = null;
- try {
- processor.processChain(new MessageContext(), HandlerChainProcessor.Direction.IN, HandlerChainProcessor.MEP.REQUEST, true);
- } catch (RuntimeException re) {
- e = re;
- }
-
- assertNotNull(e);
- // no handleFault calls
- assertEquals("S2m:S1m:L1m:L1c:S1c:S2c:", result);
- }
-
- /*
- * incoming request (we must be on the server), response expected
- * a middle Handler.handleMessage throws ProtocolException, later a Handler.handleFault returns false
- * processing expected: Logical and SOAP, reverse order, message reversed, handleFault, close
- */
- public void testHandleMessage_protocolex_false() {
-
- // reset result
- result = "";
-
- // we want one false response:
- soaphandler1_MessageResultDesired = ResultDesired.TRUE;
- soaphandler1_FaultResultDesired = ResultDesired.FALSE;
- soaphandler2_MessageResultDesired = ResultDesired.TRUE;
- soaphandler2_FaultResultDesired = ResultDesired.TRUE;
- logicalhandler1_MessageResultDesired = ResultDesired.PROTOCOL_EXCEPTION;
- logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
- logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
- logicalhandler2_FaultResultDesired = ResultDesired.TRUE;
-
- HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
- processor.processChain(new MessageContext(), HandlerChainProcessor.Direction.IN, HandlerChainProcessor.MEP.REQUEST, true);
-
- // handleFault processing, but notice S2f does not get called
- assertEquals("S2m:S1m:L1m:S1f:L1c:S1c:S2c:", result);
- }
-
- /*
- * incoming request (we must be on the server), response expected
- * a middle Handler.handleMessage throws ProtocolException, later a Handler.handleFault throws ProtocolException
- * processing expected: Logical and SOAP, reverse order, message reversed, handleFault, close
- */
- public void testHandleMessage_protocolex_protocolex() {
-
- // reset result
- result = "";
-
- // we want one false response:
- soaphandler1_MessageResultDesired = ResultDesired.TRUE;
- soaphandler1_FaultResultDesired = ResultDesired.PROTOCOL_EXCEPTION;
- soaphandler2_MessageResultDesired = ResultDesired.TRUE;
- soaphandler2_FaultResultDesired = ResultDesired.TRUE;
- logicalhandler1_MessageResultDesired = ResultDesired.PROTOCOL_EXCEPTION;
- logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
- logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
- logicalhandler2_FaultResultDesired = ResultDesired.TRUE;
-
- HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
- Exception e = null;
- try {
- // handleFault processing, but notice S2f does not get called, and we get an exception
- processor.processChain(new MessageContext(), HandlerChainProcessor.Direction.IN, HandlerChainProcessor.MEP.REQUEST, true);
- } catch (ProtocolException pe) {
- e = pe;
- }
-
- assertNotNull(e);
- assertEquals("S2m:S1m:L1m:S1f:L1c:S1c:S2c:", result);
- }
-
- /*
- * incoming request (we must be on the server), response expected
- * a middle Handler.handleMessage throws ProtocolException, later a Handler.handleFault throws ProtocolException
- * processing expected: Logical and SOAP, reverse order, handleFault, close
- */
- public void testHandleMessage_protocolex_runtimeex() {
-
- // reset result
- result = "";
-
- // we want one false response:
- soaphandler1_MessageResultDesired = ResultDesired.TRUE;
- soaphandler1_FaultResultDesired = ResultDesired.OTHER_EXCEPTION;
- soaphandler2_MessageResultDesired = ResultDesired.TRUE;
- soaphandler2_FaultResultDesired = ResultDesired.TRUE;
- logicalhandler1_MessageResultDesired = ResultDesired.PROTOCOL_EXCEPTION;
- logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
- logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
- logicalhandler2_FaultResultDesired = ResultDesired.TRUE;
-
- HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
- Exception e = null;
- try {
- // same results as testHandlers_protocolex_protocolex
- processor.processChain(new MessageContext(), HandlerChainProcessor.Direction.IN, HandlerChainProcessor.MEP.REQUEST, true);
- } catch (RuntimeException pe) {
- e = pe;
- }
-
- assertNotNull(e);
- assertEquals("S2m:S1m:L1m:S1f:L1c:S1c:S2c:", result);
- }
-
-
- /*
- * empty list
- */
- public void testHandleFault_empty1() {
-
- Exception local_exception = null;
-
- HandlerChainProcessor processor1 = new HandlerChainProcessor(null, Protocol.soap11);
- HandlerChainProcessor processor2 = new HandlerChainProcessor(new ArrayList<Handler>(), Protocol.soap11);
- try {
- processor1.processFault(new MessageContext(), HandlerChainProcessor.Direction.IN);
- processor2.processFault(new MessageContext(), HandlerChainProcessor.Direction.IN);
- } catch (Exception e) {
- local_exception = e;
- }
-
- // no exceptions!
- assertNull(local_exception);
- }
-
-
- /*
- * outgoing response (we must be on the server), response expected (ignored)
- * processing expected: Logical and SOAP, normal order, handleFault, close
- */
- public void testHandleFault_true1() {
-
- // reset result
- result = "";
-
- // we want one false response:
- soaphandler1_MessageResultDesired = ResultDesired.TRUE;
- soaphandler1_FaultResultDesired = ResultDesired.TRUE;
- soaphandler2_MessageResultDesired = ResultDesired.TRUE;
- soaphandler2_FaultResultDesired = ResultDesired.TRUE;
- logicalhandler1_MessageResultDesired = ResultDesired.TRUE;
- logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
- logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
- logicalhandler2_FaultResultDesired = ResultDesired.TRUE;
-
- HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
-
- processor.processFault(new MessageContext(), HandlerChainProcessor.Direction.OUT);
-
- assertEquals("L2f:L1f:S1f:S2f:S2c:S1c:L1c:L2c:", result);
- }
-
- /*
- * outgoing response (we must be on the server)
- * a middle Handler.handleFault returns false
- * processing expected: Logical and SOAP, normal order, handleFault, close (all)
- */
- public void testHandleFault_false1() {
-
- // reset result
- result = "";
-
- // we want one false response:
- soaphandler1_MessageResultDesired = ResultDesired.TRUE;
- soaphandler1_FaultResultDesired = ResultDesired.TRUE;
- soaphandler2_MessageResultDesired = ResultDesired.TRUE;
- soaphandler2_FaultResultDesired = ResultDesired.TRUE;
- logicalhandler1_MessageResultDesired = ResultDesired.TRUE;
- logicalhandler1_FaultResultDesired = ResultDesired.FALSE;
- logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
- logicalhandler2_FaultResultDesired = ResultDesired.TRUE;
-
- HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
-
- processor.processFault(new MessageContext(), HandlerChainProcessor.Direction.OUT);
-
- // notice all handlers are closed in this scenario
- assertEquals("L2f:L1f:S2c:S1c:L1c:L2c:", result);
- }
-
- /*
- * incoming response (we must be on the client)
- * a middle Handler.handleFault throws ProtocolException
- * processing expected: Logical and SOAP, reverse order, handleFault, close (all)
- */
- public void testHandleFault_protocolex() {
-
- // reset result
- result = "";
-
- // we want one false response:
- soaphandler1_MessageResultDesired = ResultDesired.TRUE;
- soaphandler1_FaultResultDesired = ResultDesired.TRUE;
- soaphandler2_MessageResultDesired = ResultDesired.TRUE;
- soaphandler2_FaultResultDesired = ResultDesired.TRUE;
- logicalhandler1_MessageResultDesired = ResultDesired.TRUE;
- logicalhandler1_FaultResultDesired = ResultDesired.PROTOCOL_EXCEPTION;
- logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
- logicalhandler2_FaultResultDesired = ResultDesired.TRUE;
-
- HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
-
- Exception e = null;
- try {
- // notice all handlers are closed in this scenario, and we get an exception
- processor.processFault(new MessageContext(), HandlerChainProcessor.Direction.IN);
- } catch (ProtocolException pe) {
- e = pe;
- }
-
- assertNotNull(e);
- assertEquals("S2f:S1f:L1f:L2c:L1c:S1c:S2c:", result);
- }
-
-
-
- private class SOAPHandler1 implements SOAPHandler<SOAPMessageContext> {
-
- public Set getHeaders() {
- return null;
- }
-
- public void close(javax.xml.ws.handler.MessageContext messagecontext) {
- result = result.concat("S1c:");
- }
-
- public boolean handleFault(SOAPMessageContext messagecontext) {
- result = result.concat("S1f:");
- if (soaphandler1_FaultResultDesired == ResultDesired.TRUE)
- return true;
- else if (soaphandler1_FaultResultDesired == ResultDesired.FALSE)
- return false;
- else if (soaphandler1_FaultResultDesired == ResultDesired.PROTOCOL_EXCEPTION)
- throw new ProtocolException();
- else if (soaphandler1_FaultResultDesired == ResultDesired.OTHER_EXCEPTION)
- throw new RuntimeException();
-
- // default
- return true;
- }
-
- public boolean handleMessage(SOAPMessageContext messagecontext) {
- result = result.concat("S1m:");
- if (soaphandler1_MessageResultDesired == ResultDesired.TRUE)
- return true;
- else if (soaphandler1_MessageResultDesired == ResultDesired.FALSE)
- return false;
- else if (soaphandler1_MessageResultDesired == ResultDesired.PROTOCOL_EXCEPTION)
- throw new ProtocolException();
- else if (soaphandler1_MessageResultDesired == ResultDesired.OTHER_EXCEPTION)
- throw new RuntimeException();
-
- // default
- return true;
- }
-
- }
-
-
- private class SOAPHandler2 implements SOAPHandler<SOAPMessageContext> {
-
- public Set getHeaders() {
- return null;
- }
-
- public void close(javax.xml.ws.handler.MessageContext messagecontext) {
- result = result.concat("S2c:");
- }
-
- public boolean handleFault(SOAPMessageContext messagecontext) {
- result = result.concat("S2f:");
- if (soaphandler2_FaultResultDesired == ResultDesired.TRUE)
- return true;
- else if (soaphandler2_FaultResultDesired == ResultDesired.FALSE)
- return false;
- else if (soaphandler2_FaultResultDesired == ResultDesired.PROTOCOL_EXCEPTION)
- throw new ProtocolException();
- else if (soaphandler2_FaultResultDesired == ResultDesired.OTHER_EXCEPTION)
- throw new RuntimeException();
-
- // default
- return true;
- }
-
- public boolean handleMessage(SOAPMessageContext messagecontext) {
- result = result.concat("S2m:");
- if (soaphandler2_MessageResultDesired == ResultDesired.TRUE)
- return true;
- else if (soaphandler2_MessageResultDesired == ResultDesired.FALSE)
- return false;
- else if (soaphandler2_MessageResultDesired == ResultDesired.PROTOCOL_EXCEPTION)
- throw new ProtocolException();
- else if (soaphandler2_MessageResultDesired == ResultDesired.OTHER_EXCEPTION)
- throw new RuntimeException();
-
- // default
- return true;
- }
-
- }
-
-
- private class LogicalHandler1 implements LogicalHandler<LogicalMessageContext> {
-
- public void close(javax.xml.ws.handler.MessageContext messagecontext) {
- result = result.concat("L1c:");
- }
-
- public boolean handleFault(LogicalMessageContext messagecontext) {
- result = result.concat("L1f:");
- if (logicalhandler1_FaultResultDesired == ResultDesired.TRUE)
- return true;
- else if (logicalhandler1_FaultResultDesired == ResultDesired.FALSE)
- return false;
- else if (logicalhandler1_FaultResultDesired == ResultDesired.PROTOCOL_EXCEPTION)
- throw new ProtocolException();
- else if (logicalhandler1_FaultResultDesired == ResultDesired.OTHER_EXCEPTION)
- throw new RuntimeException();
-
- // default
- return true;
- }
-
- public boolean handleMessage(LogicalMessageContext messagecontext) {
- result = result.concat("L1m:");
- if (logicalhandler1_MessageResultDesired == ResultDesired.TRUE)
- return true;
- else if (logicalhandler1_MessageResultDesired == ResultDesired.FALSE)
- return false;
- else if (logicalhandler1_MessageResultDesired == ResultDesired.PROTOCOL_EXCEPTION)
- throw new ProtocolException();
- else if (logicalhandler1_MessageResultDesired == ResultDesired.OTHER_EXCEPTION)
- throw new RuntimeException();
-
- // default
- return true;
- }
-
- }
-
-
- private class LogicalHandler2 implements LogicalHandler<LogicalMessageContext> {
-
- public void close(javax.xml.ws.handler.MessageContext messagecontext) {
- result = result.concat("L2c:");
- }
-
- public boolean handleFault(LogicalMessageContext messagecontext) {
- result = result.concat("L2f:");
- if (logicalhandler2_FaultResultDesired == ResultDesired.TRUE)
- return true;
- else if (logicalhandler2_FaultResultDesired == ResultDesired.FALSE)
- return false;
- else if (logicalhandler2_FaultResultDesired == ResultDesired.PROTOCOL_EXCEPTION)
- throw new ProtocolException();
- else if (logicalhandler2_FaultResultDesired == ResultDesired.OTHER_EXCEPTION)
- throw new RuntimeException();
-
- // default
- return true;
- }
-
- public boolean handleMessage(LogicalMessageContext messagecontext) {
- result = result.concat("L2m:");
- if (logicalhandler2_MessageResultDesired == ResultDesired.TRUE)
- return true;
- else if (logicalhandler2_MessageResultDesired == ResultDesired.FALSE)
- return false;
- else if (logicalhandler2_MessageResultDesired == ResultDesired.PROTOCOL_EXCEPTION)
- throw new ProtocolException();
- else if (logicalhandler2_MessageResultDesired == ResultDesired.OTHER_EXCEPTION)
- throw new RuntimeException();
-
- // default
- return true;
- }
-
- }
+ // String result is how we'll verify the right methods from
+ // the Handler implementations were called
+ private String result = new String();
+
+ private enum ResultDesired {
+ TRUE, FALSE, PROTOCOL_EXCEPTION, OTHER_EXCEPTION
+ };
+
+ // use the following to dictate how the Handler methods behave
+ private ResultDesired soaphandler1_MessageResultDesired;
+ private ResultDesired soaphandler1_FaultResultDesired;
+ private ResultDesired soaphandler2_MessageResultDesired;
+ private ResultDesired soaphandler2_FaultResultDesired;
+ private ResultDesired logicalhandler1_MessageResultDesired;
+ private ResultDesired logicalhandler1_FaultResultDesired;
+ private ResultDesired logicalhandler2_MessageResultDesired;
+ private ResultDesired logicalhandler2_FaultResultDesired;
+
+ ArrayList<Handler> handlers = new ArrayList<Handler>();
+
+ @Override
+ protected void setUp() throws Exception {
+ // HandlerChainProcessor expects a sorted chain
+ handlers.add(new LogicalHandler2());
+ handlers.add(new LogicalHandler1());
+ handlers.add(new SOAPHandler1());
+ handlers.add(new SOAPHandler2());
+ }
+
+ /*
+ * empty list
+ */
+ public void testHandleMessage_empty1() {
+
+ Exception local_exception = null;
+
+ HandlerChainProcessor processor1 = new HandlerChainProcessor(null, Protocol.soap11);
+ HandlerChainProcessor processor2 =
+ new HandlerChainProcessor(new ArrayList<Handler>(), Protocol.soap11);
+ try {
+ MessageContext mc1 = new MessageContext();
+ mc1.setMEPContext(new MEPContext(mc1));
+ processor1.processChain(mc1.getMEPContext(),
+ HandlerChainProcessor.Direction.IN,
+ HandlerChainProcessor.MEP.REQUEST,
+ true);
+ MessageContext mc2 = new MessageContext();
+ mc2.setMEPContext(new MEPContext(mc2));
+ processor2.processChain(mc2.getMEPContext(),
+ HandlerChainProcessor.Direction.IN,
+ HandlerChainProcessor.MEP.REQUEST,
+ true);
+ } catch (Exception e) {
+ local_exception = e;
+ }
+
+ // no exceptions!
+ assertNull(local_exception);
+ }
+
+ /*
+ * one protocol handler
+ * processing expected: Logical and SOAP, reverse order, close
+ */
+ public void testHandleMessage_oneproto1() {
+
+ // reset result
+ result = "";
+
+ // use a local list
+ ArrayList<Handler> local_list = new ArrayList<Handler>();
+ local_list.add(new SOAPHandler1());
+
+ // we want all good responses:
+ soaphandler1_MessageResultDesired = ResultDesired.TRUE;
+ soaphandler1_FaultResultDesired = ResultDesired.TRUE;
+
+ HandlerChainProcessor processor = new HandlerChainProcessor(local_list, Protocol.soap11);
+ MessageContext mc1 = new MessageContext();
+ mc1.setMEPContext(new MEPContext(mc1));
+ processor.processChain(mc1.getMEPContext(),
+ HandlerChainProcessor.Direction.IN,
+ HandlerChainProcessor.MEP.REQUEST,
+ false);
+
+ assertEquals("S1m:S1c:", result);
+
+ }
+
+ /*
+ * one protocol handler in a logical context
+ * no handlers will be processed
+ */
+ public void testHandleMessage_oneproto2() {
+
+ // reset result
+ result = "";
+
+ // use a local list
+ ArrayList<Handler> local_list = new ArrayList<Handler>();
+ local_list.add(new SOAPHandler1());
+
+ // we want all good responses:
+ soaphandler1_MessageResultDesired = ResultDesired.TRUE;
+ soaphandler1_FaultResultDesired = ResultDesired.TRUE;
+
+ HandlerChainProcessor processor = new HandlerChainProcessor(local_list, Protocol.soap11);
+ MessageContext mc1 = new MessageContext();
+ mc1.setMEPContext(new MEPContext(mc1));
+ processor.processChain(mc1.getMEPContext(),
+ HandlerChainProcessor.Direction.IN,
+ HandlerChainProcessor.MEP.REQUEST,
+ false);
+
+ assertEquals("S1m:S1c:", result);
+ }
+
+ /*
+ * one logical handler
+ * processing expected: Logical and SOAP, reverse order, close
+ */
+ public void testHandleMessage_onelogical() {
+
+ // reset result
+ result = "";
+
+ // use a local list
+ ArrayList<Handler> local_list = new ArrayList<Handler>();
+ local_list.add(new LogicalHandler1());
+
+ // we want all good responses:
+ logicalhandler1_MessageResultDesired = ResultDesired.TRUE;
+ logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
+
+ HandlerChainProcessor processor = new HandlerChainProcessor(local_list, Protocol.soap11);
+ MessageContext mc1 = new MessageContext();
+ mc1.setMEPContext(new MEPContext(mc1));
+ processor.processChain(mc1.getMEPContext(),
+ HandlerChainProcessor.Direction.IN,
+ HandlerChainProcessor.MEP.REQUEST,
+ false);
+
+ assertEquals("L1m:L1c:", result);
+ }
+
+ /*
+ * incoming request (we must be on the server), response expected
+ * processing expected: Logical and SOAP, reverse order, no closing
+ */
+ public void testHandleMessage_true1() {
+
+ // reset result
+ result = "";
+
+ // we want all good responses:
+ soaphandler1_MessageResultDesired = ResultDesired.TRUE;
+ soaphandler1_FaultResultDesired = ResultDesired.TRUE;
+ soaphandler2_MessageResultDesired = ResultDesired.TRUE;
+ soaphandler2_FaultResultDesired = ResultDesired.TRUE;
+ logicalhandler1_MessageResultDesired = ResultDesired.TRUE;
+ logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
+ logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
+ logicalhandler2_FaultResultDesired = ResultDesired.TRUE;
+
+ HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
+ MessageContext mc1 = new MessageContext();
+ mc1.setMEPContext(new MEPContext(mc1));
+ processor.processChain(mc1.getMEPContext(),
+ HandlerChainProcessor.Direction.IN,
+ HandlerChainProcessor.MEP.REQUEST,
+ true);
+
+ assertEquals("S2m:S1m:L1m:L2m:", result);
+
+ }
+
+ /*
+ * incoming request (we must be on the server), response NOT expected
+ * processing expected: Logical and SOAP, reverse order, close
+ */
+ public void testHandleMessage_true2() {
+
+ // reset result
+ result = "";
+
+ // we want all good responses:
+ soaphandler1_MessageResultDesired = ResultDesired.TRUE;
+ soaphandler1_FaultResultDesired = ResultDesired.TRUE;
+ soaphandler2_MessageResultDesired = ResultDesired.TRUE;
+ soaphandler2_FaultResultDesired = ResultDesired.TRUE;
+ logicalhandler1_MessageResultDesired = ResultDesired.TRUE;
+ logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
+ logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
+ logicalhandler2_FaultResultDesired = ResultDesired.TRUE;
+
+ HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
+ MessageContext mc1 = new MessageContext();
+ mc1.setMEPContext(new MEPContext(mc1));
+ processor.processChain(mc1.getMEPContext(),
+ HandlerChainProcessor.Direction.IN,
+ HandlerChainProcessor.MEP.REQUEST,
+ false);
+
+ assertEquals("S2m:S1m:L1m:L2m:L2c:L1c:S1c:S2c:", result);
+
+ }
+
+ /*
+ * incoming response (we must be on the client), response expected (ignored)
+ * processing expected: Logical and SOAP, reverse order, close
+ */
+ public void testHandleMessage_true3() {
+
+ // reset result
+ result = "";
+
+ // we want all good responses:
+ soaphandler1_MessageResultDesired = ResultDesired.TRUE;
+ soaphandler1_FaultResultDesired = ResultDesired.TRUE;
+ soaphandler2_MessageResultDesired = ResultDesired.TRUE;
+ soaphandler2_FaultResultDesired = ResultDesired.TRUE;
+ logicalhandler1_MessageResultDesired = ResultDesired.TRUE;
+ logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
+ logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
+ logicalhandler2_FaultResultDesired = ResultDesired.TRUE;
+
+ HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
+ MessageContext mc1 = new MessageContext();
+ mc1.setMEPContext(new MEPContext(mc1));
+ processor.processChain(mc1.getMEPContext(),
+ HandlerChainProcessor.Direction.IN,
+ HandlerChainProcessor.MEP.RESPONSE,
+ true);
+
+ /*
+ * since this is client inbound response, the original outbound invocation
+ * would have been L2m:L1m:S1m:S2m, so the closes would be S2c:S1c:L1c:L2c
+ */
+
+ assertEquals("S2m:S1m:L1m:L2m:S2c:S1c:L1c:L2c:", result);
+
+ }
+
+ /*
+ * outgoing request (we must be on the client), response expected
+ * processing expected: Logical and SOAP, normal order, no closing
+ */
+ public void testHandleMessage_true4() {
+
+ // reset result
+ result = "";
+
+ // we want all good responses:
+ soaphandler1_MessageResultDesired = ResultDesired.TRUE;
+ soaphandler1_FaultResultDesired = ResultDesired.TRUE;
+ soaphandler2_MessageResultDesired = ResultDesired.TRUE;
+ soaphandler2_FaultResultDesired = ResultDesired.TRUE;
+ logicalhandler1_MessageResultDesired = ResultDesired.TRUE;
+ logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
+ logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
+ logicalhandler2_FaultResultDesired = ResultDesired.TRUE;
+
+ HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
+ MessageContext mc1 = new MessageContext();
+ mc1.setMEPContext(new MEPContext(mc1));
+ processor.processChain(mc1.getMEPContext(),
+ HandlerChainProcessor.Direction.OUT,
+ HandlerChainProcessor.MEP.REQUEST,
+ true);
+
+ assertEquals("L2m:L1m:S1m:S2m:", result);
+ }
+
+ /*
+ * outgoing request (we must be on the client), response NOT expected
+ * processing expected: Logical and SOAP, normal order, close
+ */
+ public void testHandleMessage_true5() {
+
+ // reset result
+ result = "";
+
+ // we want all good responses:
+ soaphandler1_MessageResultDesired = ResultDesired.TRUE;
+ soaphandler1_FaultResultDesired = ResultDesired.TRUE;
+ soaphandler2_MessageResultDesired = ResultDesired.TRUE;
+ soaphandler2_FaultResultDesired = ResultDesired.TRUE;
+ logicalhandler1_MessageResultDesired = ResultDesired.TRUE;
+ logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
+ logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
+ logicalhandler2_FaultResultDesired = ResultDesired.TRUE;
+
+ HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
+ MessageContext mc1 = new MessageContext();
+ mc1.setMEPContext(new MEPContext(mc1));
+ processor.processChain(mc1.getMEPContext(),
+ HandlerChainProcessor.Direction.OUT,
+ HandlerChainProcessor.MEP.REQUEST,
+ false);
+
+ assertEquals("L2m:L1m:S1m:S2m:S2c:S1c:L1c:L2c:", result);
+ }
+
+ /*
+ * outgoing response (we must be on the server), response expected (ignored)
+ * processing expected: Logical and SOAP, normal order, close
+ */
+ public void testHandleMessage_true6() {
+
+ // reset result
+ result = "";
+
+ // we want all good responses:
+ soaphandler1_MessageResultDesired = ResultDesired.TRUE;
+ soaphandler1_FaultResultDesired = ResultDesired.TRUE;
+ soaphandler2_MessageResultDesired = ResultDesired.TRUE;
+ soaphandler2_FaultResultDesired = ResultDesired.TRUE;
+ logicalhandler1_MessageResultDesired = ResultDesired.TRUE;
+ logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
+ logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
+ logicalhandler2_FaultResultDesired = ResultDesired.TRUE;
+
+ HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
+ MessageContext mc1 = new MessageContext();
+ mc1.setMEPContext(new MEPContext(mc1));
+ processor.processChain(mc1.getMEPContext(),
+ HandlerChainProcessor.Direction.OUT,
+ HandlerChainProcessor.MEP.RESPONSE,
+ true);
+
+ /*
+ * since this is server outbound response, the original inbound invocation
+ * would have been S2m:S1m:L1m:L2m, so the closes would be L2c:L1c:S1c:S2c
+ */
+
+ assertEquals("L2m:L1m:S1m:S2m:L2c:L1c:S1c:S2c:", result);
+ }
+
+ /*
+ * At this point we know the sorting and closing logic is all good,
+ * all that's left is to make sure the SOAP handlers are excluded when
+ * we're in a LogicalMessageContext.
+ *
+ * outgoing response (we must be on the server), response expected (ignored)
+ * processing expected: Logical only, normal order, close
+ */
+ public void testHandleMessage_true7() {
+
+ // reset result
+ result = "";
+
+ // we want all good responses:
+ soaphandler1_MessageResultDesired = ResultDesired.TRUE;
+ soaphandler1_FaultResultDesired = ResultDesired.TRUE;
+ soaphandler2_MessageResultDesired = ResultDesired.TRUE;
+ soaphandler2_FaultResultDesired = ResultDesired.TRUE;
+ logicalhandler1_MessageResultDesired = ResultDesired.TRUE;
+ logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
+ logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
+ logicalhandler2_FaultResultDesired = ResultDesired.TRUE;
+
+ HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
+ MessageContext mc1 = new MessageContext();
+ mc1.setMEPContext(new MEPContext(mc1));
+ processor.processChain(mc1.getMEPContext(),
+ HandlerChainProcessor.Direction.OUT,
+ HandlerChainProcessor.MEP.RESPONSE,
+ true);
+
+ /*
+ * since this is server outbound response, the original invocation
+ * would have been S2m:S1m:L1m:L2m, so the closes would be L2c:L1c:S1c:S2c
+ */
+
+ assertEquals("L2m:L1m:S1m:S2m:L2c:L1c:S1c:S2c:", result);
+ }
+
+ /*
+ * incoming request (we must be on the server), response expected
+ * a middle Handler.handleMessage returns false
+ * processing expected: Logical and SOAP, reverse order, message reversed, close
+ */
+ public void testHandleMessage_false1() {
+
+ // reset result
+ result = "";
+
+ // we want one false response:
+ soaphandler1_MessageResultDesired = ResultDesired.TRUE;
+ soaphandler1_FaultResultDesired = ResultDesired.TRUE;
+ soaphandler2_MessageResultDesired = ResultDesired.TRUE;
+ soaphandler2_FaultResultDesired = ResultDesired.TRUE;
+ logicalhandler1_MessageResultDesired = ResultDesired.FALSE;
+ logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
+ logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
+ logicalhandler2_FaultResultDesired = ResultDesired.TRUE;
+
+ HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
+ MessageContext mc1 = new MessageContext();
+ mc1.setMEPContext(new MEPContext(mc1));
+ processor.processChain(mc1.getMEPContext(),
+ HandlerChainProcessor.Direction.IN,
+ HandlerChainProcessor.MEP.REQUEST,
+ true);
+
+ assertEquals("S2m:S1m:L1m:S1m:S2m:L1c:S1c:S2c:", result);
+ }
+
+ /*
+ * outgoing request (we must be on the client), response expected
+ * a middle Handler.handleMessage returns false
+ * processing expected: Logical and SOAP, normal order, message reversed, close
+ */
+ public void testHandleMessage_false2() {
+
+ // reset result
+ result = "";
+
+ // we want one false response:
+ soaphandler1_MessageResultDesired = ResultDesired.TRUE;
+ soaphandler1_FaultResultDesired = ResultDesired.TRUE;
+ soaphandler2_MessageResultDesired = ResultDesired.TRUE;
+ soaphandler2_FaultResultDesired = ResultDesired.TRUE;
+ logicalhandler1_MessageResultDesired = ResultDesired.FALSE;
+ logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
+ logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
+ logicalhandler2_FaultResultDesired = ResultDesired.TRUE;
+
+ HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
+ MessageContext mc1 = new MessageContext();
+ mc1.setMEPContext(new MEPContext(mc1));
+ processor.processChain(mc1.getMEPContext(),
+ HandlerChainProcessor.Direction.OUT,
+ HandlerChainProcessor.MEP.REQUEST,
+ true);
+
+ assertEquals("L2m:L1m:L2m:L1c:L2c:", result);
+ }
+
+ /*
+ * outgoing request (we must be on the client), response NOT expected
+ * a middle Handler.handleMessage returns false
+ * processing expected: Logical and SOAP, normal order, message NOT reversed, close
+ */
+ public void testHandleMessage_false3() {
+
+ // reset result
+ result = "";
+
+ // we want one false response:
+ soaphandler1_MessageResultDesired = ResultDesired.TRUE;
+ soaphandler1_FaultResultDesired = ResultDesired.TRUE;
+ soaphandler2_MessageResultDesired = ResultDesired.TRUE;
+ soaphandler2_FaultResultDesired = ResultDesired.TRUE;
+ logicalhandler1_MessageResultDesired = ResultDesired.FALSE;
+ logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
+ logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
+ logicalhandler2_FaultResultDesired = ResultDesired.TRUE;
+
+ HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
+ MessageContext mc1 = new MessageContext();
+ mc1.setMEPContext(new MEPContext(mc1));
+ processor.processChain(mc1.getMEPContext(),
+ HandlerChainProcessor.Direction.OUT,
+ HandlerChainProcessor.MEP.REQUEST,
+ false);
+
+ assertEquals("L2m:L1m:L1c:L2c:", result);
+ }
+
+ /*
+ * incoming request (we must be on the server), response expected
+ * a middle Handler.handleMessage throws ProtocolException
+ * processing expected: Logical and SOAP, reverse order, message reversed, handleFault, close
+ */
+ public void testHandleMessage_protocolex_true1() {
+
+ // reset result
+ result = "";
+
+ // we want one false response:
+ soaphandler1_MessageResultDesired = ResultDesired.TRUE;
+ soaphandler1_FaultResultDesired = ResultDesired.TRUE;
+ soaphandler2_MessageResultDesired = ResultDesired.TRUE;
+ soaphandler2_FaultResultDesired = ResultDesired.TRUE;
+ logicalhandler1_MessageResultDesired = ResultDesired.PROTOCOL_EXCEPTION;
+ logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
+ logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
+ logicalhandler2_FaultResultDesired = ResultDesired.TRUE;
+
+ HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
+ MessageContext mc1 = new MessageContext();
+ mc1.setMEPContext(new MEPContext(mc1));
+ processor.processChain(mc1.getMEPContext(),
+ HandlerChainProcessor.Direction.IN,
+ HandlerChainProcessor.MEP.REQUEST,
+ true);
+
+ // handleFault processing
+ assertEquals("S2m:S1m:L1m:S1f:S2f:L1c:S1c:S2c:", result);
+ }
+
+ /*
+ * incoming request (we must be on the server), response NOT expected
+ * a middle Handler.handleMessage throws ProtocolException
+ * processing expected: Logical and SOAP, reverse order, message NOT reversed, close
+ */
+ public void testHandleMessage_protocolex_true2() {
+
+ // reset result
+ result = "";
+
+ // we want one false response:
+ soaphandler1_MessageResultDesired = ResultDesired.TRUE;
+ soaphandler1_FaultResultDesired = ResultDesired.TRUE;
+ soaphandler2_MessageResultDesired = ResultDesired.TRUE;
+ soaphandler2_FaultResultDesired = ResultDesired.TRUE;
+ logicalhandler1_MessageResultDesired = ResultDesired.PROTOCOL_EXCEPTION;
+ logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
+ logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
+ logicalhandler2_FaultResultDesired = ResultDesired.TRUE;
+
+ HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
+ MessageContext mc1 = new MessageContext();
+ mc1.setMEPContext(new MEPContext(mc1));
+ processor.processChain(mc1.getMEPContext(),
+ HandlerChainProcessor.Direction.IN,
+ HandlerChainProcessor.MEP.REQUEST,
+ false);
+
+ // no handleFault calls
+ assertEquals("S2m:S1m:L1m:L1c:S1c:S2c:", result);
+ }
+
+ /*
+ * incoming request (we must be on the server), response expected
+ * a middle Handler.handleMessage throws RuntimeException
+ * processing expected: Logical and SOAP, reverse order, message reversed, (no handleFault), close
+ */
+ public void testHandleMessage_runtimeex_true() {
+
+ // reset result
+ result = "";
+
+ // we want one false response:
+ soaphandler1_MessageResultDesired = ResultDesired.TRUE;
+ soaphandler1_FaultResultDesired = ResultDesired.TRUE;
+ soaphandler2_MessageResultDesired = ResultDesired.TRUE;
+ soaphandler2_FaultResultDesired = ResultDesired.TRUE;
+ logicalhandler1_MessageResultDesired = ResultDesired.OTHER_EXCEPTION;
+ logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
+ logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
+ logicalhandler2_FaultResultDesired = ResultDesired.TRUE;
+
+ HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
+ MessageContext mc1 = new MessageContext();
+ mc1.setMEPContext(new MEPContext(mc1));
+ Exception e = null;
+ try {
+ processor.processChain(mc1.getMEPContext(),
+ HandlerChainProcessor.Direction.IN,
+ HandlerChainProcessor.MEP.REQUEST,
+ true);
+ } catch (RuntimeException re) {
+ e = re;
+ }
+
+ assertNotNull(e);
+ // no handleFault calls
+ assertEquals("S2m:S1m:L1m:L1c:S1c:S2c:", result);
+ }
+
+ /*
+ * incoming request (we must be on the server), response expected
+ * a middle Handler.handleMessage throws ProtocolException, later a Handler.handleFault returns false
+ * processing expected: Logical and SOAP, reverse order, message reversed, handleFault, close
+ */
+ public void testHandleMessage_protocolex_false() {
+
+ // reset result
+ result = "";
+
+ // we want one false response:
+ soaphandler1_MessageResultDesired = ResultDesired.TRUE;
+ soaphandler1_FaultResultDesired = ResultDesired.FALSE;
+ soaphandler2_MessageResultDesired = ResultDesired.TRUE;
+ soaphandler2_FaultResultDesired = ResultDesired.TRUE;
+ logicalhandler1_MessageResultDesired = ResultDesired.PROTOCOL_EXCEPTION;
+ logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
+ logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
+ logicalhandler2_FaultResultDesired = ResultDesired.TRUE;
+
+ HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
+ MessageContext mc1 = new MessageContext();
+ mc1.setMEPContext(new MEPContext(mc1));
+ processor.processChain(mc1.getMEPContext(),
+ HandlerChainProcessor.Direction.IN,
+ HandlerChainProcessor.MEP.REQUEST,
+ true);
+
+ // handleFault processing, but notice S2f does not get called
+ assertEquals("S2m:S1m:L1m:S1f:L1c:S1c:S2c:", result);
+ }
+
+ /*
+ * incoming request (we must be on the server), response expected
+ * a middle Handler.handleMessage throws ProtocolException, later a Handler.handleFault throws ProtocolException
+ * processing expected: Logical and SOAP, reverse order, message reversed, handleFault, close
+ */
+ public void testHandleMessage_protocolex_protocolex() {
+
+ // reset result
+ result = "";
+
+ // we want one false response:
+ soaphandler1_MessageResultDesired = ResultDesired.TRUE;
+ soaphandler1_FaultResultDesired = ResultDesired.PROTOCOL_EXCEPTION;
+ soaphandler2_MessageResultDesired = ResultDesired.TRUE;
+ soaphandler2_FaultResultDesired = ResultDesired.TRUE;
+ logicalhandler1_MessageResultDesired = ResultDesired.PROTOCOL_EXCEPTION;
+ logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
+ logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
+ logicalhandler2_FaultResultDesired = ResultDesired.TRUE;
+
+ HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
+ MessageContext mc1 = new MessageContext();
+ mc1.setMEPContext(new MEPContext(mc1));
+ Exception e = null;
+ try {
+ // handleFault processing, but notice S2f does not get called, and we get an exception
+ processor.processChain(mc1.getMEPContext(),
+ HandlerChainProcessor.Direction.IN,
+ HandlerChainProcessor.MEP.REQUEST,
+ true);
+ } catch (ProtocolException pe) {
+ e = pe;
+ }
+
+ assertNotNull(e);
+ assertEquals("S2m:S1m:L1m:S1f:L1c:S1c:S2c:", result);
+ }
+
+ /*
+ * incoming request (we must be on the server), response expected
+ * a middle Handler.handleMessage throws ProtocolException, later a Handler.handleFault throws ProtocolException
+ * processing expected: Logical and SOAP, reverse order, handleFault, close
+ */
+ public void testHandleMessage_protocolex_runtimeex() {
+
+ // reset result
+ result = "";
+
+ // we want one false response:
+ soaphandler1_MessageResultDesired = ResultDesired.TRUE;
+ soaphandler1_FaultResultDesired = ResultDesired.OTHER_EXCEPTION;
+ soaphandler2_MessageResultDesired = ResultDesired.TRUE;
+ soaphandler2_FaultResultDesired = ResultDesired.TRUE;
+ logicalhandler1_MessageResultDesired = ResultDesired.PROTOCOL_EXCEPTION;
+ logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
+ logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
+ logicalhandler2_FaultResultDesired = ResultDesired.TRUE;
+
+ HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
+ MessageContext mc1 = new MessageContext();
+ mc1.setMEPContext(new MEPContext(mc1));
+ Exception e = null;
+ try {
+ // same results as testHandlers_protocolex_protocolex
+ processor.processChain(mc1.getMEPContext(),
+ HandlerChainProcessor.Direction.IN,
+ HandlerChainProcessor.MEP.REQUEST,
+ true);
+ } catch (RuntimeException pe) {
+ e = pe;
+ }
+
+ assertNotNull(e);
+ assertEquals("S2m:S1m:L1m:S1f:L1c:S1c:S2c:", result);
+ }
+
+
+ /*
+ * empty list
+ */
+ public void testHandleFault_empty1() {
+
+ Exception local_exception = null;
+
+ HandlerChainProcessor processor1 = new HandlerChainProcessor(null, Protocol.soap11);
+ HandlerChainProcessor processor2 =
+ new HandlerChainProcessor(new ArrayList<Handler>(), Protocol.soap11);
+ try {
+ MessageContext mc1 = new MessageContext();
+ mc1.setMEPContext(new MEPContext(mc1));
+ processor1.processFault(mc1.getMEPContext(), HandlerChainProcessor.Direction.IN);
+ MessageContext mc2 = new MessageContext();
+ mc2.setMEPContext(new MEPContext(mc2));
+ processor2.processFault(mc2.getMEPContext(), HandlerChainProcessor.Direction.IN);
+ } catch (Exception e) {
+ local_exception = e;
+ }
+
+ // no exceptions!
+ assertNull(local_exception);
+ }
+
+
+ /*
+ * outgoing response (we must be on the server), response expected (ignored)
+ * processing expected: Logical and SOAP, normal order, handleFault, close
+ */
+ public void testHandleFault_true1() {
+
+ // reset result
+ result = "";
+
+ // we want one false response:
+ soaphandler1_MessageResultDesired = ResultDesired.TRUE;
+ soaphandler1_FaultResultDesired = ResultDesired.TRUE;
+ soaphandler2_MessageResultDesired = ResultDesired.TRUE;
+ soaphandler2_FaultResultDesired = ResultDesired.TRUE;
+ logicalhandler1_MessageResultDesired = ResultDesired.TRUE;
+ logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
+ logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
+ logicalhandler2_FaultResultDesired = ResultDesired.TRUE;
+
+ HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
+ MessageContext mc1 = new MessageContext();
+ mc1.setMEPContext(new MEPContext(mc1));
+ processor.processFault(mc1.getMEPContext(), HandlerChainProcessor.Direction.OUT);
+
+ assertEquals("L2f:L1f:S1f:S2f:S2c:S1c:L1c:L2c:", result);
+ }
+
+ /*
+ * outgoing response (we must be on the server)
+ * a middle Handler.handleFault returns false
+ * processing expected: Logical and SOAP, normal order, handleFault, close (all)
+ */
+ public void testHandleFault_false1() {
+
+ // reset result
+ result = "";
+
+ // we want one false response:
+ soaphandler1_MessageResultDesired = ResultDesired.TRUE;
+ soaphandler1_FaultResultDesired = ResultDesired.TRUE;
+ soaphandler2_MessageResultDesired = ResultDesired.TRUE;
+ soaphandler2_FaultResultDesired = ResultDesired.TRUE;
+ logicalhandler1_MessageResultDesired = ResultDesired.TRUE;
+ logicalhandler1_FaultResultDesired = ResultDesired.FALSE;
+ logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
+ logicalhandler2_FaultResultDesired = ResultDesired.TRUE;
+
+ HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
+ MessageContext mc1 = new MessageContext();
+ mc1.setMEPContext(new MEPContext(mc1));
+ processor.processFault(mc1.getMEPContext(), HandlerChainProcessor.Direction.OUT);
+
+ // notice all handlers are closed in this scenario
+ assertEquals("L2f:L1f:S2c:S1c:L1c:L2c:", result);
+ }
+
+ /*
+ * incoming response (we must be on the client)
+ * a middle Handler.handleFault throws ProtocolException
+ * processing expected: Logical and SOAP, reverse order, handleFault, close (all)
+ */
+ public void testHandleFault_protocolex() {
+
+ // reset result
+ result = "";
+
+ // we want one false response:
+ soaphandler1_MessageResultDesired = ResultDesired.TRUE;
+ soaphandler1_FaultResultDesired = ResultDesired.TRUE;
+ soaphandler2_MessageResultDesired = ResultDesired.TRUE;
+ soaphandler2_FaultResultDesired = ResultDesired.TRUE;
+ logicalhandler1_MessageResultDesired = ResultDesired.TRUE;
+ logicalhandler1_FaultResultDesired = ResultDesired.PROTOCOL_EXCEPTION;
+ logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
+ logicalhandler2_FaultResultDesired = ResultDesired.TRUE;
+
+ HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
+ MessageContext mc1 = new MessageContext();
+ mc1.setMEPContext(new MEPContext(mc1));
+ Exception e = null;
+ try {
+ // notice all handlers are closed in this scenario, and we get an exception
+ processor.processFault(mc1.getMEPContext(), HandlerChainProcessor.Direction.IN);
+ } catch (ProtocolException pe) {
+ e = pe;
+ }
+
+ assertNotNull(e);
+ assertEquals("S2f:S1f:L1f:L2c:L1c:S1c:S2c:", result);
+ }
+
+
+ private class SOAPHandler1 implements SOAPHandler<SOAPMessageContext> {
+
+ public Set getHeaders() {
+ return null;
+ }
+
+ public void close(javax.xml.ws.handler.MessageContext messagecontext) {
+ result = result.concat("S1c:");
+ }
+
+ public boolean handleFault(SOAPMessageContext messagecontext) {
+ result = result.concat("S1f:");
+ if (soaphandler1_FaultResultDesired == ResultDesired.TRUE)
+ return true;
+ else if (soaphandler1_FaultResultDesired == ResultDesired.FALSE)
+ return false;
+ else if (soaphandler1_FaultResultDesired == ResultDesired.PROTOCOL_EXCEPTION)
+ throw new ProtocolException();
+ else if (soaphandler1_FaultResultDesired == ResultDesired.OTHER_EXCEPTION)
+ throw new RuntimeException();
+
+ // default
+ return true;
+ }
+
+ public boolean handleMessage(SOAPMessageContext messagecontext) {
+ result = result.concat("S1m:");
+ if (soaphandler1_MessageResultDesired == ResultDesired.TRUE)
+ return true;
+ else if (soaphandler1_MessageResultDesired == ResultDesired.FALSE)
+ return false;
+ else if (soaphandler1_MessageResultDesired == ResultDesired.PROTOCOL_EXCEPTION)
+ throw new ProtocolException();
+ else if (soaphandler1_MessageResultDesired == ResultDesired.OTHER_EXCEPTION)
+ throw new RuntimeException();
+
+ // default
+ return true;
+ }
+
+ }
+
+
+ private class SOAPHandler2 implements SOAPHandler<SOAPMessageContext> {
+
+ public Set getHeaders() {
+ return null;
+ }
+
+ public void close(javax.xml.ws.handler.MessageContext messagecontext) {
+ result = result.concat("S2c:");
+ }
+
+ public boolean handleFault(SOAPMessageContext messagecontext) {
+ result = result.concat("S2f:");
+ if (soaphandler2_FaultResultDesired == ResultDesired.TRUE)
+ return true;
+ else if (soaphandler2_FaultResultDesired == ResultDesired.FALSE)
+ return false;
+ else if (soaphandler2_FaultResultDesired == ResultDesired.PROTOCOL_EXCEPTION)
+ throw new ProtocolException();
+ else if (soaphandler2_FaultResultDesired == ResultDesired.OTHER_EXCEPTION)
+ throw new RuntimeException();
+
+ // default
+ return true;
+ }
+
+ public boolean handleMessage(SOAPMessageContext messagecontext) {
+ result = result.concat("S2m:");
+ if (soaphandler2_MessageResultDesired == ResultDesired.TRUE)
+ return true;
+ else if (soaphandler2_MessageResultDesired == ResultDesired.FALSE)
+ return false;
+ else if (soaphandler2_MessageResultDesired == ResultDesired.PROTOCOL_EXCEPTION)
+ throw new ProtocolException();
+ else if (soaphandler2_MessageResultDesired == ResultDesired.OTHER_EXCEPTION)
+ throw new RuntimeException();
+
+ // default
+ return true;
+ }
+
+ }
+
+
+ private class LogicalHandler1 implements LogicalHandler<LogicalMessageContext> {
+
+ public void close(javax.xml.ws.handler.MessageContext messagecontext) {
+ result = result.concat("L1c:");
+ }
+
+ public boolean handleFault(LogicalMessageContext messagecontext) {
+ result = result.concat("L1f:");
+ if (logicalhandler1_FaultResultDesired == ResultDesired.TRUE)
+ return true;
+ else if (logicalhandler1_FaultResultDesired == ResultDesired.FALSE)
+ return false;
+ else if (logicalhandler1_FaultResultDesired == ResultDesired.PROTOCOL_EXCEPTION)
+ throw new ProtocolException();
+ else if (logicalhandler1_FaultResultDesired == ResultDesired.OTHER_EXCEPTION)
+ throw new RuntimeException();
+
+ // default
+ return true;
+ }
+
+ public boolean handleMessage(LogicalMessageContext messagecontext) {
+ result = result.concat("L1m:");
+ if (logicalhandler1_MessageResultDesired == ResultDesired.TRUE)
+ return true;
+ else if (logicalhandler1_MessageResultDesired == ResultDesired.FALSE)
+ return false;
+ else if (logicalhandler1_MessageResultDesired == ResultDesired.PROTOCOL_EXCEPTION)
+ throw new ProtocolException();
+ else if (logicalhandler1_MessageResultDesired == ResultDesired.OTHER_EXCEPTION)
+ throw new RuntimeException();
+
+ // default
+ return true;
+ }
+
+ }
+
+
+ private class LogicalHandler2 implements LogicalHandler<LogicalMessageContext> {
+
+ public void close(javax.xml.ws.handler.MessageContext messagecontext) {
+ result = result.concat("L2c:");
+ }
+
+ public boolean handleFault(LogicalMessageContext messagecontext) {
+ result = result.concat("L2f:");
+ if (logicalhandler2_FaultResultDesired == ResultDesired.TRUE)
+ return true;
+ else if (logicalhandler2_FaultResultDesired == ResultDesired.FALSE)
+ return false;
+ else if (logicalhandler2_FaultResultDesired == ResultDesired.PROTOCOL_EXCEPTION)
+ throw new ProtocolException();
+ else if (logicalhandler2_FaultResultDesired == ResultDesired.OTHER_EXCEPTION)
+ throw new RuntimeException();
+
+ // default
+ return true;
+ }
+
+ public boolean handleMessage(LogicalMessageContext messagecontext) {
+ result = result.concat("L2m:");
+ if (logicalhandler2_MessageResultDesired == ResultDesired.TRUE)
+ return true;
+ else if (logicalhandler2_MessageResultDesired == ResultDesired.FALSE)
+ return false;
+ else if (logicalhandler2_MessageResultDesired == ResultDesired.PROTOCOL_EXCEPTION)
+ throw new ProtocolException();
+ else if (logicalhandler2_MessageResultDesired == ResultDesired.OTHER_EXCEPTION)
+ throw new RuntimeException();
+
+ // default
+ return true;
+ }
+
+ }
}
Modified: webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/handler/context/LogicalMessageContextTests.java
URL: http://svn.apache.org/viewvc/webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/handler/context/LogicalMessageContextTests.java?view=diff&rev=551228&r1=551227&r2=551228
==============================================================================
--- webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/handler/context/LogicalMessageContextTests.java (original)
+++ webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/handler/context/LogicalMessageContextTests.java Wed Jun 27 09:45:37 2007
@@ -34,6 +34,7 @@
import junit.framework.TestCase;
import org.apache.axis2.jaxws.context.factory.MessageContextFactory;
+import org.apache.axis2.jaxws.core.MEPContext;
import org.apache.axis2.jaxws.core.MessageContext;
import org.apache.axis2.jaxws.message.Block;
import org.apache.axis2.jaxws.message.Message;
@@ -227,6 +228,7 @@
msg.setBodyBlock(block);
MessageContext mc = new MessageContext();
+ mc.setMEPContext(new MEPContext(mc));
mc.setMessage(msg);
LogicalMessageContext lmc = MessageContextFactory.createLogicalMessageContext(mc);
@@ -243,6 +245,7 @@
msg.setXMLFault(fault);
MessageContext mc = new MessageContext();
+ mc.setMEPContext(new MEPContext(mc));
mc.setMessage(msg);
LogicalMessageContext lmc = MessageContextFactory.createLogicalMessageContext(mc);
Modified: webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/nonanonymous/complextype/META-INF/services.xml
URL: http://svn.apache.org/viewvc/webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/nonanonymous/complextype/META-INF/services.xml?view=diff&rev=551228&r1=551227&r2=551228
==============================================================================
--- webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/nonanonymous/complextype/META-INF/services.xml (original)
+++ webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/nonanonymous/complextype/META-INF/services.xml Wed Jun 27 09:45:37 2007
@@ -3,7 +3,7 @@
<messageReceivers>
<messageReceiver mep="http://www.w3.org/2004/08/wsdl/in-out" class="org.apache.axis2.jaxws.server.JAXWSMessageReceiver"/>
</messageReceivers>
- <parameter locked="false" name="ServiceClass">org.apache.axis2.jaxws.nonanonymous.complextype.EchoMessageImpl</parameter>
+ <parameter name="ServiceClass">org.apache.axis2.jaxws.nonanonymous.complextype.EchoMessageImpl</parameter>
</service>
</serviceGroup>
Modified: webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/polymorphic/shape/META-INF/services.xml
URL: http://svn.apache.org/viewvc/webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/polymorphic/shape/META-INF/services.xml?view=diff&rev=551228&r1=551227&r2=551228
==============================================================================
--- webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/polymorphic/shape/META-INF/services.xml (original)
+++ webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/polymorphic/shape/META-INF/services.xml Wed Jun 27 09:45:37 2007
@@ -3,7 +3,7 @@
<messageReceivers>
<messageReceiver mep="http://www.w3.org/2004/08/wsdl/in-out" class="org.apache.axis2.jaxws.server.JAXWSMessageReceiver"/>
</messageReceivers>
- <parameter locked="false" name="ServiceClass">org.apache.axis2.jaxws.polymorphic.shape.PolymorphicShapePortTypeImpl</parameter>
+ <parameter name="ServiceClass">org.apache.axis2.jaxws.polymorphic.shape.PolymorphicShapePortTypeImpl</parameter>
</service>
</serviceGroup>
Modified: webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/provider/SOAPFaultProviderTests.java
URL: http://svn.apache.org/viewvc/webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/provider/SOAPFaultProviderTests.java?view=diff&rev=551228&r1=551227&r2=551228
==============================================================================
--- webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/provider/SOAPFaultProviderTests.java (original)
+++ webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/provider/SOAPFaultProviderTests.java Wed Jun 27 09:45:37 2007
@@ -63,7 +63,7 @@
// Force soap action because we are passing junk over the wire
dispatch.getRequestContext().put(BindingProvider.SOAPACTION_USE_PROPERTY, Boolean.TRUE);
- dispatch.getRequestContext().put(BindingProvider.SOAPACTION_URI_PROPERTY, "echoString");
+ dispatch.getRequestContext().put(BindingProvider.SOAPACTION_URI_PROPERTY, "http://stringprovider.sample.test.org/echoString");
return dispatch;
}
Modified: webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/provider/StringProviderTests.java
URL: http://svn.apache.org/viewvc/webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/provider/StringProviderTests.java?view=diff&rev=551228&r1=551227&r2=551228
==============================================================================
--- webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/provider/StringProviderTests.java (original)
+++ webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/provider/StringProviderTests.java Wed Jun 27 09:45:37 2007
@@ -52,7 +52,7 @@
// Force soap action because we are passing junk over the wire
dispatch.getRequestContext().put(BindingProvider.SOAPACTION_USE_PROPERTY, Boolean.TRUE);
- dispatch.getRequestContext().put(BindingProvider.SOAPACTION_URI_PROPERTY,"echoString");
+ dispatch.getRequestContext().put(BindingProvider.SOAPACTION_URI_PROPERTY,"http://stringprovider.sample.test.org/echoString");
return dispatch;
Modified: webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/provider/jaxb/META-INF/services.xml
URL: http://svn.apache.org/viewvc/webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/provider/jaxb/META-INF/services.xml?view=diff&rev=551228&r1=551227&r2=551228
==============================================================================
--- webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/provider/jaxb/META-INF/services.xml (original)
+++ webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/provider/jaxb/META-INF/services.xml Wed Jun 27 09:45:37 2007
@@ -3,7 +3,7 @@
<messageReceivers>
<messageReceiver mep="http://www.w3.org/2004/08/wsdl/in-out" class="org.apache.axis2.jaxws.server.JAXWSMessageReceiver"/>
</messageReceivers>
- <parameter locked="false" name="ServiceClass">org.apache.axis2.jaxws.provider.jaxb.JAXBProvider</parameter>
+ <parameter name="ServiceClass">org.apache.axis2.jaxws.provider.jaxb.JAXBProvider</parameter>
<excludeOperations>
<operation>invoke</operation>
</excludeOperations>
Modified: webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/provider/soapmsg/META-INF/services.xml
URL: http://svn.apache.org/viewvc/webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/provider/soapmsg/META-INF/services.xml?view=diff&rev=551228&r1=551227&r2=551228
==============================================================================
--- webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/provider/soapmsg/META-INF/services.xml (original)
+++ webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/provider/soapmsg/META-INF/services.xml Wed Jun 27 09:45:37 2007
@@ -3,7 +3,7 @@
<messageReceivers>
<messageReceiver mep="http://www.w3.org/2004/08/wsdl/in-out" class="org.apache.axis2.jaxws.server.JAXWSMessageReceiver"/>
</messageReceivers>
- <parameter locked="false" name="ServiceClass">org.apache.axis2.jaxws.provider.soapmsg.SoapMessageProvider</parameter>
+ <parameter name="ServiceClass">org.apache.axis2.jaxws.provider.soapmsg.SoapMessageProvider</parameter>
<excludeOperations>
<operation>invoke</operation>
</excludeOperations>
Modified: webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/provider/source/META-INF/services.xml
URL: http://svn.apache.org/viewvc/webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/provider/source/META-INF/services.xml?view=diff&rev=551228&r1=551227&r2=551228
==============================================================================
--- webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/provider/source/META-INF/services.xml (original)
+++ webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/provider/source/META-INF/services.xml Wed Jun 27 09:45:37 2007
@@ -3,7 +3,7 @@
<messageReceivers>
<messageReceiver mep="http://www.w3.org/2004/08/wsdl/in-out" class="org.apache.axis2.jaxws.server.JAXWSMessageReceiver"/>
</messageReceivers>
- <parameter locked="false" name="ServiceClass">org.apache.axis2.jaxws.provider.source.SourceProvider</parameter>
+ <parameter name="ServiceClass">org.apache.axis2.jaxws.provider.source.SourceProvider</parameter>
<excludeOperations>
<operation>invoke</operation>
</excludeOperations>
Modified: webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/provider/sourcemsg/META-INF/services.xml
URL: http://svn.apache.org/viewvc/webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/provider/sourcemsg/META-INF/services.xml?view=diff&rev=551228&r1=551227&r2=551228
==============================================================================
--- webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/provider/sourcemsg/META-INF/services.xml (original)
+++ webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/provider/sourcemsg/META-INF/services.xml Wed Jun 27 09:45:37 2007
@@ -3,7 +3,7 @@
<messageReceivers>
<messageReceiver mep="http://www.w3.org/2004/08/wsdl/in-out" class="org.apache.axis2.jaxws.server.JAXWSMessageReceiver"/>
</messageReceivers>
- <parameter locked="false" name="ServiceClass">org.apache.axis2.jaxws.provider.sourcemsg.SourceMessageProvider</parameter>
+ <parameter name="ServiceClass">org.apache.axis2.jaxws.provider.sourcemsg.SourceMessageProvider</parameter>
<excludeOperations>
<operation>invoke</operation>
</excludeOperations>
Modified: webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/provider/string/META-INF/services.xml
URL: http://svn.apache.org/viewvc/webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/provider/string/META-INF/services.xml?view=diff&rev=551228&r1=551227&r2=551228
==============================================================================
--- webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/provider/string/META-INF/services.xml (original)
+++ webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/provider/string/META-INF/services.xml Wed Jun 27 09:45:37 2007
@@ -3,7 +3,7 @@
<messageReceivers>
<messageReceiver mep="http://www.w3.org/2004/08/wsdl/in-out" class="org.apache.axis2.jaxws.server.JAXWSMessageReceiver"/>
</messageReceivers>
- <parameter locked="false" name="ServiceClass">org.apache.axis2.jaxws.provider.string.StringProvider</parameter>
+ <parameter name="ServiceClass">org.apache.axis2.jaxws.provider.string.StringProvider</parameter>
<operation name="invoke" mep="http://www.w3.org/2004/08/wsdl/in-out">
<actionMapping/>
</operation>
Modified: webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/provider/stringmsg/META-INF/services.xml
URL: http://svn.apache.org/viewvc/webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/provider/stringmsg/META-INF/services.xml?view=diff&rev=551228&r1=551227&r2=551228
==============================================================================
--- webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/provider/stringmsg/META-INF/services.xml (original)
+++ webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/provider/stringmsg/META-INF/services.xml Wed Jun 27 09:45:37 2007
@@ -3,7 +3,7 @@
<messageReceivers>
<messageReceiver mep="http://www.w3.org/2004/08/wsdl/in-out" class="org.apache.axis2.jaxws.server.JAXWSMessageReceiver"/>
</messageReceivers>
- <parameter locked="false" name="ServiceClass">org.apache.axis2.jaxws.provider.stringmsg.StringMessageProvider</parameter>
+ <parameter name="ServiceClass">org.apache.axis2.jaxws.provider.stringmsg.StringMessageProvider</parameter>
<excludeOperations>
<operation>invoke</operation>
</excludeOperations>
Modified: webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/proxy/doclitnonwrapped/META-INF/services.xml
URL: http://svn.apache.org/viewvc/webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/proxy/doclitnonwrapped/META-INF/services.xml?view=diff&rev=551228&r1=551227&r2=551228
==============================================================================
--- webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/proxy/doclitnonwrapped/META-INF/services.xml (original)
+++ webservices/axis2/branches/java/jaxws21/modules/jaxws/test/org/apache/axis2/jaxws/proxy/doclitnonwrapped/META-INF/services.xml Wed Jun 27 09:45:37 2007
@@ -3,7 +3,7 @@
<messageReceivers>
<messageReceiver mep="http://www.w3.org/2004/08/wsdl/in-out" class="org.apache.axis2.jaxws.server.JAXWSMessageReceiver"/>
</messageReceivers>
- <parameter locked="false" name="ServiceClass">org.apache.axis2.jaxws.proxy.doclitnonwrapped.DocLitnonWrappedImpl</parameter>
+ <parameter name="ServiceClass">org.apache.axis2.jaxws.proxy.doclitnonwrapped.DocLitnonWrappedImpl</parameter>
<operation name="invoke" mep="http://www.w3.org/2004/08/wsdl/in-out">
<actionMapping/>
</operation>
---------------------------------------------------------------------
To unsubscribe, e-mail: axis-cvs-unsubscribe@ws.apache.org
For additional commands, e-mail: axis-cvs-help@ws.apache.org