/*
 * 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.spi;

import junit.framework.TestCase;
import org.apache.axis2.jaxws.description.builder.DescriptionBuilderComposite;
import org.apache.axis2.jaxws.description.impl.DescriptionUtils;
import org.apache.axis2.jaxws.description.xml.handler.HandlerChainsType;

import javax.jws.HandlerChain;
import javax.jws.WebService;
import javax.xml.namespace.QName;
import javax.xml.ws.Service;
import javax.xml.ws.WebServiceClient;
import javax.xml.ws.handler.Handler;
import javax.xml.ws.handler.HandlerResolver;
import javax.xml.ws.handler.PortInfo;
import javax.xml.ws.soap.SOAPBinding;
import java.io.File;
import java.io.InputStream;
import java.net.URL;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * Verify that handler chains specified using the HandlerChainsType in a sparse
 * composite are correctly applied to Services and Ports on the client requester. 
 */
public class ClientMetadataHandlerChainTest extends TestCase {
    
    static String namespaceURI = "http://www.apache.org/test/namespace";
    static String svcLocalPart = "DummyService";
    static private String portLocalPart = "DummyPort";
    private static int uniqueService = 0;
    
    /**
     *  Test creating a service without a sparse composite.  This verifies pre-existing default
     *  behavior.
     */
    public void testServiceAndPortNoComposite() {
        QName serviceQName = new QName(namespaceURI, svcLocalPart);
        QName portQName = new QName(namespaceURI, portLocalPart);

        Service service = Service.create(serviceQName);
        HandlerResolver resolver = service.getHandlerResolver();
        assertNotNull(resolver);
        PortInfo pi = new DummyPortInfo();
        List<Handler> list = resolver.getHandlerChain(pi);
        assertEquals(0, list.size());
        
        ClientMetadataHandlerChainTestSEI port = service.getPort(portQName, ClientMetadataHandlerChainTestSEI.class);
        // Verify that ports created under the service have no handlers from the sparse composite
        BindingProvider bindingProvider = (BindingProvider) port;
        Binding binding = (Binding) bindingProvider.getBinding();
        List<Handler> portHandlers = binding.getHandlerChain();
        assertEquals(0, portHandlers.size());
    }

    /**
     * Test creating a service with a sparse composite that contains handler configuration
     * information for this service delegate.  Verify that the handlers are included in the 
     * chain.
     */
    public void testServiceWithComposite() {
        QName serviceQName = new QName(namespaceURI, svcLocalPart);
        QName portQName = new QName(namespaceURI, portLocalPart);
        // Create a composite with a JAXB Handler Config 
        DescriptionBuilderComposite sparseComposite = new DescriptionBuilderComposite();
        HandlerChainsType handlerChainsType = getHandlerChainsType();
        sparseComposite.setHandlerChainsType(handlerChainsType);

        ServiceDelegate.setServiceMetadata(sparseComposite);
        Service service = Service.create(serviceQName);
        ClientMetadataHandlerChainTestSEI port = service.getPort(portQName, ClientMetadataHandlerChainTestSEI.class);

        // Verify the HandlerResolver on the service knows about the handlers in the sparse composite
        HandlerResolver resolver = service.getHandlerResolver();
        assertNotNull(resolver);
        PortInfo pi = new DummyPortInfo();
        List<Handler> list = resolver.getHandlerChain(pi);
        assertEquals(2, list.size());
        
        // Verify that ports created under the service have handlers
        BindingProvider bindingProvider = (BindingProvider) port;
        Binding binding = (Binding) bindingProvider.getBinding();
        List<Handler> portHandlers = binding.getHandlerChain();
        assertEquals(2, portHandlers.size());
        assertTrue(containSameHandlers(portHandlers, list));
        
        // Verify that a subsequent port are different and that they also gets the correct handlers
        ClientMetadataHandlerChainTestSEI port2 = service.getPort(portQName, ClientMetadataHandlerChainTestSEI.class);
        BindingProvider bindingProvider2 = (BindingProvider) port2;
        Binding binding2 = (Binding) bindingProvider2.getBinding();
        List<Handler> portHandlers2 = binding2.getHandlerChain();
        assertNotSame(port, port2);
        assertEquals(2, portHandlers2.size());
        assertTrue(containSameHandlers(portHandlers2, list));
    }
    
