/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

package org.apache.axis2.jaxws.sample;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Future;

import javax.xml.namespace.QName;
import javax.xml.soap.SOAPFault;
import javax.xml.transform.Result;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;
import javax.xml.ws.AsyncHandler;
import javax.xml.ws.Binding;
import javax.xml.ws.BindingProvider;
import javax.xml.ws.Dispatch;
import javax.xml.ws.Response;
import javax.xml.ws.Service;
import javax.xml.ws.handler.Handler;
import javax.xml.ws.handler.HandlerResolver;
import javax.xml.ws.handler.PortInfo;
import javax.xml.ws.soap.SOAPFaultException;

import junit.framework.Test;
import junit.framework.TestSuite;

import org.apache.axis2.jaxws.TestLogger;
import org.apache.axis2.jaxws.framework.AbstractTestCase;
import org.apache.axis2.jaxws.sample.addnumbershandler.AddNumbersClientLogicalHandler;
import org.apache.axis2.jaxws.sample.addnumbershandler.AddNumbersClientLogicalHandler2;
import org.apache.axis2.jaxws.sample.addnumbershandler.AddNumbersClientLogicalHandler3;
import org.apache.axis2.jaxws.sample.addnumbershandler.AddNumbersClientLogicalHandler4;
import org.apache.axis2.jaxws.sample.addnumbershandler.AddNumbersClientProtocolHandler;
import org.apache.axis2.jaxws.sample.addnumbershandler.AddNumbersHandlerFault_Exception;
import org.apache.axis2.jaxws.sample.addnumbershandler.AddNumbersHandlerPortType;
import org.apache.axis2.jaxws.sample.addnumbershandler.AddNumbersHandlerService;
import org.test.addnumbershandler.AddNumbersHandlerResponse;

public class AddNumbersHandlerTests extends AbstractTestCase {
	
    String axisEndpoint = "http://localhost:6060/axis2/services/AddNumbersHandlerService.AddNumbersHandlerPortTypeImplPort";
    static File requestFile = null;
    static {
        String resourceDir = System.getProperty("basedir",".")+
            File.separator+"test-resources"+File.separator+"xml";
        requestFile = new File(resourceDir+File.separator+"addnumberstest.xml");
    }
    
    private static final String filelogname = "target/AddNumbersHandlerTests.log";

    public static Test suite() {
        return getTestSetup(new TestSuite(AddNumbersHandlerTests.class));
    }