    /**
     * Set a sparse composite on a specific Port.  Verify that instances of that Port have the
     * correct handlers associated and other Ports do not.
     */
    public void testPortWithComposite() {
        QName serviceQName = new QName(namespaceURI, svcLocalPart);
        QName portQName = new QName(namespaceURI, portLocalPart);

        Service service = Service.create(serviceQName);
        
        // Create a composite with a JAXB Handler Config 
        DescriptionBuilderComposite sparseComposite = new DescriptionBuilderComposite();
        HandlerChainsType handlerChainsType = getHandlerChainsType();
        sparseComposite.setHandlerChainsType(handlerChainsType);
        ServiceDelegate.setPortMetadata(sparseComposite);
        ClientMetadataHandlerChainTestSEI port = service.getPort(portQName, ClientMetadataHandlerChainTestSEI.class);

        // Verify the HandlerResolver on the service knows about the handlers in the sparse composite
        HandlerResolver resolver = service.getHandlerResolver();
        assertNotNull(resolver);
        PortInfo pi = new DummyPortInfo();
        List<Handler> list = resolver.getHandlerChain(pi);
        assertEquals(2, list.size());
        
        // Verify that the port created with the sparse metadata has those handlers
        BindingProvider bindingProvider = (BindingProvider) port;
        Binding binding = (Binding) bindingProvider.getBinding();
        List<Handler> portHandlers = binding.getHandlerChain();
        assertEquals(2, portHandlers.size());
        assertTrue(containSameHandlers(portHandlers, list));
        
        // Verify that a creating another instance of the same port also gets those handlers
        ClientMetadataHandlerChainTestSEI port2 = service.getPort(portQName, ClientMetadataHandlerChainTestSEI.class);
        BindingProvider bindingProvider2 = (BindingProvider) port2;
        Binding binding2 = (Binding) bindingProvider2.getBinding();
        List<Handler> portHandlers2 = binding2.getHandlerChain();
        assertNotSame(port, port2);
        assertEquals(2, portHandlers2.size());
        assertTrue(containSameHandlers(portHandlers2, list));
        
        // Verify that createing a different port doesn't get the handlers
        QName portQName3 = new QName(namespaceURI, portLocalPart + "3");
        ClientMetadataHandlerChainTestSEI port3 = service.getPort(portQName3, ClientMetadataHandlerChainTestSEI.class);
        BindingProvider bindingProvider3 = (BindingProvider) port3;
        Binding binding3 = (Binding) bindingProvider3.getBinding();
        List<Handler> portHandlers3 = binding3.getHandlerChain();
        assertEquals(0, portHandlers3.size());
        
        // Verify setting the metadata on a different port (a different QName) will get handlers.
        QName portQName4 = new QName(namespaceURI, portLocalPart + "4");
        ServiceDelegate.setPortMetadata(sparseComposite);
        ClientMetadataHandlerChainTestSEI port4 = service.getPort(portQName4, ClientMetadataHandlerChainTestSEI.class);
        BindingProvider bindingProvider4 = (BindingProvider) port4;
        Binding binding4 = (Binding) bindingProvider4.getBinding();
        List<Handler> portHandlers4 = binding4.getHandlerChain();
        assertEquals(2, portHandlers4.size());
        
        // Verify the service handler resolver knows about boths sets of handlers
        // attached to the two different port QNames and none are attached for the third port
        List<Handler> listForPort = resolver.getHandlerChain(pi);
        assertEquals(2, listForPort.size());

        PortInfo pi4 = new DummyPortInfo(portQName4);
        List<Handler> listForPort4 = resolver.getHandlerChain(pi4);
        assertEquals(2, listForPort4.size());
        
        PortInfo pi3 = new DummyPortInfo(portQName3);
        List<Handler> listForPort3 = resolver.getHandlerChain(pi3);
        assertEquals(0, listForPort3.size());
    }
    
    /**
     * Verify that handlers specified in a sparse compoiste on the service are only associated with 
     * that specific service delegate (i.e. Service instance), even if the QNames are the same 
     * across two instances of a Service.
     */
    public void testMultipleServiceDelgatesServiceComposite() {
        try {
            // Need to cache the ServiceDescriptions so that they are shared
            // across the two instances of the same Service.
            ClientMetadataTest.installCachingFactory();
            
            QName serviceQName = new QName(namespaceURI, svcLocalPart);
            PortInfo pi = new DummyPortInfo();

            // Create a Service specifying a sparse composite and verify the
            // ports under that service get the correct handlers associated.
            DescriptionBuilderComposite sparseComposite = new DescriptionBuilderComposite();
            HandlerChainsType handlerChainsType = getHandlerChainsType();
            sparseComposite.setHandlerChainsType(handlerChainsType);
            ServiceDelegate.setServiceMetadata(sparseComposite);
            Service service1 = Service.create(serviceQName);

            // Create a second instance of the same Service, but without
            // metadata. Ports created under that service should not get handler's associated.
            Service service2 = Service.create(serviceQName);

            // No ports created yet, so there should be no relevant handler
            // chains.
            HandlerResolver resolver1 = service1.getHandlerResolver();
            List<Handler> list1 = resolver1.getHandlerChain(pi);
            assertEquals(0, list1.size());

            // Create the port, it should get handlers.
            QName portQName1 = new QName(namespaceURI, portLocalPart);
            ClientMetadataHandlerChainTestSEI port1 =
                    service1.getPort(portQName1, ClientMetadataHandlerChainTestSEI.class);
            BindingProvider bindingProvider1 = (BindingProvider) port1;
            Binding binding1 = (Binding) bindingProvider1.getBinding();
            List<Handler> portHandlers1 = binding1.getHandlerChain();
            assertEquals(2, portHandlers1.size());
            
            // Refresh the handler list from the resolver after the port is created
            list1 = resolver1.getHandlerChain(pi);
            assertTrue(containSameHandlers(portHandlers1, list1));

            // Make sure the 2nd Service instance doesn't have handlers
            // associated with it
            HandlerResolver resolver2 = service2.getHandlerResolver();
            List<Handler> list2 = resolver2.getHandlerChain(pi);
            assertEquals(0, list2.size());

            // Make sure the same port created under the 2nd service also
            // doesn't have handlers
            ClientMetadataHandlerChainTestSEI port2 =
                    service2.getPort(portQName1, ClientMetadataHandlerChainTestSEI.class);
            BindingProvider bindingProvider2 = (BindingProvider) port2;
            Binding binding2 = (Binding) bindingProvider2.getBinding();
            List<Handler> portHandlers2 = binding2.getHandlerChain();
            assertEquals(0, portHandlers2.size());
        }
        finally {
            ClientMetadataTest.restoreOriginalFactory();
        }
    }

    /**
     * Verify that handlers specified in a sparse compoiste on the port are only associated with 
     * that port on that specific service delegate (i.e. Service instance), even if the QNames are the same 
     * across two instances of a Service.
     */
    public void testMultipleServiceDelgatesPortComposite() {
        try {
            // Need to cache the ServiceDescriptions so that they are shared
            // across the two instances of the same Service.
            ClientMetadataTest.installCachingFactory();
            
            QName serviceQName = new QName(namespaceURI, svcLocalPart);
            PortInfo pi = new DummyPortInfo();

            // Create two instances of the same Service
            Service service1 = Service.create(serviceQName);
            Service service2 = Service.create(serviceQName);

            // No ports created yet, so there should be no relevant handler
            // chains.
            HandlerResolver resolver1 = service1.getHandlerResolver();
            List<Handler> list1 = resolver1.getHandlerChain(pi);
            assertEquals(0, list1.size());

            // Create a Port specifying a sparse composite and verify the
            // port gets the correct handlers associated.
            DescriptionBuilderComposite sparseComposite = new DescriptionBuilderComposite();
            HandlerChainsType handlerChainsType = getHandlerChainsType();
            sparseComposite.setHandlerChainsType(handlerChainsType);
            ServiceDelegate.setPortMetadata(sparseComposite);
            QName portQName1 = new QName(namespaceURI, portLocalPart);
            ClientMetadataHandlerChainTestSEI port1 =
                    service1.getPort(portQName1, ClientMetadataHandlerChainTestSEI.class);
            BindingProvider bindingProvider1 = (BindingProvider) port1;
            Binding binding1 = (Binding) bindingProvider1.getBinding();
            List<Handler> portHandlers1 = binding1.getHandlerChain();
            assertEquals(2, portHandlers1.size());
            
            // Refresh the handler list from the resolver after the port is created
            list1 = resolver1.getHandlerChain(pi);
            assertTrue(containSameHandlers(portHandlers1, list1));

            // Make sure the 2nd Service instance doesn't have handlers
            // associated with it
            HandlerResolver resolver2 = service2.getHandlerResolver();
            List<Handler> list2 = resolver2.getHandlerChain(pi);
            assertEquals(0, list2.size());

            // Make sure the same port created under the 2nd service also
            // doesn't have handlers
            ClientMetadataHandlerChainTestSEI port2 =
                    service2.getPort(portQName1, ClientMetadataHandlerChainTestSEI.class);
            BindingProvider bindingProvider2 = (BindingProvider) port2;
            Binding binding2 = (Binding) bindingProvider2.getBinding();
            List<Handler> portHandlers2 = binding2.getHandlerChain();
            assertEquals(0, portHandlers2.size());
        }
        finally {
            ClientMetadataTest.restoreOriginalFactory();
        }
    }
    