    /**
     * Client app sends 10, 10 as params to sum.  No client-side handlers are configured
     * for this scenario.  The server-side AddNumbersLogicalHandler is instantiated with a
     * variable "deduction" with value 1.  Upon class initialization using PostConstruct
     * annotation, that internal variable is changed to value 2.  The inbound AddNumbersLogicalHandler
     * subtracts 1 from the first param, then outbound it subtracts 2 from the result sum.
     * 
     * This test accomplishes three things (which also carry over to other tests since they all use
     * the same endpoint and server-side handlers:
     * 1)  PostConstruct annotation honored in the handler framework for handler instantiation
     * 2)  AddNumbersLogicalHandler also sets two message context properties, one with APPLICATION
     *     scope, which the endpoint checks.
     * 3)  Handlers are sharing properties, both APPLICATION scoped and HANDLER scoped
     * 3)  General handler framework functionality; make sure handlers are instantiated and called
     */
    public void testAddNumbersHandler() {
		try{
            TestLogger.logger.debug("----------------------------------");
            TestLogger.logger.debug("test: " + getName());
			
            AddNumbersHandlerService service = new AddNumbersHandlerService();
            AddNumbersHandlerPortType proxy = service.getAddNumbersHandlerPort();
			
            BindingProvider p =	(BindingProvider)proxy;
            p.getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, axisEndpoint);
            int total = proxy.addNumbersHandler(10, 10);

            assertEquals("With handler manipulation, total should be 3 less than a proper sumation.", 17, total);
            TestLogger.logger.debug("Total (after handler manipulation) = " + total);
            
            // also confirm that @PreDestroy method is called.  Since it only makes sense to call it on the managed
            // (server) side and just before the handler instance goes out of scope, we are creating a file in the
            // @PreDestroy method, and will check for its existance here.  If the file does not exist, it means
            // @PreDestroy method was never called.  The file is set to .deleteOnExit(), so no need to delete it.
            File file = new File("AddNumbersProtocolHandler.preDestroy.txt");
            assertTrue("File AddNumbersProtocolHandler.preDestroy.txt does not exist, meaning the @PreDestroy method was not called.", file.exists());

            String log = readLogFile();
            String expected_calls =
                      "AddNumbersLogicalHandler2 POST_CONSTRUCT\n"
                    + "AddNumbersProtocolHandler2 GET_HEADERS\n"
                    + "AddNumbersProtocolHandler GET_HEADERS\n"
                    + "AddNumbersProtocolHandler HANDLE_MESSAGE_INBOUND\n"
                    + "AddNumbersProtocolHandler2 HANDLE_MESSAGE_INBOUND\n"
                    + "AddNumbersLogicalHandler2 HANDLE_MESSAGE_INBOUND\n"
                    + "AddNumbersLogicalHandler HANDLE_MESSAGE_INBOUND\n"
                    + "AddNumbersLogicalHandler HANDLE_MESSAGE_OUTBOUND\n"
                    + "AddNumbersLogicalHandler2 HANDLE_MESSAGE_OUTBOUND\n"
                    + "AddNumbersProtocolHandler2 HANDLE_MESSAGE_OUTBOUND\n"
                    + "AddNumbersProtocolHandler HANDLE_MESSAGE_OUTBOUND\n"
                    + "AddNumbersLogicalHandler CLOSE\n"
                    + "AddNumbersLogicalHandler2 CLOSE\n"
                    + "AddNumbersProtocolHandler2 CLOSE\n"
                    + "AddNumbersProtocolHandler CLOSE\n"
                    + "AddNumbersProtocolHandler PRE_DESTROY\n";
            assertEquals(expected_calls, log);
            
            TestLogger.logger.debug("----------------------------------");
		} catch(Exception e) {
			e.printStackTrace();
			fail(e.getMessage());
		}
	}
    
    /**
     * Client app sends MAXVALUE, MAXVALUE as params to add.
     * No client-side handlers are configured for this scenario.  
     * The endpoint method (addNumbersHandler) will detect the possible overflow and
     * throw an application exception, AddNumbersHandleFault_Exception.
     * 
     * The server-side AddNumbersProtocolHandler will
     * access the thrown exception using the "jaxws.webmethod.exception"
     * property and add the stack trace string to fault string.
     * 
     * The client should receive a AddNumbersHandlerFault_Exception that has a stack
     * trace as part of the message.
     * This test verifies the following:
     * 
     * 1)  Proper exception/fault processing when handlers are installed.
     * 2)  Access to the special "jaxws.webmethod.exception"
     * 3)  Proper exception call flow when an application exception is thrown.
     */
    public void testAddNumbersHandler_WithCheckedException() throws Exception {

        TestLogger.logger.debug("----------------------------------");
        TestLogger.logger.debug("test: " + getName());

        AddNumbersHandlerService service = new AddNumbersHandlerService();
        AddNumbersHandlerPortType proxy = service.getAddNumbersHandlerPort();

        BindingProvider p = (BindingProvider)proxy;
        p.getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, axisEndpoint);
        AddNumbersHandlerFault_Exception expectedException = null;
        Throwable t = null;
        try {
            proxy.addNumbersHandler(Integer.MAX_VALUE, Integer.MAX_VALUE);
            
        } catch (Throwable e) {
            // An exception is expected
            t = e;
            
        } 
        
        // Make sure the proper exception is thrown
        if (t == null) {
            fail("Expected AddNumbersHandlerFault_Exception to be thrown");
        }
        if (t instanceof AddNumbersHandlerFault_Exception) {
            expectedException = (AddNumbersHandlerFault_Exception) t;
        } else {
            fail("Expected AddNumbersHandlerFault_Exception to be thrown, " +
                        "but the exception is: " + t);
        }
       
        // also confirm that @PreDestroy method is called.  Since it only makes sense to call it on the managed
        // (server) side and just before the handler instance goes out of scope, we are creating a file in the
        // @PreDestroy method, and will check for its existance here.  If the file does not exist, it means
        // @PreDestroy method was never called.  The file is set to .deleteOnExit(), so no need to delete it.
        File file = new File("AddNumbersProtocolHandler.preDestroy.txt");
        assertTrue("File AddNumbersProtocolHandler.preDestroy.txt does not exist, meaning the @PreDestroy method was not called.", file.exists());

        String log = readLogFile();
        String expected_calls =
            "AddNumbersLogicalHandler2 POST_CONSTRUCT\n"
            + "AddNumbersProtocolHandler2 GET_HEADERS\n"
            + "AddNumbersProtocolHandler GET_HEADERS\n"
            + "AddNumbersProtocolHandler HANDLE_MESSAGE_INBOUND\n"
            + "AddNumbersProtocolHandler2 HANDLE_MESSAGE_INBOUND\n"
            + "AddNumbersLogicalHandler2 HANDLE_MESSAGE_INBOUND\n"
            + "AddNumbersLogicalHandler HANDLE_MESSAGE_INBOUND\n"
            + "AddNumbersLogicalHandler HANDLE_FAULT_OUTBOUND\n"
            + "AddNumbersLogicalHandler2 HANDLE_FAULT_OUTBOUND\n"
            + "AddNumbersProtocolHandler2 HANDLE_FAULT_OUTBOUND\n"
            + "AddNumbersProtocolHandler HANDLE_FAULT_OUTBOUND\n"
            + "AddNumbersLogicalHandler CLOSE\n"
            + "AddNumbersLogicalHandler2 CLOSE\n"
            + "AddNumbersProtocolHandler2 CLOSE\n"
            + "AddNumbersProtocolHandler CLOSE\n"
            + "AddNumbersProtocolHandler PRE_DESTROY\n";
        
        assertEquals(expected_calls, log);
        
        TestLogger.logger.debug("Expected Exception is " + 
                                expectedException.getMessage());
        
        // The outbound service handler adds the stack trace to the 
        // message.  Make sure the stack trace contains the AddNumbersHandlerPortTypeImpl
        assertTrue("A stack trace was not present in the returned exception's message:" + 
                   expectedException.getMessage(),
                   expectedException.getMessage().indexOf("AddNumbersHandlerPortTypeImpl") > 0);

        TestLogger.logger.debug("----------------------------------");
        
    }
    
    /**
     * Client app sends MAXVALUE, MAXVALUE as params to add.
     * No client-side handlers are configured for this scenario.  
     * The endpoint method (addNumbersHandler) will detect the possible overflow and
     * throw an unchecked exception, NullPointerException.
     * 
     * The server-side AddNumbersProtocolHandler will
     * access the thrown exception using the "jaxws.webmethod.exception"
     * property and add the stack trace string to fault string.
     * 
     * The client should receive a SOAPFaultException that has a stack
     * trace as part of the message.
     * This test verifies the following:
     * 
     * 1)  Proper exception/fault processing when handlers are installed.
     * 2)  Access to the special "jaxws.webmethod.exception"
     * 3)  Proper exception call flow when an unchecked exception is thrown.
     */
    public void testAddNumbersHandler_WithUnCheckedException() throws Exception {

        TestLogger.logger.debug("----------------------------------");
        TestLogger.logger.debug("test: " + getName());

        AddNumbersHandlerService service = new AddNumbersHandlerService();
        AddNumbersHandlerPortType proxy = service.getAddNumbersHandlerPort();

        BindingProvider p = (BindingProvider)proxy;
        p.getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, axisEndpoint);
        SOAPFaultException expectedException = null;
        Throwable t = null;
        try {
            proxy.addNumbersHandler(-1000, Integer.MIN_VALUE);
            
        } catch (Throwable e) {
            // An exception is expected
            t = e;
            
        } 
        
        // Make sure the proper exception is thrown
        if (t == null) {
            fail("Expected AddNumbersHandlerFault_Exception to be thrown");
        }
        if (t instanceof SOAPFaultException) {
            expectedException = (SOAPFaultException) t;
        } else {
            fail("Expected SOAPFaultException to be thrown, " +
                        "but the exception is: " + t);
        }
       
        // also confirm that @PreDestroy method is called.  Since it only makes sense to call it on the managed
        // (server) side and just before the handler instance goes out of scope, we are creating a file in the
        // @PreDestroy method, and will check for its existance here.  If the file does not exist, it means
        // @PreDestroy method was never called.  The file is set to .deleteOnExit(), so no need to delete it.
        File file = new File("AddNumbersProtocolHandler.preDestroy.txt");
        assertTrue("File AddNumbersProtocolHandler.preDestroy.txt does not exist, meaning the @PreDestroy method was not called.", file.exists());

        String log = readLogFile();
        String expected_calls =
            "AddNumbersLogicalHandler2 POST_CONSTRUCT\n"
            + "AddNumbersProtocolHandler2 GET_HEADERS\n"
            + "AddNumbersProtocolHandler GET_HEADERS\n"
            + "AddNumbersProtocolHandler HANDLE_MESSAGE_INBOUND\n"
            + "AddNumbersProtocolHandler2 HANDLE_MESSAGE_INBOUND\n"
            + "AddNumbersLogicalHandler2 HANDLE_MESSAGE_INBOUND\n"
            + "AddNumbersLogicalHandler HANDLE_MESSAGE_INBOUND\n"
            + "AddNumbersLogicalHandler HANDLE_FAULT_OUTBOUND\n"
            + "AddNumbersLogicalHandler2 HANDLE_FAULT_OUTBOUND\n"
            + "AddNumbersProtocolHandler2 HANDLE_FAULT_OUTBOUND\n"
            + "AddNumbersProtocolHandler HANDLE_FAULT_OUTBOUND\n"
            + "AddNumbersLogicalHandler CLOSE\n"
            + "AddNumbersLogicalHandler2 CLOSE\n"
            + "AddNumbersProtocolHandler2 CLOSE\n"
            + "AddNumbersProtocolHandler CLOSE\n"
            + "AddNumbersProtocolHandler PRE_DESTROY\n";
        
        assertEquals(expected_calls, log);
        
        // The outbound service handler adds the stack trace to the 
        // message.  Make sure the stack trace contains the AddNumbersHandlerPortTypeImpl
        
        TestLogger.logger.debug("Expected Exception is " + 
                                expectedException.getMessage());
        
        SOAPFault fault = expectedException.getFault();
        assertTrue("A stack trace was not present in the returned exception's message:" + 
                   fault.getFaultString(),
                   fault.getFaultString().indexOf("AddNumbersHandlerPortTypeImpl") > 0);
                   

        TestLogger.logger.debug("----------------------------------");
        
    }
    
    public void testAddNumbersHandlerDispatch() {
        try {
            QName serviceName =
                    new QName("http://org/test/addnumbershandler", "AddNumbersHandlerService");
            QName portName =
                    new QName("http://org/test/addnumbershandler", "AddNumbersHandlerPort");

            Service myService = Service.create(serviceName);
            
            myService.addPort(portName, null, axisEndpoint);
            Dispatch<Source> myDispatch = myService.createDispatch(portName, Source.class, 
                                                                   Service.Mode.MESSAGE);

            // set handler chain for binding provider
            Binding binding = ((BindingProvider) myDispatch).getBinding();

            // create a new list or use the existing one
            List<Handler> handlers = binding.getHandlerChain();
        
            if (handlers == null)
                handlers = new ArrayList<Handler>();
            handlers.add(new AddNumbersClientLogicalHandler());
            handlers.add(new AddNumbersClientProtocolHandler());
            binding.setHandlerChain(handlers);
            
            //Invoke the Dispatch
            TestLogger.logger.debug(">> Invoking Async Dispatch");
            Source response = myDispatch.invoke(createRequestSource());
            String resString = getString(response);
            if (!resString.contains("<return>16</return>")) {
                fail("Response string should contain <return>16</return>, but does not.  The resString was: \"" + resString + "\"");
            }
            
            String log = readLogFile();
            String expected_calls = "AddNumbersClientLogicalHandler HANDLE_MESSAGE_OUTBOUND\n"
                    + "AddNumbersClientProtocolHandler HANDLE_MESSAGE_OUTBOUND\n"
                    + "AddNumbersLogicalHandler2 POST_CONSTRUCT\n"
                    + "AddNumbersProtocolHandler2 GET_HEADERS\n"
                    + "AddNumbersProtocolHandler GET_HEADERS\n"
                    + "AddNumbersProtocolHandler HANDLE_MESSAGE_INBOUND\n"
                    + "AddNumbersProtocolHandler2 HANDLE_MESSAGE_INBOUND\n"
                    + "AddNumbersLogicalHandler2 HANDLE_MESSAGE_INBOUND\n"
                    + "AddNumbersLogicalHandler HANDLE_MESSAGE_INBOUND\n"
                    + "AddNumbersLogicalHandler HANDLE_MESSAGE_OUTBOUND\n"
                    + "AddNumbersLogicalHandler2 HANDLE_MESSAGE_OUTBOUND\n"
                    + "AddNumbersProtocolHandler2 HANDLE_MESSAGE_OUTBOUND\n"
                    + "AddNumbersProtocolHandler HANDLE_MESSAGE_OUTBOUND\n"
                    + "AddNumbersLogicalHandler CLOSE\n"
                    + "AddNumbersLogicalHandler2 CLOSE\n"
                    + "AddNumbersProtocolHandler2 CLOSE\n"
                    + "AddNumbersProtocolHandler CLOSE\n"
                    + "AddNumbersProtocolHandler PRE_DESTROY\n"
                    + "AddNumbersClientProtocolHandler GET_HEADERS\n"
                    + "AddNumbersClientProtocolHandler HANDLE_MESSAGE_INBOUND\n"
                    + "AddNumbersClientLogicalHandler HANDLE_MESSAGE_INBOUND\n"
                    + "AddNumbersClientProtocolHandler CLOSE\n"
                    + "AddNumbersClientLogicalHandler CLOSE\n";
            assertEquals(expected_calls, log);
            
            TestLogger.logger.debug("----------------------------------");
        } catch (Exception e) {
            e.printStackTrace();
            fail();
        }
    }
    
    public void testAddNumbersHandlerDispatchMyResolver() {
        try {
            QName serviceName =
                    new QName("http://org/test/addnumbershandler", "AddNumbersHandlerService");
            QName portName =
                    new QName("http://org/test/addnumbershandler", "AddNumbersHandlerPort");

            Service myService = Service.create(serviceName);
            
            myService.setHandlerResolver(new MyHandlerResolver());
            
            myService.addPort(portName, null, axisEndpoint);
            Dispatch<Source> myDispatch = myService.createDispatch(portName, Source.class, 
                                                                   Service.Mode.MESSAGE);

            //Invoke the Dispatch
            TestLogger.logger.debug(">> Invoking Async Dispatch");
            Source response = myDispatch.invoke(createRequestSource());
            String resString = getString(response);
            if (!resString.contains("<return>16</return>")) {
                fail("Response string should contain <return>16</return>, but does not.  The resString was: \"" + resString + "\"");
            }
            
            String log = readLogFile();
            String expected_calls = "AddNumbersClientLogicalHandler HANDLE_MESSAGE_OUTBOUND\n"
                + "AddNumbersClientProtocolHandler HANDLE_MESSAGE_OUTBOUND\n"
                + "AddNumbersLogicalHandler2 POST_CONSTRUCT\n"
                + "AddNumbersProtocolHandler2 GET_HEADERS\n"
                + "AddNumbersProtocolHandler GET_HEADERS\n"
                + "AddNumbersProtocolHandler HANDLE_MESSAGE_INBOUND\n"
                + "AddNumbersProtocolHandler2 HANDLE_MESSAGE_INBOUND\n"
                + "AddNumbersLogicalHandler2 HANDLE_MESSAGE_INBOUND\n"
                + "AddNumbersLogicalHandler HANDLE_MESSAGE_INBOUND\n"
                + "AddNumbersLogicalHandler HANDLE_MESSAGE_OUTBOUND\n"
                + "AddNumbersLogicalHandler2 HANDLE_MESSAGE_OUTBOUND\n"
                + "AddNumbersProtocolHandler2 HANDLE_MESSAGE_OUTBOUND\n"
                + "AddNumbersProtocolHandler HANDLE_MESSAGE_OUTBOUND\n"
                + "AddNumbersLogicalHandler CLOSE\n"
                + "AddNumbersLogicalHandler2 CLOSE\n"
                + "AddNumbersProtocolHandler2 CLOSE\n"
                + "AddNumbersProtocolHandler CLOSE\n"
                + "AddNumbersProtocolHandler PRE_DESTROY\n"
                + "AddNumbersClientProtocolHandler GET_HEADERS\n"
                + "AddNumbersClientProtocolHandler HANDLE_MESSAGE_INBOUND\n"
                + "AddNumbersClientLogicalHandler HANDLE_MESSAGE_INBOUND\n"
                + "AddNumbersClientProtocolHandler CLOSE\n"
                + "AddNumbersClientLogicalHandler CLOSE\n";
            assertEquals(expected_calls, log);
            
            TestLogger.logger.debug("----------------------------------");
        } catch (Exception e) {
            e.printStackTrace();
            fail();
        }
    }
    
    /*
     * JAXWS 9.2.1.1 conformance test
     */
    public void testAddNumbersHandlerResolver() {
        try {
            TestLogger.logger.debug("----------------------------------");
            TestLogger.logger.debug("test: " + getName());

            AddNumbersHandlerService service = new AddNumbersHandlerService();

            AddNumbersHandlerPortType proxy = service.getAddNumbersHandlerPort();
            
            service.setHandlerResolver(new MyHandlerResolver());

            BindingProvider p = (BindingProvider) proxy;
            
            /*
             * despite setting MyHandlerResolver on the service, we should get an empty
             * list from the getBinding().getHandlerChain() call below.  JAXWS 9.2.1.1 conformance
             */
            List<Handler> list = p.getBinding().getHandlerChain();
            
            assertTrue("List should be empty.  We've not conformed to JAXWS 9.2.1.1.", list.isEmpty());
            String log = readLogFile();
            assertNull("log should be empty, since no handlers are in the list and we never called a service", log);
            
            TestLogger.logger.debug("----------------------------------");
        } catch (Exception e) {
            e.printStackTrace();
            fail(e.getMessage());
        }
    }

    public void testAddNumbersHandlerWithFault() {
        try{
            TestLogger.logger.debug("----------------------------------");
            TestLogger.logger.debug("test: " + getName());
            
            AddNumbersHandlerService service = new AddNumbersHandlerService();
            AddNumbersHandlerPortType proxy = service.getAddNumbersHandlerPort();
            
            BindingProvider p = (BindingProvider)proxy;
            p.getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, 
                    axisEndpoint);  
            // value 99 triggers the handler to throw an exception, but does
            // NOT trigger the AddNumbersHandler.handlefault method.
            // The spec does not call the handlefault method of a handler that
            // causes a flow reversal
            int total = proxy.addNumbersHandler(99,10);
            
            fail("We should have got an exception due to the handler.");
        } catch(Exception e) {
            e.printStackTrace();
            assertTrue("Exception should be SOAPFaultException", e instanceof SOAPFaultException);
            assertEquals(((SOAPFaultException)e).getMessage(), "I don't like the value 99");
            
            String log = readLogFile();
            String expected_calls = "AddNumbersLogicalHandler2 POST_CONSTRUCT\n"
                + "AddNumbersProtocolHandler2 GET_HEADERS\n"
                + "AddNumbersProtocolHandler GET_HEADERS\n"
                + "AddNumbersProtocolHandler HANDLE_MESSAGE_INBOUND\n"
                + "AddNumbersProtocolHandler2 HANDLE_MESSAGE_INBOUND\n"
                + "AddNumbersLogicalHandler2 HANDLE_MESSAGE_INBOUND\n"
                + "AddNumbersLogicalHandler2 THROWING PROTOCOLEXCEPTION INBOUND\n"
                + "AddNumbersProtocolHandler2 HANDLE_FAULT_OUTBOUND\n"
                + "AddNumbersProtocolHandler HANDLE_FAULT_OUTBOUND\n"
                + "AddNumbersLogicalHandler2 CLOSE\n"
                + "AddNumbersProtocolHandler2 CLOSE\n"
                + "AddNumbersProtocolHandler CLOSE\n"
                + "AddNumbersProtocolHandler PRE_DESTROY\n";
            assertEquals(expected_calls, log);
        }
        TestLogger.logger.debug("----------------------------------");
    }


    /**
     * testAddNumbersClientHandler performs the same tests as testAddNumbersHandler, except
     * that two client-side handlers are also inserted into the flow.  The inbound AddNumbersClientLogicalHandler
     * checks that the properties set here in this method (the client app) and the properties set in the
     * outbound AddNumbersClientProtocolHandler are accessible.  These properties are also checked here in
     * the client app.  AddNumbersClientLogicalHandler also subtracts 1 from the sum on the inbound flow.
     */
    public void testAddNumbersClientHandler() {
        try{
            TestLogger.logger.debug("----------------------------------");
            TestLogger.logger.debug("test: " + getName());
            
            AddNumbersHandlerService service = new AddNumbersHandlerService();
            AddNumbersHandlerPortType proxy = service.getAddNumbersHandlerPort();
            
            BindingProvider p = (BindingProvider)proxy;
            
            p.getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, 
                    axisEndpoint);
            p.getRequestContext().put("myClientKey", "myClientVal");

            List<Handler> handlers = p.getBinding().getHandlerChain();
            if (handlers == null)
                handlers = new ArrayList<Handler>();
            handlers.add(new AddNumbersClientLogicalHandler());
            handlers.add(new AddNumbersClientProtocolHandler());
            p.getBinding().setHandlerChain(handlers);

            int total = proxy.addNumbersHandler(10,10);
            
            // see if I can get an APPLICATION scoped property set during outbound flow.  I should be able to do this according to 4.2.1
            
            // TODO:  assert is now commented out.  This property is set by a client outbound handler, and I don't think it
            // should be available on the request or response contexts.
            //assertNotNull("Should be able to retrieve APPLICATION scoped property, but could not.", ((String)p.getRequestContext().get("AddNumbersClientProtocolHandlerOutboundAppScopedProperty")));

            // should NOT be able to get this HANDLER scoped property though
            assertNull("Should not be able to retrieve HANDLER scoped property, but was able.", (String)p.getResponseContext().get("AddNumbersClientProtocolHandlerOutboundHandlerScopedProperty"));
            // should be able to get this APPLICATION scoped property set during inbound flow
            assertNotNull("Should be able to retrieve APPLICATION scoped property, but could not.", (String)p.getResponseContext().get("AddNumbersClientProtocolHandlerInboundAppScopedProperty"));
            // should NOT be able to get this HANDLER scoped property though
            assertNull("Should not be able to retrieve HANDLER scoped property, but was able.", (String)p.getResponseContext().get("AddNumbersClientProtocolHandlerInboundHandlerScopedProperty"));
            // should be able to get this APPLICATION scoped property set by this client
            assertNotNull("Should be able to retrieve APPLICATION scoped property, but could not.", (String)p.getRequestContext().get("myClientKey"));

            assertEquals("With handler manipulation, total should be 4 less than a proper sumation.", 16, total);
            TestLogger.logger.debug("Total (after handler manipulation) = " + total);
            
            String log = readLogFile();
            String expected_calls = "AddNumbersClientLogicalHandler HANDLE_MESSAGE_OUTBOUND\n"
                + "AddNumbersClientProtocolHandler HANDLE_MESSAGE_OUTBOUND\n"
                + "AddNumbersLogicalHandler2 POST_CONSTRUCT\n"
                + "AddNumbersProtocolHandler2 GET_HEADERS\n"
                + "AddNumbersProtocolHandler GET_HEADERS\n"
                + "AddNumbersProtocolHandler HANDLE_MESSAGE_INBOUND\n"
                + "AddNumbersProtocolHandler2 HANDLE_MESSAGE_INBOUND\n"
                + "AddNumbersLogicalHandler2 HANDLE_MESSAGE_INBOUND\n"
                + "AddNumbersLogicalHandler HANDLE_MESSAGE_INBOUND\n"
                + "AddNumbersLogicalHandler HANDLE_MESSAGE_OUTBOUND\n"
                + "AddNumbersLogicalHandler2 HANDLE_MESSAGE_OUTBOUND\n"
                + "AddNumbersProtocolHandler2 HANDLE_MESSAGE_OUTBOUND\n"
                + "AddNumbersProtocolHandler HANDLE_MESSAGE_OUTBOUND\n"
                + "AddNumbersLogicalHandler CLOSE\n"
                + "AddNumbersLogicalHandler2 CLOSE\n"
                + "AddNumbersProtocolHandler2 CLOSE\n"
                + "AddNumbersProtocolHandler CLOSE\n"
                + "AddNumbersProtocolHandler PRE_DESTROY\n"
                + "AddNumbersClientProtocolHandler GET_HEADERS\n"
                + "AddNumbersClientProtocolHandler HANDLE_MESSAGE_INBOUND\n"
                + "AddNumbersClientLogicalHandler HANDLE_MESSAGE_INBOUND\n"
                + "AddNumbersClientProtocolHandler CLOSE\n"
                + "AddNumbersClientLogicalHandler CLOSE\n";
            assertEquals(expected_calls, log);
            
            TestLogger.logger.debug("----------------------------------");
        } catch(Exception e) {
            e.printStackTrace();
            fail();
        }
    }
    
    /*
     * uses a custom HandlerResolver instead of the default.  MyHandlerResolver
     * puts the AddNumbersClientLogicalHandler and AddNumbersClientProtocolHandler
     * in the flow.  Results should be the same as testAddNumbersClientHandler.
     */
    public void testAddNumbersClientHandlerMyResolver() {
        try{
            TestLogger.logger.debug("----------------------------------");
            TestLogger.logger.debug("test: " + getName());
            
            AddNumbersHandlerService service = new AddNumbersHandlerService();
            service.setHandlerResolver(new MyHandlerResolver());
            
            AddNumbersHandlerPortType proxy = service.getAddNumbersHandlerPort();
            
            BindingProvider p = (BindingProvider)proxy;
            
            p.getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, 
                    axisEndpoint);

            int total = proxy.addNumbersHandler(10,10);
            
            assertEquals("With handler manipulation, total should be 4 less than a proper sumation.",
                         16,
                         total);
            TestLogger.logger.debug("Total (after handler manipulation) = " + total);
            
            String log = readLogFile();
            String expected_calls = "AddNumbersClientLogicalHandler HANDLE_MESSAGE_OUTBOUND\n"
                + "AddNumbersClientProtocolHandler HANDLE_MESSAGE_OUTBOUND\n"
                + "AddNumbersLogicalHandler2 POST_CONSTRUCT\n"
                + "AddNumbersProtocolHandler2 GET_HEADERS\n"
                + "AddNumbersProtocolHandler GET_HEADERS\n"
                + "AddNumbersProtocolHandler HANDLE_MESSAGE_INBOUND\n"
                + "AddNumbersProtocolHandler2 HANDLE_MESSAGE_INBOUND\n"
                + "AddNumbersLogicalHandler2 HANDLE_MESSAGE_INBOUND\n"
                + "AddNumbersLogicalHandler HANDLE_MESSAGE_INBOUND\n"
                + "AddNumbersLogicalHandler HANDLE_MESSAGE_OUTBOUND\n"
                + "AddNumbersLogicalHandler2 HANDLE_MESSAGE_OUTBOUND\n"
                + "AddNumbersProtocolHandler2 HANDLE_MESSAGE_OUTBOUND\n"
                + "AddNumbersProtocolHandler HANDLE_MESSAGE_OUTBOUND\n"
                + "AddNumbersLogicalHandler CLOSE\n"
                + "AddNumbersLogicalHandler2 CLOSE\n"
                + "AddNumbersProtocolHandler2 CLOSE\n"
                + "AddNumbersProtocolHandler CLOSE\n"
                + "AddNumbersProtocolHandler PRE_DESTROY\n"
                + "AddNumbersClientProtocolHandler GET_HEADERS\n"
                + "AddNumbersClientProtocolHandler HANDLE_MESSAGE_INBOUND\n"
                + "AddNumbersClientLogicalHandler HANDLE_MESSAGE_INBOUND\n"
                + "AddNumbersClientProtocolHandler CLOSE\n"
                + "AddNumbersClientLogicalHandler CLOSE\n";
            assertEquals(expected_calls, log);
            
            TestLogger.logger.debug("----------------------------------");
        } catch(Exception e) {
            e.printStackTrace();
            fail();
        }
    }
    
    public void testAddNumbersClientProtoAndLogicalHandler() {
        try{
            TestLogger.logger.debug("----------------------------------");
            TestLogger.logger.debug("test: " + getName());
            
            AddNumbersHandlerService service = new AddNumbersHandlerService();
            AddNumbersHandlerPortType proxy = service.getAddNumbersHandlerPort();
            
            BindingProvider p = (BindingProvider)proxy;
            
            p.getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, 
                    axisEndpoint);

            List<Handler> handlers = p.getBinding().getHandlerChain();
            if (handlers == null)
                handlers = new ArrayList<Handler>();
            handlers.add(new AddNumbersClientLogicalHandler());
            handlers.add(new AddNumbersClientProtocolHandler());
            p.getBinding().setHandlerChain(handlers);

            // value 102 triggers an endpoint exception, which will run through the server outbound
            // handleFault methods, then client inbound handleFault methods
            int total = proxy.addNumbersHandler(102,10);
            
            fail("should have got an exception, but didn't");
        } catch(Exception e) {
            e.printStackTrace();
            assertTrue("Exception should be SOAPFaultException", e instanceof SOAPFaultException);
            //AXIS2-2417 - assertEquals(((SOAPFaultException)e).getMessage(), "AddNumbersLogicalHandler2 was here");
            assertTrue(((SOAPFaultException)e).getMessage().contains("Got value 101.  " +
            		"AddNumbersHandlerPortTypeImpl.addNumbersHandler method is " +
            		"correctly throwing this exception as part of testing"));
            
            String log = readLogFile();
            String expected_calls = "AddNumbersClientLogicalHandler HANDLE_MESSAGE_OUTBOUND\n"
                + "AddNumbersClientProtocolHandler HANDLE_MESSAGE_OUTBOUND\n"
                + "AddNumbersLogicalHandler2 POST_CONSTRUCT\n"
                + "AddNumbersProtocolHandler2 GET_HEADERS\n"
                + "AddNumbersProtocolHandler GET_HEADERS\n"
                + "AddNumbersProtocolHandler HANDLE_MESSAGE_INBOUND\n"
                + "AddNumbersProtocolHandler2 HANDLE_MESSAGE_INBOUND\n"
                + "AddNumbersLogicalHandler2 HANDLE_MESSAGE_INBOUND\n"
                + "AddNumbersLogicalHandler HANDLE_MESSAGE_INBOUND\n"
                + "AddNumbersLogicalHandler HANDLE_FAULT_OUTBOUND\n"
                + "AddNumbersLogicalHandler2 HANDLE_FAULT_OUTBOUND\n"
                + "AddNumbersProtocolHandler2 HANDLE_FAULT_OUTBOUND\n"
                + "AddNumbersProtocolHandler HANDLE_FAULT_OUTBOUND\n"
                + "AddNumbersLogicalHandler CLOSE\n"
                + "AddNumbersLogicalHandler2 CLOSE\n"
                + "AddNumbersProtocolHandler2 CLOSE\n"
                + "AddNumbersProtocolHandler CLOSE\n"
                + "AddNumbersProtocolHandler PRE_DESTROY\n"
                + "AddNumbersClientProtocolHandler GET_HEADERS\n"
                + "AddNumbersClientProtocolHandler HANDLE_FAULT_INBOUND\n"
                + "AddNumbersClientLogicalHandler HANDLE_FAULT_INBOUND\n"
                + "AddNumbersClientProtocolHandler CLOSE\n"
                + "AddNumbersClientLogicalHandler CLOSE\n";
            assertEquals(expected_calls, log);
            
        }
        TestLogger.logger.debug("----------------------------------");
    }
    
    public void testAddNumbersClientHandlerWithFault() {
        try{
            TestLogger.logger.debug("----------------------------------");
            TestLogger.logger.debug("test: " + getName());
            
            AddNumbersHandlerService service = new AddNumbersHandlerService();
            AddNumbersHandlerPortType proxy = service.getAddNumbersHandlerPort();
            
            BindingProvider p = (BindingProvider)proxy;
            
            p.getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, 
                    axisEndpoint);

            List<Handler> handlers = p.getBinding().getHandlerChain();
            if (handlers == null)
                handlers = new ArrayList<Handler>();
            handlers.add(new AddNumbersClientLogicalHandler4());
            handlers.add(new AddNumbersClientLogicalHandler3());
            handlers.add(new AddNumbersClientLogicalHandler());
            
            p.getBinding().setHandlerChain(handlers);

            int total = proxy.addNumbersHandler(99,10);
            
            fail("Should have got an exception, but we didn't.");
        } catch(Exception e) {
            e.printStackTrace();
            assertTrue("Exception should be SOAPFaultException", e instanceof SOAPFaultException);
            assertEquals("I don't like the value 99", ((SOAPFaultException)e).getMessage());
            
            String log = readLogFile();
            String expected_calls = "AddNumbersClientLogicalHandler4 HANDLE_MESSAGE_OUTBOUND\n"
                + "AddNumbersClientLogicalHandler3 HANDLE_FAULT_OUTBOUND\n"
                + "AddNumbersClientLogicalHandler HANDLE_MESSAGE_OUTBOUND\n"
                + "AddNumbersClientLogicalHandler3 HANDLE_FAULT_INBOUND\n"
                + "AddNumbersClientLogicalHandler3 RETURNING FALSE INBOUND\n"
                + "AddNumbersClientLogicalHandler CLOSE\n"
                + "AddNumbersClientLogicalHandler3 CLOSE\n"
                + "AddNumbersClientLogicalHandler4 CLOSE\n";
            assertEquals(expected_calls, log);
            
        }
        TestLogger.logger.debug("----------------------------------");
    }

    /**
     * test results should be the same as testAddNumbersClientHandler, except that
     * AddNumbersClientLogicalHandler2 doubles the first param on outbound.  Async, of course.
     *
     */
    public void testAddNumbersClientHandlerAsync() {
        try{
            TestLogger.logger.debug("----------------------------------");
            TestLogger.logger.debug("test: " + getName());
            
            AddNumbersHandlerService service = new AddNumbersHandlerService();
            AddNumbersHandlerPortType proxy = service.getAddNumbersHandlerPort();
            
            BindingProvider p = (BindingProvider)proxy;
            
            p.getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, 
                    axisEndpoint);

            List<Handler> handlers = p.getBinding().getHandlerChain();
            if (handlers == null)
                handlers = new ArrayList<Handler>();
            handlers.add(new AddNumbersClientLogicalHandler());
            handlers.add(new AddNumbersClientLogicalHandler2());
            handlers.add(new AddNumbersClientProtocolHandler());
            p.getBinding().setHandlerChain(handlers);

            
            AddNumbersHandlerAsyncCallback callback = new AddNumbersHandlerAsyncCallback();
            Future<?> future = proxy.addNumbersHandlerAsync(10, 10, callback);

            while (!future.isDone()) {
                Thread.sleep(1000);
                TestLogger.logger.debug("Async invocation incomplete");
            }
            
            int total = callback.getResponseValue();
            
            assertEquals("With handler manipulation, total should be 26.", 26, total);
            TestLogger.logger.debug("Total (after handler manipulation) = " + total);
            
            String log = readLogFile();
            String expected_calls = "AddNumbersClientLogicalHandler HANDLE_MESSAGE_OUTBOUND\n"
                + "AddNumbersClientLogicalHandler2 HANDLE_MESSAGE_OUTBOUND\n"
                + "AddNumbersClientProtocolHandler HANDLE_MESSAGE_OUTBOUND\n"
                + "AddNumbersLogicalHandler2 POST_CONSTRUCT\n"
                + "AddNumbersProtocolHandler2 GET_HEADERS\n"
                + "AddNumbersProtocolHandler GET_HEADERS\n"
                + "AddNumbersProtocolHandler HANDLE_MESSAGE_INBOUND\n"
                + "AddNumbersProtocolHandler2 HANDLE_MESSAGE_INBOUND\n"
                + "AddNumbersLogicalHandler2 HANDLE_MESSAGE_INBOUND\n"
                + "AddNumbersLogicalHandler HANDLE_MESSAGE_INBOUND\n"
                + "AddNumbersLogicalHandler HANDLE_MESSAGE_OUTBOUND\n"
                + "AddNumbersLogicalHandler2 HANDLE_MESSAGE_OUTBOUND\n"
                + "AddNumbersProtocolHandler2 HANDLE_MESSAGE_OUTBOUND\n"
                + "AddNumbersProtocolHandler HANDLE_MESSAGE_OUTBOUND\n"
                + "AddNumbersLogicalHandler CLOSE\n"
                + "AddNumbersLogicalHandler2 CLOSE\n"
                + "AddNumbersProtocolHandler2 CLOSE\n"
                + "AddNumbersProtocolHandler CLOSE\n"
                + "AddNumbersProtocolHandler PRE_DESTROY\n"
                + "AddNumbersClientProtocolHandler GET_HEADERS\n"
                + "AddNumbersClientProtocolHandler HANDLE_MESSAGE_INBOUND\n"
                + "AddNumbersClientLogicalHandler2 HANDLE_MESSAGE_INBOUND\n"
                + "AddNumbersClientLogicalHandler HANDLE_MESSAGE_INBOUND\n"
                + "AddNumbersClientProtocolHandler CLOSE\n"
                + "AddNumbersClientLogicalHandler2 CLOSE\n"
                + "AddNumbersClientLogicalHandler CLOSE\n";
            assertEquals(expected_calls, log);
            
            TestLogger.logger.debug("----------------------------------");
        } catch(Exception e) {
            e.printStackTrace();
            fail(e.toString());
        }
    }
    
    public void testAddNumbersHandlerHandlerResolver() {
        try {
            System.out.println("----------------------------------");
            System.out.println("test: " + getName());
            AddNumbersHandlerService service = new AddNumbersHandlerService(); // will give NPE:
            List<Handler> handlers = service.getHandlerResolver()
                    .getHandlerChain(null);
            assertNotNull(
                    "Default handlers list should not be null but empty.",
                    handlers);
            
            String log = readLogFile();
            assertNull("log should be null since we did not call any services", log);
        } catch (Exception e) {
            e.printStackTrace();
            fail(e.getMessage());
        }
        TestLogger.logger.debug("----------------------------------");
    } 
    
    public void testOneWay() {
        try {
            TestLogger.logger.debug("----------------------------------");
            TestLogger.logger.debug("test: " + getName());
            
            AddNumbersHandlerService service = new AddNumbersHandlerService();
            AddNumbersHandlerPortType proxy = service.getAddNumbersHandlerPort();
            
            BindingProvider bp = (BindingProvider) proxy;
            bp.getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, 
                    axisEndpoint);
            proxy.oneWayInt(11);
            
            // one-way invocations run in their own thread,
            // and we can't tell here in the client when it
            // has completed.  So, we need to wait long enough
            // for the invocation to complete, so our log file
            // is fully populated.
            Thread.sleep(1000 * 5); // 5 seconds
            
            String log = readLogFile();
            String expected_calls = "AddNumbersLogicalHandler2 POST_CONSTRUCT\n"
                + "AddNumbersProtocolHandler2 GET_HEADERS\n"
                + "AddNumbersProtocolHandler GET_HEADERS\n"
                + "AddNumbersProtocolHandler HANDLE_MESSAGE_INBOUND\n"
                + "AddNumbersProtocolHandler2 HANDLE_MESSAGE_INBOUND\n"
                + "AddNumbersLogicalHandler2 HANDLE_MESSAGE_INBOUND\n"
                + "AddNumbersLogicalHandler HANDLE_MESSAGE_INBOUND\n"
                + "AddNumbersLogicalHandler CLOSE\n"
                + "AddNumbersLogicalHandler2 CLOSE\n"
                + "AddNumbersProtocolHandler2 CLOSE\n"
                + "AddNumbersProtocolHandler CLOSE\n";
            assertEquals(expected_calls, log);

        } catch (Exception e) {
            e.printStackTrace();
            fail(e.getMessage());
        }
        TestLogger.logger.debug("----------------------------------");
    }
    
    public void testOneWayWithProtocolException() {
        Exception exception = null;
        try {
            TestLogger.logger.debug("----------------------------------");
            TestLogger.logger.debug("test: " + getName());

            AddNumbersHandlerService service = new AddNumbersHandlerService();
            AddNumbersHandlerPortType proxy = service.getAddNumbersHandlerPort();

            BindingProvider p = (BindingProvider) proxy;

            p.getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, axisEndpoint);
            p.getRequestContext().put("myClientKey", "myClientVal");

            List<Handler> handlers = p.getBinding().getHandlerChain();
            if (handlers == null)
                handlers = new ArrayList<Handler>();
            handlers.add(new AddNumbersClientLogicalHandler());
            handlers.add(new AddNumbersClientProtocolHandler());
            p.getBinding().setHandlerChain(handlers);
            
            BindingProvider bp = (BindingProvider) proxy;
            bp.getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, axisEndpoint);
            // value 99 will trigger exception from AddNumbersClientLogicalHandler
            proxy.oneWayInt(99);
        } catch (Exception e) {            
            e.printStackTrace();
            exception = e;
        }
        
        // exceptions on one-way invocations are suppressed by default
        assertNull(exception);
            
        // one-way invocations run in their own thread,
        // and we can't tell here in the client when it
        // has completed.  So, we need to wait long enough
        // for the invocation to complete, so our log file
        // is fully populated.
        try {
            Thread.sleep(1000 * 5); // 5 seconds
        } catch (InterruptedException ie) {
            // nothing
        }
            
        String log = readLogFile();
        String expected_calls = "AddNumbersClientLogicalHandler HANDLE_MESSAGE_OUTBOUND\n"
                + "AddNumbersClientLogicalHandler CLOSE\n";
        assertEquals(expected_calls, log);
                    
        TestLogger.logger.debug("----------------------------------");
    }
    
    public void testOneWayWithRuntimeException() {
        Exception exception = null;
        try {
            TestLogger.logger.debug("----------------------------------");
            TestLogger.logger.debug("test: " + getName());

            AddNumbersHandlerService service = new AddNumbersHandlerService();
            AddNumbersHandlerPortType proxy = service.getAddNumbersHandlerPort();

            BindingProvider p = (BindingProvider) proxy;

            p.getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, axisEndpoint);
            p.getRequestContext().put("myClientKey", "myClientVal");

            List<Handler> handlers = p.getBinding().getHandlerChain();
            if (handlers == null)
                handlers = new ArrayList<Handler>();
            handlers.add(new AddNumbersClientLogicalHandler());
            handlers.add(new AddNumbersClientProtocolHandler());
            p.getBinding().setHandlerChain(handlers);
            
            BindingProvider bp = (BindingProvider) proxy;
            bp.getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, axisEndpoint);
            // value 99 will trigger exception from AddNumbersClientLogicalHandler
            proxy.oneWayInt(999);
        } catch (Exception e) {
            e.printStackTrace();
            exception = e;
        }
        
        // exceptions on one-way invocations are suppressed by default
        assertNull(exception);            
            
        // one-way invocations run in their own thread,
        // and we can't tell here in the client when it
        // has completed.  So, we need to wait long enough
        // for the invocation to complete, so our log file
        // is fully populated.
        try {
            Thread.sleep(1000 * 5); // 5 seconds
        } catch (InterruptedException ie) {
            // nothing
        }
            
        String log = readLogFile();
        String expected_calls = "AddNumbersClientLogicalHandler HANDLE_MESSAGE_OUTBOUND\n"
                + "AddNumbersClientLogicalHandler CLOSE\n";
        assertEquals(expected_calls, log);
        
        TestLogger.logger.debug("----------------------------------");
    }


    /*
     * A callback implementation that can be used to collect the exceptions
     */
    class AddNumbersHandlerAsyncCallback implements AsyncHandler<AddNumbersHandlerResponse> {
     
        private Exception exception;
        private int retVal;
        
        public void handleResponse(Response<AddNumbersHandlerResponse> response) {
            try {
                TestLogger.logger.debug("FaultyAsyncHandler.handleResponse() was called");
                AddNumbersHandlerResponse r = response.get();
                TestLogger.logger.debug("No exception was thrown from Response.get()");
                retVal = r.getReturn();
            }
            catch (Exception e) {
                TestLogger.logger.debug("An exception was thrown: " + e.getClass());
                exception = e;
            }
        }
        
        public int getResponseValue() {
            return retVal;
        }
        
        public Exception getException() {
            return exception;
        }
    }
    
    class MyHandlerResolver implements HandlerResolver {

        public List<Handler> getHandlerChain(PortInfo portinfo) {
            ArrayList<Handler> handlers = new ArrayList<Handler>();
            handlers.add(new AddNumbersClientLogicalHandler());
            handlers.add(new AddNumbersClientProtocolHandler());
            return handlers;
        }

    }
    
    private String getString(Source source) throws Exception {
        if (source == null) {
            return null;
        }
        StringWriter writer = new StringWriter();
        Transformer t = TransformerFactory.newInstance().newTransformer();
        Result result = new StreamResult(writer);
        t.transform(source, result);
        return writer.getBuffer().toString();

    }
    
    /**
     * Create a Source request to be used by Dispatch<Source>
     */
    private Source createRequestSource() throws IOException {
        FileInputStream fis = new FileInputStream(requestFile);
        return new StreamSource(fis);
    }
    
    protected void setUp() {
        File file = new File(filelogname);
        file.delete();  // yes, delete for each retrieval, which should only happen once per test
    }
    
    private String readLogFile() {
        try {
            FileReader fr = new FileReader(filelogname);
            BufferedReader inputStream = new BufferedReader(fr);
            String line = null;
            String ret = null;
            while ((line = inputStream.readLine()) != null) {
                if (ret == null) {
                    ret = "";
                }
                ret = ret.concat(line + "\n");
            }
            fr.close();
            return ret;
        } catch (FileNotFoundException fnfe) {
            // it's possible the test does not actually call any handlers and therefore
            // no file would have been written.  The test should account for this by
            // assertNull on the return value from here
        } catch (IOException ioe) {
            ioe.printStackTrace();
            fail(ioe.getMessage());
        }
        return null;
    }

}