    /**
     * Verify that the original functionality of specifying a HandlerChain annotation with a
     * file member works as it should. 
     */
    public void testHandlerChainOnSEI() {
        QName serviceQN = new QName(namespaceURI, svcLocalPart);

        Service service = Service.create(serviceQN);
        
        ClientMetadataHandlerChainTestSEIWithHC port = service.getPort(ClientMetadataHandlerChainTestSEIWithHC.class);
        BindingProvider bindingProvider = (BindingProvider) port;
        Binding binding = (Binding) bindingProvider.getBinding();
        List<Handler> portHandlers = binding.getHandlerChain();
        assertEquals(1, portHandlers.size());
        assertTrue(containsHandlerChainAnnotationHandlers(portHandlers));
    }
    
    /**
     * Verify that handler information in a sparse composite on the Port will override any handler chain
     * annotation on the SEI. 
     */
    public void testSEIHandlerChainOverrideOnPort() {
        QName serviceQN = new QName(namespaceURI, svcLocalPart + uniqueService++);
        
        Service service = Service.create(serviceQN);

        // The SEI has a HandlerChain annotation, but the sparse metadata should override it
        DescriptionBuilderComposite sparseComposite = new DescriptionBuilderComposite();
        HandlerChainsType handlerChainsType = getHandlerChainsType();
        sparseComposite.setHandlerChainsType(handlerChainsType);
        ServiceDelegate.setPortMetadata(sparseComposite);
        ClientMetadataHandlerChainTestSEIWithHC port = service.getPort(ClientMetadataHandlerChainTestSEIWithHC.class);
        BindingProvider bindingProvider = (BindingProvider) port;
        Binding binding = (Binding) bindingProvider.getBinding();
        List<Handler> portHandlers = binding.getHandlerChain();
        assertEquals(2, portHandlers.size());
        assertTrue(containsSparseCompositeHandlers(portHandlers));
    }
    
    /**
     * Verify that handler information in a sparse composite on the Service will override any handler chain
     * annotation on the SEI. 
     */
    public void testSEIHandlerChainOverrideOnService() {
        QName serviceQN = new QName(namespaceURI, svcLocalPart + uniqueService++);
        
        // The SEI has a HandlerChain annotation, but the sparse metadata should override it
        DescriptionBuilderComposite sparseComposite = new DescriptionBuilderComposite();
        HandlerChainsType handlerChainsType = getHandlerChainsType();
        sparseComposite.setHandlerChainsType(handlerChainsType);
        ServiceDelegate.setServiceMetadata(sparseComposite);
        Service service = Service.create(serviceQN);

        ClientMetadataHandlerChainTestSEIWithHC port = service.getPort(ClientMetadataHandlerChainTestSEIWithHC.class);
        BindingProvider bindingProvider = (BindingProvider) port;
        Binding binding = (Binding) bindingProvider.getBinding();
        List<Handler> portHandlers = binding.getHandlerChain();
        assertEquals(2, portHandlers.size());
        assertTrue(containsSparseCompositeHandlers(portHandlers));
    }
    
    /**
     * Set different composites on the Service and the Port that specify different 
     * HandlerChainsType values.  
     */
    public void testCompositeOnServiceAndPort() {
        QName serviceQN = new QName(namespaceURI, svcLocalPart + uniqueService++);
        
        // Create a service with a composite specifying handlers
        DescriptionBuilderComposite sparseComposite = new DescriptionBuilderComposite();
        HandlerChainsType handlerChainsType = getHandlerChainsType();
        sparseComposite.setHandlerChainsType(handlerChainsType);
        ServiceDelegate.setServiceMetadata(sparseComposite);
        Service service = Service.create(serviceQN);

        // Create a port with a composite specifying different handlers
        DescriptionBuilderComposite portComposite = new DescriptionBuilderComposite();
        HandlerChainsType portHandlerChainsType = getHandlerChainsType("ClientMetadataHandlerChainTest.xml");
        portComposite.setHandlerChainsType(portHandlerChainsType);
        ServiceDelegate.setPortMetadata(portComposite);
        ClientMetadataHandlerChainTestSEI port = service.getPort(ClientMetadataHandlerChainTestSEI.class);
        BindingProvider bindingProvider = (BindingProvider) port;
        Binding binding = (Binding) bindingProvider.getBinding();
        List<Handler> portHandlers = binding.getHandlerChain();

        // If there is a HandlerChainsType composite specified on both the Service and the Port,
        // then the composite specified on the Port should be the one used to associate the 
        // handlers for that Port.
        assertEquals(1, portHandlers.size());
        assertTrue(containsHandlerChainAnnotationHandlers(portHandlers));
    }
    
    /**
     * Verfiy that a HandlerChain annotation on the Service is associated with the Port 
     */
    public void testGeneratedServiceWithHC() {
        ClientMetadataHandlerChainTestServiceWithHC service = new ClientMetadataHandlerChainTestServiceWithHC();
        ClientMetadataHandlerChainTestSEI port = service.getPort(ClientMetadataHandlerChainTestSEI.class);

        BindingProvider bindingProvider = (BindingProvider) port;
        Binding binding = (Binding) bindingProvider.getBinding();
        List<Handler> portHandlers = binding.getHandlerChain();
        assertEquals(1, portHandlers.size());
        assertTrue(containsHandlerChainAnnotationHandlers(portHandlers));

    }
    
    /**
     * Verfiy that given a HandlerChain annotation on the Service and a Port and a sparse composite
     * on the Port associates the handlers from the sparse composite on the Port.
     */
    public void testGeneratedServiceWithHCPortOverride() {
        ClientMetadataHandlerChainTestServiceWithHC service = new ClientMetadataHandlerChainTestServiceWithHC();

        // Set a HandlerChainsType on the sparse composite for the Port creation; it should override the 
        // HandlerChain annotation on the Service.
        DescriptionBuilderComposite sparseComposite = new DescriptionBuilderComposite();
        HandlerChainsType handlerChainsType = getHandlerChainsType();
        sparseComposite.setHandlerChainsType(handlerChainsType);
        ServiceDelegate.setPortMetadata(sparseComposite);
        ClientMetadataHandlerChainTestSEI port = service.getPort(ClientMetadataHandlerChainTestSEI.class);

        BindingProvider bindingProvider = (BindingProvider) port;
        Binding binding = (Binding) bindingProvider.getBinding();
        List<Handler> portHandlers = binding.getHandlerChain();
        assertEquals(2, portHandlers.size());
        assertTrue(containsSparseCompositeHandlers(portHandlers));
    }

    // =============================================================================================
    // Helper methods and classes
    // =============================================================================================
    private boolean containsSparseCompositeHandlers(List<Handler> handlerList) {
        List<Class> inputHandlerClasses = handlerClasses(handlerList);

        // These are the handlers defined in the HandlerChainsType placed on the sparse composite
        List<Class> compositeHandlerClasses = new ArrayList<Class>();
        compositeHandlerClasses.add(org.apache.axis2.jaxws.spi.handler.DummySOAPHandler.class);
        compositeHandlerClasses.add(org.apache.axis2.jaxws.spi.handler.DummyLogicalHandler.class);

        if (inputHandlerClasses.size() != compositeHandlerClasses.size()) {
            return false;
        }
        
        if (inputHandlerClasses.containsAll(compositeHandlerClasses)) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * Answer if the List contains the same handlers as defined in the SEI
     * via the HandlerChain.file annotation memeber.
     * 
     * @param portHandlers List of handlers
     * @return true if the list matches what was defined on the SEI via the
     *   HandlerChain annotation; false otherwise.
     */
    private boolean containsHandlerChainAnnotationHandlers(List<Handler> portHandlers) {
        List<Class> portHandlerClasses = handlerClasses(portHandlers);
        List<Class> seiHandlerClasses = new ArrayList<Class>();
        seiHandlerClasses.add(ClientMetadataHandlerChainHandler.class);
        
        if (portHandlerClasses.size() != seiHandlerClasses.size()) {
            return false;
        }
        
        if (portHandlerClasses.containsAll(seiHandlerClasses)) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * Answer if two List<Handler> arguments contain the same handler Class files.
     * @param list1
     * @param list2
     * @return
     */
    private boolean containSameHandlers(List<Handler> list1, List<Handler> list2) {
        if (list1.size() != list2.size()) {
            return false;
        }

        List<Class> list1HandlerClasses = handlerClasses(list1);
        List<Class> list2HandlerClasses = handlerClasses(list2);

        if (list1HandlerClasses.containsAll(list2HandlerClasses)) {
            return true;
        } else {
            return false;
        }
            
    }
    
    private List<Class> handlerClasses(List<Handler> listOfHandlers) {
        List<Class> handlerClasses = new ArrayList<Class>();
        Iterator<Handler> handlerIterator = listOfHandlers.iterator();
        while (handlerIterator.hasNext()) {
            handlerClasses.add(handlerIterator.next().getClass());
        }
        return handlerClasses;
    }
    
    private HandlerChainsType getHandlerChainsType() {
        return getHandlerChainsType("handler.xml");
    }
    private HandlerChainsType getHandlerChainsType(String fileName) {
        InputStream is = getXMLFileStream(fileName);
        assertNotNull(is);
        HandlerChainsType returnHCT = DescriptionUtils.loadHandlerChains(is, this.getClass().getClassLoader());
        assertNotNull(returnHCT);
        return returnHCT;
    }
    private InputStream getXMLFileStream(String fileName) {
        InputStream is = null;
        String configLoc = null;
        try {
            String sep = "/";
            configLoc = sep + "test-resources" + sep + "configuration" + sep + "handlers" + sep + fileName;
            String baseDir = new File(System.getProperty("basedir",".")).getCanonicalPath();
            is = new File(baseDir + configLoc).toURL().openStream();
        }
        catch(Exception e) {
            e.printStackTrace();
        }
        return is;
    }

    public class DummyPortInfo implements PortInfo {
        private QName portQN;
        private QName serviceQN;
        
        public DummyPortInfo() {
            this.portQN = new QName("http://www.apache.org/test/namespace", "DummyPort");
            this.serviceQN = new QName("http://www.apache.org/test/namespace", "DummyService");
        }
        
        public DummyPortInfo(QName portQN) {
            this();
            this.portQN = portQN;
        }

        public String getBindingID() {
            return SOAPBinding.SOAP11HTTP_BINDING;
        }

        public QName getPortName() {
            return portQN;
        }
        
        public QName getServiceName() {
            return serviceQN;
        }
    }

}

@WebService
interface ClientMetadataHandlerChainTestSEI {
    public String echo(String toEcho);
}

@WebService
@HandlerChain(file="ClientMetadataHandlerChainTest.xml")
interface ClientMetadataHandlerChainTestSEIWithHC {
    public String echo(String toEcho);
}

@WebServiceClient
@HandlerChain(file="ClientMetadataHandlerChainTest.xml")
class ClientMetadataHandlerChainTestServiceWithHC extends javax.xml.ws.Service {
        public ClientMetadataHandlerChainTestServiceWithHC() {
            super(null,
                  new QName(ClientMetadataHandlerChainTest.namespaceURI, ClientMetadataHandlerChainTest.svcLocalPart));
        }
        public ClientMetadataHandlerChainTestServiceWithHC(URL wsdlLocation, QName serviceName) {
            super(wsdlLocation, serviceName);
        }
}