cxf-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ningji...@apache.org
Subject svn commit: r454743 - in /incubator/cxf/trunk/test/benchmark1: ./ src/ src/org/ src/org/apache/ src/org/apache/cxf/ src/org/apache/cxf/performance/ src/org/apache/cxf/performance/client/ src/org/apache/cxf/performance/server/ wsdl/
Date Tue, 10 Oct 2006 13:58:33 GMT
Author: ningjiang
Date: Tue Oct 10 06:58:32 2006
New Revision: 454743

URL: http://svn.apache.org/viewvc?view=rev&rev=454743
Log:
CXF-112 ported Axis2 performence test to CXF
 commented the wrapped method invoke for current CXF don't support mix style(bare and wrapped) in the same interface.
 If you want to run the test please see the build.xml.

Added:
    incubator/cxf/trunk/test/benchmark1/
    incubator/cxf/trunk/test/benchmark1/build.xml   (with props)
    incubator/cxf/trunk/test/benchmark1/src/
    incubator/cxf/trunk/test/benchmark1/src/org/
    incubator/cxf/trunk/test/benchmark1/src/org/apache/
    incubator/cxf/trunk/test/benchmark1/src/org/apache/cxf/
    incubator/cxf/trunk/test/benchmark1/src/org/apache/cxf/performance/
    incubator/cxf/trunk/test/benchmark1/src/org/apache/cxf/performance/client/
    incubator/cxf/trunk/test/benchmark1/src/org/apache/cxf/performance/client/BenchClient.java   (with props)
    incubator/cxf/trunk/test/benchmark1/src/org/apache/cxf/performance/server/
    incubator/cxf/trunk/test/benchmark1/src/org/apache/cxf/performance/server/BenchmarkImpl.java   (with props)
    incubator/cxf/trunk/test/benchmark1/src/org/apache/cxf/performance/server/BenchmarkServer.java   (with props)
    incubator/cxf/trunk/test/benchmark1/wsdl/
    incubator/cxf/trunk/test/benchmark1/wsdl/Benchmark.wsdl   (with props)

Added: incubator/cxf/trunk/test/benchmark1/build.xml
URL: http://svn.apache.org/viewvc/incubator/cxf/trunk/test/benchmark1/build.xml?view=auto&rev=454743
==============================================================================
--- incubator/cxf/trunk/test/benchmark1/build.xml (added)
+++ incubator/cxf/trunk/test/benchmark1/build.xml Tue Oct 10 06:58:32 2006
@@ -0,0 +1,32 @@
+<?xml version="1.0"?>
+<project name="test.Benchmark" default="build" basedir=".">
+    <import file="../performance/etc/common_build.xml"/>
+    <property name="wsdl.dir" location="${basedir}/wsdl"/>
+    <property name="wsdl.file" value="Benchmark.wsdl"/>
+
+    <target name="client" description="run Benchmark client">
+         <java maxmemory="512m" fork="true" classname="org.apache.cxf.performance.client.BenchClient">
+            <jvmarg line="-server -Xmx512m -Dtest.setup=LINUX_PENTIUM_M -Dserver.name=CXF"/>
+           <!--file:${basedir}/wsdl/${wsdl.file} wsldlocation 
+                200    totalelementtosend
+                aa     to invoke all method
+                1,10   the arraysize for eacho call  -->
+            <arg line="file:${basedir}/wsdl/${wsdl.file} 200 aa 1,10"/>
+            <classpath refid="cxf.classpath"/>
+            <sysproperty key="java.util.logging.config.file" value="${cxf.etc.dir}/logging.properties"/>
+            <sysproperty key="log4j.configuration" value="file:///${cxf.etc.dir}/log4j.properties"/>
+        </java>
+
+    </target>
+
+    <target name="server" description="run Benchmark server">
+        <cxf.server.run classname="org.apache.cxf.performance.server.BenchmarkServer" argline="${basedir}/wsdl/${wsdl.file}"/>
+    </target>
+
+     <target name="generate.code">
+        <echo level="info" message="Generating code using wsdl2java..."/>
+        <wsdl2java file="Benchmark.wsdl"/>
+    </target>
+  
+
+</project>

Propchange: incubator/cxf/trunk/test/benchmark1/build.xml
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: incubator/cxf/trunk/test/benchmark1/build.xml
------------------------------------------------------------------------------
    svn:keywords = Rev Date

Propchange: incubator/cxf/trunk/test/benchmark1/build.xml
------------------------------------------------------------------------------
    svn:mime-type = text/xml

Added: incubator/cxf/trunk/test/benchmark1/src/org/apache/cxf/performance/client/BenchClient.java
URL: http://svn.apache.org/viewvc/incubator/cxf/trunk/test/benchmark1/src/org/apache/cxf/performance/client/BenchClient.java?view=auto&rev=454743
==============================================================================
--- incubator/cxf/trunk/test/benchmark1/src/org/apache/cxf/performance/client/BenchClient.java (added)
+++ incubator/cxf/trunk/test/benchmark1/src/org/apache/cxf/performance/client/BenchClient.java Tue Oct 10 06:58:32 2006
@@ -0,0 +1,719 @@
+package org.apache.cxf.performance.client;
+
+import edu.indiana.extreme.wsdl.benchmark1.Benchmark;
+import edu.indiana.extreme.wsdl.benchmark1.Benchmark_Service;
+import edu.indiana.extreme.wsdl.benchmark1.ReceiveMeshInterfaceObjectsResponse;
+import edu.indiana.extreme.wsdl.benchmark1.SendMeshInterfaceObjectsResponse;
+import edu.indiana.extreme.wsdl.benchmark1.SimpleEvent;
+import edu.indiana.extreme.wsdl.benchmark1.MeshInterfaceObject;
+import edu.indiana.extreme.wsdl.benchmark1.EchoSimpleEventsRequest;
+import edu.indiana.extreme.wsdl.benchmark1.ArrayOfSimpleEvent;
+import edu.indiana.extreme.wsdl.benchmark1.ReceiveSimpleEventsRequest;
+import edu.indiana.extreme.wsdl.benchmark1.SendSimpleEventsRequest;
+import edu.indiana.extreme.wsdl.benchmark1.EchoMeshInterfaceObjectsRequest;
+import edu.indiana.extreme.wsdl.benchmark1.ReceiveMeshInterfaceObjectsRequest;
+import edu.indiana.extreme.wsdl.benchmark1.ArrayOfMeshInterfaceObject;
+import edu.indiana.extreme.wsdl.benchmark1.SendMeshInterfaceObjectsRequest;
+
+import javax.xml.namespace.QName;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+
+
+public class BenchClient {
+	private final static QName SERVICE_NAME = new QName("http://www.extreme.indiana.edu/wsdl/Benchmark1", "Benchmark");
+    private final static boolean VERBOSE = true;
+    private final static String SMOKE_TEST = "smoke_test";
+    
+    Benchmark_Service service;
+    Benchmark port;
+
+    public BenchClient(String location) throws Exception {
+    	URL wsdlURL = null;
+        File wsdlFile = new File(location);
+        try {
+            if (wsdlFile.exists()) {
+                wsdlURL = wsdlFile.toURL();
+            } else {
+                wsdlURL = new URL(location);
+            }
+        } catch (MalformedURLException e) {
+            e.printStackTrace();
+        }        
+      
+        service = new Benchmark_Service(wsdlURL, SERVICE_NAME);
+        port = service.getBenchmark(); 
+       
+        
+        /*options.setProperty(org.apache.axis2.transport.http.HTTPConstants.SO_TIMEOUT,new Integer(480000));
+        options.setProperty(org.apache.axis2.transport.http.HTTPConstants.CONNECTION_TIMEOUT,new Integer(480000));*/
+    }
+
+    //URL or port of service
+    //total number of elements to send (default 10K)
+    //[rse] means receive, send, or echo (a == all)
+    //[bdisva] means base64, double, int, string, void (only applies to echo), a == all methods;
+    //arraySize (optional for void) - default to 10
+    //java -Dmachine.name=... -Dserver.name=... Client URL total {rsea}{bdisva} [arraySize]
+    public static void main(String[] args) throws Exception {
+        long benchmarkStart = System.currentTimeMillis();
+        final String BENCHMARK_DRIVER_VERSION = "$Date$";
+        final String ID = "Benchmark1 Driver Version 1.0 (" + BENCHMARK_DRIVER_VERSION + ")";
+        verbose("Starting " + ID + " at " + (new Date()));
+
+        // allow multiple URLs (each must start with http"
+        List<String> locationList = new ArrayList<String>();        
+        int pos = 0;
+        while (pos < args.length) {
+            String s = args[pos];
+            if (s.startsWith("http") || s.startsWith("file")) {
+                locationList.add(s);                
+            } else {
+                break;
+            }
+            ++pos;
+        }
+        if (locationList.isEmpty()) {
+            int port = 34321;
+            locationList.add("http://localhost:" + port);
+        }
+
+        final int elementsToSend = args.length > pos ? Integer.parseInt(args[pos]) : 10000;
+
+        String testType = "aa";
+        if (args.length > (pos + 1)) {
+            testType = args[(pos + 1)];
+        }
+
+        String arrSizeToSend = "10";
+
+        if (args.length > (pos + 2)) {
+            arrSizeToSend = args[(pos + 2)];
+        }
+        
+        String[] locations = new String[locationList.size()];
+        locationList.toArray(locations);
+
+        for (int i = 0; i < locations.length; i++) {
+            String location = locations[i];
+            verbose("connecting to " + location);            
+            runTestsForSize(location, elementsToSend, testType, arrSizeToSend);
+        }
+        long benchmarkEnd = System.currentTimeMillis();
+        double seconds = ((benchmarkEnd - benchmarkStart) / 1000.0);
+        System.out.println("Finished " + ID + " in " + seconds + " seconds at " + (new Date()));
+    }
+
+    private static void runTestsForSize(String location,
+                                        final int elementsToSend,
+                                        String testType,
+                                        String arrSizeToSend)
+            throws Exception {
+        TestDescriptor td = new TestDescriptor(location, elementsToSend);
+        int commaPos = -1;
+        boolean finished = false;
+        while (!finished) {
+            td.setDirection(testType.charAt(0));
+            td.setMethod(testType.charAt(1));
+            int prevPos = commaPos;
+            commaPos = arrSizeToSend.indexOf(",", prevPos + 1);
+            String size;
+            if (commaPos > 0) {
+                size = arrSizeToSend.substring(prevPos + 1, commaPos);
+            } else {
+                size = arrSizeToSend.substring(prevPos + 1);
+                finished = true;
+            }
+            td.arrSizeToSend = Integer.parseInt(size);
+            //System.out.println("runnig test with size=" + size + " " + (new Date()));
+            final char direction = td.getDirection();
+            if (direction == 'a') {
+                td.setDirection('e');
+                runTestsForDirection(td);
+                td.setDirection('r');
+                runTestsForDirection(td);
+                td.setDirection('s');
+                runTestsForDirection(td);
+                td.setDirection('a'); //restore
+            } else {
+                runTestsForDirection(td);
+            }
+        }
+    }
+
+    public static void runTestsForDirection(TestDescriptor td)
+            throws Exception {
+        final char direction = td.direction;
+        final char method = td.method;
+        if (method == 'a') {
+            if (direction == 'e') {
+                //test for the void 
+                td.setMethod('v');
+                runOneTest(td);
+            }
+            /*
+            // test for Base64 
+            td.setMethod('b');
+            runOneTest(td);
+            // test for Doubles
+            td.setMethod('d');
+            runOneTest(td);
+            // test for Ints
+            td.setMethod('i');
+            runOneTest(td);
+            // test for Strings
+            td.setMethod('s');
+            runOneTest(td);*/
+            // test for MeshInterfaceObjects
+            td.setMethod('m');
+            runOneTest(td);
+            // test for SimpleEvents
+            td.setMethod('e');
+            runOneTest(td);
+            td.setMethod('a'); //restore
+        } else {
+            runOneTest(td);
+        }
+    }
+        
+
+    public static void runOneTest(TestDescriptor td)
+            throws Exception {
+        final char direction = td.direction;
+        final char method = td.method;
+        //int arrSize = method == 'v' ? 1 : td.arrSizeToSend;
+        int arrSize = td.arrSizeToSend;
+        int N = td.elementsToSend / arrSize; // + 1;
+        if (N == 0) {
+            N = 1;
+        }
+        final boolean smokeTest = System.getProperty(SMOKE_TEST) != null;
+        if (smokeTest) N = 3;
+
+        int totalInv = N * td.arrSizeToSend;
+
+        byte[] barr = null;
+        byte[] ba = null;
+        if (method == 'b') {
+            ba = new byte[td.arrSizeToSend];
+            barr = new byte[totalInv];
+            for (int i = 0; i < barr.length; i++) {
+                barr[i] = (byte) i;
+            }
+        }
+
+        Double[] darr = null;        
+        if (method == 'd') {            
+            darr = new Double[totalInv];
+            for (int i = 0; i < darr.length; i++) {
+                darr[i] = new Double(i);
+            }
+        }
+
+        Integer[] iarr = null;           
+        if (method == 'i') {            
+            iarr = new Integer[totalInv];
+            for (int i = 0; i < iarr.length ; i++) {
+                iarr[i] = new Integer(i);
+            }
+        }
+
+        String[] sarr = null;        
+        if (method == 's') {            
+            sarr = new String[totalInv];
+            for (int i = 0; i < sarr.length; i++) {
+                sarr[i] = "s" + i;
+            }
+        }
+
+        MeshInterfaceObject[] marr = null;        
+        if (method == 'm') {            
+            marr = new MeshInterfaceObject[totalInv];
+            for (int i = 0; i < totalInv; i++) {
+            	marr[i] = new MeshInterfaceObject();
+                marr[i].setX(i);
+                marr[i].setY(i);
+                marr[i].setValue(Math.sqrt(i));
+            }
+        }
+
+        SimpleEvent[] earr = null;        
+        if (method == 'e') {            
+            earr = new SimpleEvent[totalInv];
+            for (int i = 0; i < earr.length; i++) {
+                earr[i] = new SimpleEvent();
+                earr[i].setSequenceNumber(i);
+                earr[i].setMessage("Message #"+i);
+                earr[i].setTimestamp(Math.sqrt(i));
+            }
+        }
+
+        BenchClient client = new BenchClient(td.serverLocation);
+
+//        System.out.println("invoking " + N + (smokeTest ? " (SMOKE TEST)" : "")
+//                + " times for test " + method + " arraysSize=" + td.arrSizeToSend
+//                + " " + (new Date()));
+        //boolean validate = true;
+        long start = System.currentTimeMillis();
+        for (int count = 0; count < N; count++) {
+            int off = count * arrSize;
+            //String arg = "echo"+i;
+            if (method == 'v') {
+                if (direction == 'e') {
+                    client.echoVoid();
+                } else if (direction == 'r' || direction == 's') {
+                    throw new RuntimeException("usupported direction " + direction + " for void method");
+                } else {
+                    throw new RuntimeException("unrecongized direction " + direction);
+                }
+            } else if (method == 'b') {
+            	System.arraycopy(barr, off, ba, 0, ba.length);
+                byte[] uba = null;
+                int ulen = -1;
+                if (direction == 'e') {
+                    uba = client.echoBase64(ba);
+                } else if (direction == 'r') {
+                    ulen = client.receiveBase64(ba);
+                    if (ulen != ba.length) fail(method2s(direction, method) + " returned wrong size");
+                } else if (direction == 's') {
+                    uba = client.sendBase64(arrSize);
+                } else {
+                    throw new RuntimeException("unrecongized direction " + direction);
+                }
+                if ((count == 0 || count == N - 1) && (direction == 'e' || direction == 's')) {
+                    // bruta force
+                    if (direction == 's') off = 0;
+                    if (uba == null) fail(method2s(direction, method) + " byte array response was null");
+                    if (uba.length != ba.length) {
+                        fail(method2s(direction, method) + " byte array had wrong size " + uba.length
+                                + " (expected " + ba.length + ")");
+                    }
+                    for (int i = 0; i < ba.length; i++) {
+                        if (uba[i] != barr[i + off]) {
+                            fail("byte array response had wrong content");
+                        }
+                    }
+                }
+            } else if (method == 'd') {
+            	ArrayList<Double> da = new ArrayList<Double>();            	 
+            	new Util<Double>().copyList(darr, off, da, td.arrSizeToSend);            	
+                List<Double> uda = null;
+                int dlen = -1;
+                if (direction == 'e') {
+                    uda = client.echoDoubles(da);
+                } else if (direction == 'r') {
+                    dlen = client.receiveDoubles(da);
+                    if (dlen != da.size()) fail("receive double array returned wrong size");
+                } else if (direction == 's') {
+                    uda = client.sendDoubles(arrSize);
+                } else {
+                    throw new RuntimeException("unrecongized direction " + direction);
+                }
+                if ((count == 0 || count == N - 1) && (direction == 'e' || direction == 's')) {
+                    // bruta force verification
+                    if (direction == 's') off = 0;
+                    if (uda == null) fail(method2s(direction, method) + " double array response was null");
+                    if (uda.size() != da.size()) {
+                        fail(method2s(direction, method) + " double array had wrong size " + uda.size()
+                                + " (expected " + da.size() + ")");
+                    }
+                    for (int i = 0; i < uda.size(); i++) {
+                        if (uda.get(i) != darr[i + off]) {
+                            fail(method2s(direction, method) + " double array response had wrong content");
+                        }
+                    }
+                }
+            } else if (method == 'i') {
+            	ArrayList<Integer> ia = new ArrayList<Integer>();
+            	new Util<Integer>().copyList(iarr, off, ia, td.arrSizeToSend);
+                List<Integer> uia = null;
+                int ulen = -1;
+                if (direction == 'e') {
+                    uia = client.echoInts(ia);
+                } else if (direction == 'r') {
+                    ulen = client.receiveInts(ia);
+                    if (ulen != ia.size()) {
+                        fail(method2s(direction, method) + " receive byte array returned wrong size");
+                    }
+                } else if (direction == 's') {
+                    uia = client.sendInts(arrSize);
+                } else {
+                    throw new RuntimeException("unrecongized direction " + direction);
+                }
+                if ((count == 0 || count == N - 1) && (direction == 'e' || direction == 's')) {
+                    // bruta force verification
+                    if (direction == 's') off = 0;
+                    if (uia == null) fail(method2s(direction, method) + " int array response was null");
+                    if (uia.size() != ia.size()) {
+                        fail(method2s(direction, method) + " int array had wrong size " + uia.size()
+                                + " (expected " + ia.size() + ")");
+                    }
+                    for (int i = 0; i < uia.size(); i++) {
+                        if (uia.get(i) != iarr[i + off]) {
+                            fail(method2s(direction, method) + " int array response had wrong content");
+                        }
+                    }
+                }
+            } else if (method == 's') {
+            	ArrayList<String> sa = new ArrayList<String>();
+            	new Util<String>().copyList(sarr, off, sa, td.arrSizeToSend);
+                List<String> usa = null;
+                int slen = -1;
+                if (direction == 'e') {
+                    usa = client.echoStrings(sa);
+                } else if (direction == 'r') {
+                    slen = client.receiveStrings(sa);
+                    if (slen != sa.size())
+                        fail(method2s(direction, method) + " receive string array returned wrong size");
+                } else if (direction == 's') {
+                    usa = client.sendStrings(arrSize);
+                } else {
+                    throw new RuntimeException("unrecongized direction " + direction);
+                }
+                if (start > 0 && (count == 0 || count == N - 1) && (direction == 'e' || direction == 's')) {
+                    // bruta force verification
+                    if (direction == 's') off = 0;
+                    if (usa == null) fail(method2s(direction, method) + " string array response was null");
+                    if (usa.size() != sa.size()) {
+                        fail(method2s(direction, method) + " string array had wrong size " + usa.size()
+                                + " (expected " + sa.size() + ")");
+                    }
+                    for (int i = 0; i < usa.size(); i++) {
+                        String s1 = usa.get(i);
+                        String s2 = sarr[i + off];
+                        if (!s1.equals(s2)) {
+                            fail(method2s(direction, method) + " string array response"
+                                    + " had wrong content (s1=" + s1 + " s2=" + s2 + " i=" + i + ")");
+                        }
+                    }
+                }
+            } else if (method == 'm') {
+            	ArrayList<MeshInterfaceObject> ma = new ArrayList<MeshInterfaceObject>();
+            	new Util<MeshInterfaceObject>().copyList(marr, off, ma, td.arrSizeToSend);
+                List<MeshInterfaceObject> uma = null;
+                int slen = -1;
+                if (direction == 'e') {
+                    uma = client.echoMeshInterfaceObjects(ma);
+                } else if (direction == 'r') {
+                    slen = client.receiveMeshInterfaceObjects(ma);
+                    if (slen != ma.size())
+                        fail(method2s(direction, method) + " receive MeshInterfaceObject array returned wrong size");
+                } else if (direction == 's') {
+                    uma = client.sendMeshInterfaceObjects(arrSize);
+                } else {
+                    throw new RuntimeException("unrecongized direction " + direction);
+                }
+                if (start > 0 && (count == 0 || count == N - 1) && (direction == 'e' || direction == 's')) {
+                    // bruta force verification
+                    if (direction == 's') off = 0;
+                    if (uma == null) fail(method2s(direction, method) + " MeshInterfaceObject array response was null");
+                    if (uma.size() != ma.size()) {
+                        fail(method2s(direction, method) + " string MeshInterfaceObject had wrong size " + uma.size()
+                                + " (expected " + ma.size() + ")");
+                    }
+                    for (int i = 0; i < uma.size(); i++) {
+                        MeshInterfaceObject s1 = uma.get(i);
+                        MeshInterfaceObject s2 = marr[i + off];
+                        if (!toString(s1).equals(toString(s2))) {
+                            fail(method2s(direction, method) + " MeshInterfaceObject array response"
+                                    + " had wrong content (s1=" + s1 + " s2=" + s2 + " i=" + i + ")");
+                        }
+                    }
+                }
+            } else if (method == 'e') {
+            	ArrayList<SimpleEvent> ea = new ArrayList<SimpleEvent>();
+            	new Util<SimpleEvent>().copyList(earr, off, ea, td.arrSizeToSend);
+                List<SimpleEvent> uea = null;
+                int slen = -1;
+                if (direction == 'e') {
+                    uea = client.echoSimpleEvents(ea);
+                } else if (direction == 'r') {
+                    slen = client.receiveSimpleEvents(ea);
+                    if (slen != ea.size())
+                        fail(method2s(direction, method) + " receive SimpleEvent array returned wrong size");
+                } else if (direction == 's') {
+                    uea = client.sendSimpleEvents(arrSize);
+                } else {
+                    throw new RuntimeException("unrecongized direction " + direction);
+                }
+                if (start > 0 && (count == 0 || count == N - 1) && (direction == 'e' || direction == 's')) {
+                    // bruta force verification
+                    if (direction == 's') off = 0;
+                    if (uea == null) fail(method2s(direction, method) + " SimpleEvent array response was null");
+                    if (uea.size() != ea.size()) {
+                        fail(method2s(direction, method) + " string SimpleEvent had wrong size " + uea.size()
+                                + " (expected " + ea.size() + ")");
+                    }
+                    for (int i = 0; i < uea.size(); i++) {
+                        SimpleEvent s1 = uea.get(i);
+                        SimpleEvent s2 = earr[i + off];
+                        if (!toString(s1).equals(toString(s2))) {
+                            fail(method2s(direction, method) + " SimpleEvent array response"
+                                    + " had wrong content (s1=" + s1 + " s2=" + s2 + " i=" + i + ")");
+                        }
+                    }
+                }
+            } else {
+                throw new RuntimeException("unrecongized method " + method);
+            }
+
+            if (start > 0 && smokeTest) {
+//                String resp = builder.serializeToString(handler.getLastResponse());
+//                System.out.println(method2s(direction, method)+" response=\n"+resp+"---\n");
+            }
+        }
+        if (start > 0) {
+            long end = System.currentTimeMillis();
+            long total = (end == start) ? 1 : (end - start);
+            double seconds = (total / 1000.0);
+            double invPerSecs = (double) N / seconds;
+            double avgInvTimeInMs = (double) total / (double) N;
+//            System.out.println("N=" + N + " avg invocation:" + avgInvTimeInMs + " [ms]" +
+//                    "total:"+total+" [ms] "+
+//                    " throughput:" + invPerSecs + " [invocations/second]" +
+//                    " arraysSize=" + arrSize +
+//                    " direction=" + direction +
+//                    " method=" + method
+//                    + " " + (new Date())
+//            );
+            td.printResult(avgInvTimeInMs / 1000.0, invPerSecs);
+        }
+    }
+
+    private static String toString(SimpleEvent event){
+        return "[" + event.getMessage() + ":" + event.getSequenceNumber() + ":" + event.getTimestamp() + "]";
+    }
+
+    private static String toString(MeshInterfaceObject object){
+        return "[" + object.getValue() + ":" + object.getX() + ":" + object.getY() + "]";
+    }
+
+    private static void verbose(String msg) {
+    	if(VERBOSE) {
+    		System.out.println("B1> " + msg);
+    	}	
+    }
+
+    private static void fail(String msg) {
+        String s = "FATAL ERROR: service is not following benchmark requirement: " + msg;
+        System.out.println(s);
+        throw new RuntimeException(s);
+        //System.exit(-1);
+    }
+
+    private static String method2s(char direction, char method) {
+        StringBuffer sb = new StringBuffer(20);
+        if (direction == 'e') {
+            sb.append("echo");
+        } else if (direction == 's') {
+            sb.append("send");
+        } else if (direction == 'r') {
+            sb.append("receive");
+        }
+        if (method == 'v') {
+            sb.append("Void");
+        } else if (method == 'b') {
+            sb.append("Base64");
+        } else if (method == 'd') {
+            sb.append("Doubles");
+        } else if (method == 'i') {
+            sb.append("Ints");
+        } else if (method == 's') {
+            sb.append("Strings");
+        } else if (method == 'm') {
+            sb.append("MeshInterfaceObjects");
+        } else if (method == 'e') {
+            sb.append("SimpleEvent");
+        }
+        return sb.toString();
+    }
+
+    private final static class TestDescriptor {
+        private java.text.DecimalFormat df = new java.text.DecimalFormat("##0.000000000");
+        private java.text.DecimalFormat df2 = new java.text.DecimalFormat("##0.0000");
+        private String testSetup;
+        private String clientName = "CXF";
+        private String serverName = null;
+        private String serverLocation;
+        private int arrSizeToSend;
+        private int elementsToSend;
+
+        private char direction;
+        private char method;
+
+        TestDescriptor(//String serverName,
+                       String location,
+                       //final char direction,
+                       //final char method,
+                       int elementsToSend)
+        //int arrSizeToSend)
+        {
+            this.testSetup = System.getProperty("test.setup");
+            if (this.testSetup == null) {
+                this.testSetup = System.getProperty("machine.name", "UDISCLOSED_SETUP");
+            }
+            final String SERVER_NAME = "server.name";
+            this.serverName = System.getProperty(SERVER_NAME);
+            if (serverName == null) {
+                throw new RuntimeException(SERVER_NAME + " must be specified as system property");
+            }
+            this.serverName = serverName;
+            this.serverLocation = location;
+            //this.direction =  direction;
+            //this.method = method;
+            this.elementsToSend = elementsToSend;
+            //this.arrSizeToSend = arrSizeToSend;
+        }
+
+        public void setDirection(char direction) {
+            this.direction = direction;
+        }
+
+        public char getDirection() {
+            return direction;
+        }
+
+        public void setMethod(char method) {
+            this.method = method;
+        }
+
+        public char getMethod() {
+            return method;
+        }
+
+        public void printResult(double timeSecs, double throughput) throws IOException {
+            PrintWriter results = new PrintWriter(System.out, true);
+            results.print(testSetup + '\t'
+                    + clientName + '\t'
+                    + serverName + '\t'
+                    + method2s(direction, method) + ((method == 'm') ? "\t" : ((method=='e' && direction=='r') ?"\t\t":"\t\t\t"))
+                    + arrSizeToSend + '\t'
+                    + df.format(timeSecs) + '\t'
+                    + df2.format(throughput)
+                    + "\r\n");
+            results.flush();
+        }
+
+    }
+
+    public void echoVoid() throws java.lang.Exception {        
+        port.echoVoid();
+    }
+
+    public List<String> echoStrings(List<String> input) throws java.lang.Exception {
+        return port.echoStrings(input);
+    }
+
+    public int receiveBase64(byte[] input) throws java.lang.Exception {       
+        return port.receiveBase64(input);
+        
+    }
+
+    public int receiveDoubles(List<Double> input) throws java.lang.Exception {
+        
+        return port.receiveDoubles(input);
+    }
+
+    public List<Integer> sendInts(int input) throws java.lang.Exception {        
+        return port.sendInts(input);
+    }
+
+    public byte[] echoBase64(byte[] input) throws java.lang.Exception {
+        return port.echoBase64(input);        
+    }
+
+    public int receiveStrings(List<String> input) throws java.lang.Exception {        
+        return port.receiveStrings(input);
+    }
+
+    public List<Integer> echoInts(List<Integer> input) throws java.lang.Exception {
+        return port.echoInts(input);
+    }
+
+    public int receiveInts(List<Integer> input) throws java.lang.Exception {
+        return port.receiveInts(input);
+    }
+
+    public List<Double> sendDoubles(int input) throws java.lang.Exception {
+        return port.sendDoubles(input);
+    }
+
+    public byte[] sendBase64(int input) throws java.lang.Exception {
+        
+        return port.sendBase64(input);
+    }
+
+    public List<Double> echoDoubles(List<Double> input) throws java.lang.Exception {       
+        return port.echoDoubles(input);
+    }
+
+    public List<String> sendStrings(int input) throws java.lang.Exception {        
+        return port.sendStrings(input);
+    }
+
+    public List<SimpleEvent> echoSimpleEvents(List<SimpleEvent> input) throws java.lang.Exception {
+        EchoSimpleEventsRequest request = new EchoSimpleEventsRequest();
+        ArrayOfSimpleEvent array = new ArrayOfSimpleEvent();
+        array.getItem().addAll(input);
+        request.setInput(array);
+        return port.echoSimpleEvents(request).getEchoSimpleEventsReturn().getItem();
+    }
+
+    public int receiveSimpleEvents(List<SimpleEvent> input) throws java.lang.Exception {
+        ReceiveSimpleEventsRequest request = new ReceiveSimpleEventsRequest();
+        ArrayOfSimpleEvent array = new ArrayOfSimpleEvent();
+        array.getItem().addAll(input);
+        request.setInput(array);
+        return port.receiveSimpleEvents(request).getReceiveSimpleEventsReturn();
+    }
+
+    public List<SimpleEvent> sendSimpleEvents(int size) throws java.lang.Exception {
+        SendSimpleEventsRequest request = new SendSimpleEventsRequest();
+        request.setSize(size);
+        return port.sendSimpleEvents(request).getSendSimpleEventsReturn().getItem();
+    }
+
+    public List<MeshInterfaceObject> echoMeshInterfaceObjects(List<MeshInterfaceObject> input) throws java.lang.Exception {
+        EchoMeshInterfaceObjectsRequest request = new EchoMeshInterfaceObjectsRequest();
+        request.getInput().addAll(input);
+        return port.echoMeshInterfaceObjects(request).getEchoMeshInterfaceObjectReturn();
+    }
+
+    public int receiveMeshInterfaceObjects(List<MeshInterfaceObject> input) throws java.lang.Exception {
+        ReceiveMeshInterfaceObjectsRequest request = new ReceiveMeshInterfaceObjectsRequest();
+        ArrayOfMeshInterfaceObject array = new ArrayOfMeshInterfaceObject();
+        array.getItem().addAll(input);
+        request.setInput(array);
+        ReceiveMeshInterfaceObjectsResponse response= port.receiveMeshInterfaceObjects(request);
+        return response.getReceiveMeshInterfaceObjectsReturn();
+    }
+
+    public List<MeshInterfaceObject> sendMeshInterfaceObjects(int size) throws java.lang.Exception {
+        SendMeshInterfaceObjectsRequest request = new SendMeshInterfaceObjectsRequest();
+        request.setSize(size);
+        SendMeshInterfaceObjectsResponse response = port.sendMeshInterfaceObjects(request);        
+        return response.getSendMeshInterfaceObjectsReturn().getItem();
+    }
+    
+    static class Util<E> {
+    	public Util() {
+    		
+    	}
+    	public void copyList(E[] src, int off, ArrayList<E>des, int size) {
+    		des.clear();
+    		for(int i = 0; i< size; i++) {
+    			E o = src[i+off];
+    			des.add(o);
+    		}
+    	}	
+    }
+}
+
+

Propchange: incubator/cxf/trunk/test/benchmark1/src/org/apache/cxf/performance/client/BenchClient.java
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: incubator/cxf/trunk/test/benchmark1/src/org/apache/cxf/performance/client/BenchClient.java
------------------------------------------------------------------------------
    svn:keywords = Rev Date

Added: incubator/cxf/trunk/test/benchmark1/src/org/apache/cxf/performance/server/BenchmarkImpl.java
URL: http://svn.apache.org/viewvc/incubator/cxf/trunk/test/benchmark1/src/org/apache/cxf/performance/server/BenchmarkImpl.java?view=auto&rev=454743
==============================================================================
--- incubator/cxf/trunk/test/benchmark1/src/org/apache/cxf/performance/server/BenchmarkImpl.java (added)
+++ incubator/cxf/trunk/test/benchmark1/src/org/apache/cxf/performance/server/BenchmarkImpl.java Tue Oct 10 06:58:32 2006
@@ -0,0 +1,292 @@
+
+
+package org.apache.cxf.performance.server;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import edu.indiana.extreme.wsdl.benchmark1.ArrayOfMeshInterfaceObject;
+import edu.indiana.extreme.wsdl.benchmark1.ArrayOfSimpleEvent;
+import edu.indiana.extreme.wsdl.benchmark1.Benchmark;
+import edu.indiana.extreme.wsdl.benchmark1.EchoMeshInterfaceObjectsResponse;
+import edu.indiana.extreme.wsdl.benchmark1.EchoSimpleEventsResponse;
+import edu.indiana.extreme.wsdl.benchmark1.MeshInterfaceObject;
+import edu.indiana.extreme.wsdl.benchmark1.ReceiveMeshInterfaceObjectsResponse;
+import edu.indiana.extreme.wsdl.benchmark1.ReceiveSimpleEventsResponse;
+import edu.indiana.extreme.wsdl.benchmark1.SendMeshInterfaceObjectsResponse;
+import edu.indiana.extreme.wsdl.benchmark1.SendSimpleEventsResponse;
+import edu.indiana.extreme.wsdl.benchmark1.SimpleEvent;
+
+
+
+@javax.jws.WebService(name = "Benchmark", serviceName = "Benchmark",
+                      portName = "Benchmark",
+                      targetNamespace = "http://www.extreme.indiana.edu/wsdl/Benchmark1", 
+                      endpointInterface = "edu.indiana.extreme.wsdl.benchmark1.Benchmark")
+                      
+public class BenchmarkImpl implements Benchmark {
+
+    private static final Logger LOG = 
+        Logger.getLogger(BenchmarkImpl.class.getPackage().getName());
+    
+    public BenchmarkImpl() {
+    	LOG.setLevel(Level.INFO);
+    }
+    	
+    
+
+    /* (non-Javadoc)
+     * @see edu.indiana.extreme.wsdl.benchmark1.Benchmark#echoVoid(*
+     */
+    public void echoVoid() { 
+        LOG.info("Executing operation echoVoid");
+    }
+
+    /* (non-Javadoc)
+     * @see edu.indiana.extreme.wsdl.benchmark1.Benchmark#echoBase64(byte[]  input )*
+     */
+    public byte[] echoBase64 (byte[] input) { 
+        LOG.info("Executing operation echoBase64");        
+        return input;
+    }
+
+    /* (non-Javadoc)
+     * @see edu.indiana.extreme.wsdl.benchmark1.Benchmark#echoStrings(java.util.List<java.lang.String>  input )*
+     */
+    public java.util.List<java.lang.String> echoStrings(
+        java.util.List<java.lang.String> input
+    )
+    { 
+       LOG.info("Executing operation echoStrings");
+        return input;
+    }
+
+    /* (non-Javadoc)
+     * @see edu.indiana.extreme.wsdl.benchmark1.Benchmark#echoInts(java.util.List<java.lang.Integer>  input )*
+     */
+    public java.util.List<java.lang.Integer> echoInts(
+        java.util.List<java.lang.Integer> input
+    )
+    { 
+        LOG.info("Executing operation echoInts");
+        return input;
+    }
+
+    /* (non-Javadoc)
+     * @see edu.indiana.extreme.wsdl.benchmark1.Benchmark#echoDoubles(java.util.List<java.lang.Double>  input )*
+     */
+    public java.util.List<java.lang.Double> echoDoubles(
+        java.util.List<java.lang.Double> input
+    )
+    { 
+        LOG.info("Executing operation echoDoubles");
+        return input;
+    }
+
+    /* (non-Javadoc)
+     * @see edu.indiana.extreme.wsdl.benchmark1.Benchmark#echoSimpleEvents(edu.indiana.extreme.wsdl.benchmark1.EchoSimpleEventsRequest  input )*
+     */
+    public edu.indiana.extreme.wsdl.benchmark1.EchoSimpleEventsResponse echoSimpleEvents(
+        edu.indiana.extreme.wsdl.benchmark1.EchoSimpleEventsRequest input
+    )
+    { 
+        LOG.info("Executing operation echoSimpleEvents");
+        EchoSimpleEventsResponse ret = new EchoSimpleEventsResponse();
+        ret.setEchoSimpleEventsReturn(input.getInput());
+        return ret;
+    }
+
+    /* (non-Javadoc)
+     * @see edu.indiana.extreme.wsdl.benchmark1.Benchmark#echoMeshInterfaceObjects(edu.indiana.extreme.wsdl.benchmark1.EchoMeshInterfaceObjectsRequest  input )*
+     */
+    public edu.indiana.extreme.wsdl.benchmark1.EchoMeshInterfaceObjectsResponse echoMeshInterfaceObjects(
+        edu.indiana.extreme.wsdl.benchmark1.EchoMeshInterfaceObjectsRequest input
+    )
+    { 
+        LOG.info("Executing operation echoMeshInterfaceObjects");
+        EchoMeshInterfaceObjectsResponse ret = new EchoMeshInterfaceObjectsResponse();
+        List<MeshInterfaceObject> output = ret.getEchoMeshInterfaceObjectReturn();
+        for(MeshInterfaceObject mio :input.getInput()) {
+        	output.add(mio);
+        }
+        return ret;
+    }
+
+    /* (non-Javadoc)
+     * @see edu.indiana.extreme.wsdl.benchmark1.Benchmark#receiveBase64(byte[]  input )*
+     */
+    public int receiveBase64(
+        byte[] input
+    )
+    { 
+        LOG.info("Executing operation receiveBase64");
+        System.out.println("Executing operation receiveBase64 " + input.length);
+        return input.length;        
+    }
+
+    /* (non-Javadoc)
+     * @see edu.indiana.extreme.wsdl.benchmark1.Benchmark#receiveStrings(java.util.List<java.lang.String>  input )*
+     */
+    public int receiveStrings(
+        java.util.List<java.lang.String> input
+    )
+    { 
+        LOG.info("Executing operation receiveStrings");
+        return input.size();        
+    }
+
+    /* (non-Javadoc)
+     * @see edu.indiana.extreme.wsdl.benchmark1.Benchmark#receiveInts(java.util.List<java.lang.Integer>  input )*
+     */
+    public int receiveInts(
+        java.util.List<java.lang.Integer> input
+    )
+    { 
+        LOG.info("Executing operation receiveInts");
+        return input.size();
+    }
+
+    /* (non-Javadoc)
+     * @see edu.indiana.extreme.wsdl.benchmark1.Benchmark#receiveDoubles(java.util.List<java.lang.Double>  input )*
+     */
+    public int receiveDoubles(
+        java.util.List<java.lang.Double> input
+    )
+    { 
+        LOG.info("Executing operation receiveDoubles");
+        return input.size();
+    }
+
+    /* (non-Javadoc)
+     * @see edu.indiana.extreme.wsdl.benchmark1.Benchmark#receiveSimpleEvents(edu.indiana.extreme.wsdl.benchmark1.ReceiveSimpleEventsRequest  input )*
+     */
+    public edu.indiana.extreme.wsdl.benchmark1.ReceiveSimpleEventsResponse receiveSimpleEvents(
+        edu.indiana.extreme.wsdl.benchmark1.ReceiveSimpleEventsRequest input
+    )
+    { 
+        LOG.info("Executing operation receiveSimpleEvents");
+        ReceiveSimpleEventsResponse ret = new ReceiveSimpleEventsResponse();
+        ret.setReceiveSimpleEventsReturn(input.getInput().getItem().size());
+        return ret;
+    }
+
+    /* (non-Javadoc)
+     * @see edu.indiana.extreme.wsdl.benchmark1.Benchmark#receiveMeshInterfaceObjects(edu.indiana.extreme.wsdl.benchmark1.ReceiveMeshInterfaceObjectsRequest  input )*
+     */
+    public edu.indiana.extreme.wsdl.benchmark1.ReceiveMeshInterfaceObjectsResponse receiveMeshInterfaceObjects(
+        edu.indiana.extreme.wsdl.benchmark1.ReceiveMeshInterfaceObjectsRequest input
+    )
+    { 
+        LOG.info("Executing operation receiveMeshInterfaceObjects");
+        ReceiveMeshInterfaceObjectsResponse ret = new ReceiveMeshInterfaceObjectsResponse();
+        ret.setReceiveMeshInterfaceObjectsReturn(input.getInput().getItem().size());
+        return ret;
+    }
+
+    /* (non-Javadoc)
+     * @see edu.indiana.extreme.wsdl.benchmark1.Benchmark#sendBase64(int  size )*
+     */
+    public byte[] sendBase64(
+        int size
+    )
+    { 
+        LOG.info("Executing operation sendBase64");        
+        return new byte[size];
+    }
+
+    /* (non-Javadoc)
+     * @see edu.indiana.extreme.wsdl.benchmark1.Benchmark#sendStrings(int  size )*
+     */
+    public java.util.List<java.lang.String> sendStrings(
+        int size
+    )
+    { 
+       LOG.info("Executing operation sendStrings");       
+       List<String> ret = new ArrayList<String>(0);
+       for (int i = 0; i < size; i++) {
+           String temp = "s" + i;
+           ret.add(temp);
+       }
+       return ret;
+    }
+
+    /* (non-Javadoc)
+     * @see edu.indiana.extreme.wsdl.benchmark1.Benchmark#sendInts(int  size )*
+     */
+    public java.util.List<java.lang.Integer> sendInts(
+        int size
+    )
+    { 
+        LOG.info("Executing operation sendInts");
+        List<Integer> ret = new LinkedList<Integer>();
+        for (int i = 0; i < size; i++) {
+        	Integer temp = i;
+        	ret.add(temp);
+        }
+        return ret;
+    }
+
+    /* (non-Javadoc)
+     * @see edu.indiana.extreme.wsdl.benchmark1.Benchmark#sendDoubles(int  size )*
+     */
+    public java.util.List<java.lang.Double> sendDoubles(
+        int size
+    )
+    { 
+        LOG.info("Executing operation sendDoubles");
+        List<Double> ret = new LinkedList<Double>();
+        for (int i = 0; i < size; i++) {
+        	double temp = i ;
+        	ret.add(temp);
+        }
+        return ret;
+    }
+
+    /* (non-Javadoc)
+     * @see edu.indiana.extreme.wsdl.benchmark1.Benchmark#sendSimpleEvents(edu.indiana.extreme.wsdl.benchmark1.SendSimpleEventsRequest  size )*
+     */
+    public edu.indiana.extreme.wsdl.benchmark1.SendSimpleEventsResponse sendSimpleEvents(
+        edu.indiana.extreme.wsdl.benchmark1.SendSimpleEventsRequest size
+    )
+    { 
+        LOG.info("Executing operation sendSimpleEvents");
+        SendSimpleEventsResponse ret = new SendSimpleEventsResponse();
+        ArrayOfSimpleEvent value = new ArrayOfSimpleEvent();
+        List<SimpleEvent> item = value.getItem();
+        for(int i = 0 ; i < size.getSize() ; i++) {        	
+        	SimpleEvent object = new SimpleEvent();
+            object.setSequenceNumber(i);
+            object.setMessage("Message #" + i);
+            object.setTimestamp(Math.sqrt(i));
+            item.add(object);
+        }
+        ret.setSendSimpleEventsReturn(value);
+        return ret;
+    }
+
+    /* (non-Javadoc)
+     * @see edu.indiana.extreme.wsdl.benchmark1.Benchmark#sendMeshInterfaceObjects(edu.indiana.extreme.wsdl.benchmark1.SendMeshInterfaceObjectsRequest  size )*
+     */
+    public edu.indiana.extreme.wsdl.benchmark1.SendMeshInterfaceObjectsResponse sendMeshInterfaceObjects(
+        edu.indiana.extreme.wsdl.benchmark1.SendMeshInterfaceObjectsRequest size
+    )
+    { 
+        LOG.info("Executing operation sendMeshInterfaceObjects");
+        SendMeshInterfaceObjectsResponse ret = new SendMeshInterfaceObjectsResponse();
+        ArrayOfMeshInterfaceObject value = new ArrayOfMeshInterfaceObject();
+        List<MeshInterfaceObject> item = value.getItem();
+        for(int i = 0 ; i < size.getSize() ; i++) {
+        	MeshInterfaceObject object = new MeshInterfaceObject();
+        	object.setX(i);
+            object.setY(i);
+            object.setValue(Math.sqrt(i));
+            item.add(object);
+        }
+        ret.setSendMeshInterfaceObjectsReturn(value);
+        return ret;
+    }
+
+}
\ No newline at end of file

Propchange: incubator/cxf/trunk/test/benchmark1/src/org/apache/cxf/performance/server/BenchmarkImpl.java
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: incubator/cxf/trunk/test/benchmark1/src/org/apache/cxf/performance/server/BenchmarkImpl.java
------------------------------------------------------------------------------
    svn:keywords = Rev Date

Added: incubator/cxf/trunk/test/benchmark1/src/org/apache/cxf/performance/server/BenchmarkServer.java
URL: http://svn.apache.org/viewvc/incubator/cxf/trunk/test/benchmark1/src/org/apache/cxf/performance/server/BenchmarkServer.java?view=auto&rev=454743
==============================================================================
--- incubator/cxf/trunk/test/benchmark1/src/org/apache/cxf/performance/server/BenchmarkServer.java (added)
+++ incubator/cxf/trunk/test/benchmark1/src/org/apache/cxf/performance/server/BenchmarkServer.java Tue Oct 10 06:58:32 2006
@@ -0,0 +1,30 @@
+/* Generated by WSDLToJava Compiler. */
+package org.apache.cxf.performance.server;
+
+import javax.xml.ws.Endpoint;
+
+
+/**
+ * This class was generated by the CXF 2.0-incubator-M1-SNAPSHOT
+ * Mon Oct 09 13:22:53 CST 2006
+ * Generated source version: 2.0-incubator-M1-SNAPSHOT
+ * 
+ */
+ 
+public class BenchmarkServer{
+
+    protected BenchmarkServer() throws Exception {
+        System.out.println("Starting Server");
+        Object implementor = new BenchmarkImpl();
+        String address = "http://localhost:8080/cxf/services/Benchmark";
+        Endpoint.publish(address, implementor);
+    }
+    
+    public static void main(String args[]) throws Exception { 
+        new BenchmarkServer();
+        System.out.println("Server ready...");         
+        Thread.sleep(Integer.MAX_VALUE); 
+        System.out.println("Server exitting");
+        System.exit(0);
+    }
+}
\ No newline at end of file

Propchange: incubator/cxf/trunk/test/benchmark1/src/org/apache/cxf/performance/server/BenchmarkServer.java
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: incubator/cxf/trunk/test/benchmark1/src/org/apache/cxf/performance/server/BenchmarkServer.java
------------------------------------------------------------------------------
    svn:keywords = Rev Date

Added: incubator/cxf/trunk/test/benchmark1/wsdl/Benchmark.wsdl
URL: http://svn.apache.org/viewvc/incubator/cxf/trunk/test/benchmark1/wsdl/Benchmark.wsdl?view=auto&rev=454743
==============================================================================
--- incubator/cxf/trunk/test/benchmark1/wsdl/Benchmark.wsdl (added)
+++ incubator/cxf/trunk/test/benchmark1/wsdl/Benchmark.wsdl Tue Oct 10 06:58:32 2006
@@ -0,0 +1,666 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wsdl:definitions xmlns:impl="http://www.extreme.indiana.edu/wsdl/Benchmark1" xmlns:intf="http://www.extreme.indiana.edu/wsdl/Benchmark1" xmlns:apachesoap="http://xml.apache.org/xml-soap" xmlns:wsdlsoap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" targetNamespace="http://www.extreme.indiana.edu/wsdl/Benchmark1">
+	<wsdl:types>
+		<schema xmlns="http://www.w3.org/2001/XMLSchema" targetNamespace="http://www.extreme.indiana.edu/wsdl/Benchmark1" elementFormDefault="qualified">
+			<element name="echoVoid">
+				<complexType/>
+			</element>
+			<element name="echoVoidResponse">
+				<complexType/>
+			</element>
+			<element name="echoBase64">
+				<complexType>
+					<sequence>
+						<element name="input" type="xsd:base64Binary"/>
+					</sequence>
+				</complexType>
+			</element>
+			<element name="echoBase64Response">
+				<complexType>
+					<sequence>
+						<element name="echoBase64Return" type="xsd:base64Binary"/>
+					</sequence>
+				</complexType>
+			</element>
+			<element name="echoStrings">
+				<complexType>
+					<sequence>
+						<element name="input" type="xsd:string" maxOccurs="unbounded"/>
+					</sequence>
+				</complexType>
+			</element>
+			<element name="echoStringsResponse">
+				<complexType>
+					<sequence>
+						<element name="echoStringsReturn" type="xsd:string" maxOccurs="unbounded"/>
+					</sequence>
+				</complexType>
+			</element>
+			<element name="echoInts">
+				<complexType>
+					<sequence>
+						<element name="input" type="xsd:int" maxOccurs="unbounded"/>
+					</sequence>
+				</complexType>
+			</element>
+			<element name="echoIntsResponse">
+				<complexType>
+					<sequence>
+						<element name="echoIntsReturn" type="xsd:int" maxOccurs="unbounded"/>
+					</sequence>
+				</complexType>
+			</element>
+			<element name="echoDoubles">
+				<complexType>
+					<sequence>
+						<element name="input" type="xsd:double" maxOccurs="unbounded"/>
+					</sequence>
+				</complexType>
+			</element>
+			<element name="echoDoublesResponse">
+				<complexType>
+					<sequence>
+						<element name="echoDoublesReturn" type="xsd:double" maxOccurs="unbounded"/>
+					</sequence>
+				</complexType>
+			</element>
+			<element name="receiveBase64">
+				<complexType>
+					<sequence>
+						<element name="input" type="xsd:base64Binary"/>
+					</sequence>
+				</complexType>
+			</element>
+			<element name="receiveBase64Response">
+				<complexType>
+					<sequence>
+						<element name="receiveBase64Return" type="xsd:int"/>
+					</sequence>
+				</complexType>
+			</element>
+			<element name="receiveStrings">
+				<complexType>
+					<sequence>
+						<element name="input" type="xsd:string" maxOccurs="unbounded"/>
+					</sequence>
+				</complexType>
+			</element>
+			<element name="receiveStringsResponse">
+				<complexType>
+					<sequence>
+						<element name="receiveStringsReturn" type="xsd:int"/>
+					</sequence>
+				</complexType>
+			</element>
+			<element name="receiveInts">
+				<complexType>
+					<sequence>
+						<element name="input" type="xsd:int" maxOccurs="unbounded"/>
+					</sequence>
+				</complexType>
+			</element>
+			<element name="receiveIntsResponse">
+				<complexType>
+					<sequence>
+						<element name="receiveIntsReturn" type="xsd:int"/>
+					</sequence>
+				</complexType>
+			</element>
+			<element name="receiveDoubles">
+				<complexType>
+					<sequence>
+						<element name="input" type="xsd:double" maxOccurs="unbounded"/>
+					</sequence>
+				</complexType>
+			</element>
+			<element name="receiveDoublesResponse">
+				<complexType>
+					<sequence>
+						<element name="receiveDoublesReturn" type="xsd:int"/>
+					</sequence>
+				</complexType>
+			</element>
+			<element name="receiveSimpleEventsRequest">
+				<complexType>
+					<sequence>
+						<element name="input" type="impl:ArrayOfSimpleEvent"/>
+					</sequence>
+				</complexType>
+			</element>
+			<element name="receiveMeshInterfaceObjectsRequest">
+				<complexType>
+					<sequence>
+						<element name="input" type="impl:ArrayOfMeshInterfaceObject"/>
+					</sequence>
+				</complexType>
+			</element>
+			<element name="receiveSimpleEventsResponse">
+				<complexType>
+					<sequence>
+						<element name="receiveSimpleEventsReturn" type="xsd:int"/>
+					</sequence>
+				</complexType>
+			</element>
+			<element name="receiveMeshInterfaceObjectsResponse">
+				<complexType>
+					<sequence>
+						<element name="receiveMeshInterfaceObjectsReturn" type="xsd:int"/>
+					</sequence>
+				</complexType>
+			</element>
+			<element name="sendBase64">
+				<complexType>
+					<sequence>
+						<element name="size" type="xsd:int"/>
+					</sequence>
+				</complexType>
+			</element>
+			<element name="sendBase64Response">
+				<complexType>
+					<sequence>
+						<element name="sendBase64Return" type="xsd:base64Binary"/>
+					</sequence>
+				</complexType>
+			</element>
+			<element name="sendStrings">
+				<complexType>
+					<sequence>
+						<element name="size" type="xsd:int"/>
+					</sequence>
+				</complexType>
+			</element>
+			<element name="sendStringsResponse">
+				<complexType>
+					<sequence>
+						<element name="sendStringsReturn" type="xsd:string" maxOccurs="unbounded"/>
+					</sequence>
+				</complexType>
+			</element>
+			<element name="sendInts">
+				<complexType>
+					<sequence>
+						<element name="size" type="xsd:int"/>
+					</sequence>
+				</complexType>
+			</element>
+			<element name="sendIntsResponse">
+				<complexType>
+					<sequence>
+						<element name="sendIntsReturn" type="xsd:int" maxOccurs="unbounded"/>
+					</sequence>
+				</complexType>
+			</element>
+			<element name="sendDoubles">
+				<complexType>
+					<sequence>
+						<element name="size" type="xsd:int"/>
+					</sequence>
+				</complexType>
+			</element>
+			<element name="sendDoublesResponse">
+				<complexType>
+					<sequence>
+						<element name="sendDoublesReturn" type="xsd:double" maxOccurs="unbounded"/>
+					</sequence>
+				</complexType>
+			</element>
+			<element name="sendSimpleEventsRequest">
+				<complexType>
+					<sequence>
+						<element name="size" type="xsd:int"/>
+					</sequence>
+				</complexType>
+			</element>
+			<element name="sendSimpleEventsResponse">
+				<complexType>
+					<sequence>
+						<element name="sendSimpleEventsReturn" type="impl:ArrayOfSimpleEvent"/>
+					</sequence>
+				</complexType>
+			</element>
+			<element name="sendMeshInterfaceObjectsRequest">
+				<complexType>
+					<sequence>
+						<element name="size" type="xsd:int"/>
+					</sequence>
+				</complexType>
+			</element>
+			<element name="sendMeshInterfaceObjectsResponse">
+				<complexType>
+					<sequence>
+						<element name="sendMeshInterfaceObjectsReturn" type="impl:ArrayOfMeshInterfaceObject"/>
+					</sequence>
+				</complexType>
+			</element>
+			<element name="echoSimpleEventsRequest">
+				<complexType>
+					<sequence>
+						<element name="input" type="impl:ArrayOfSimpleEvent"/>
+					</sequence>
+				</complexType>
+			</element>
+			<element name="echoSimpleEventsResponse">
+				<complexType>
+					<sequence>
+						<element name="echoSimpleEventsReturn" type="impl:ArrayOfSimpleEvent"/>
+					</sequence>
+				</complexType>
+			</element>
+			<element name="echoMeshInterfaceObjectsRequest">
+				<complexType>
+					<sequence>
+						<element name="input" type="impl:MeshInterfaceObject" maxOccurs="unbounded"/>
+					</sequence>
+				</complexType>
+			</element>
+			<element name="echoMeshInterfaceObjectsResponse">
+				<complexType>
+					<sequence>
+						<element name="echoMeshInterfaceObjectReturn" type="impl:MeshInterfaceObject" maxOccurs="unbounded"/>
+					</sequence>
+				</complexType>
+			</element>
+			<element name="SimpleEvent" type="impl:SimpleEvent"/>
+			<xsd:complexType name="SimpleEvent">
+				<xsd:all>
+					<xsd:element name="sequenceNumber" type="xsd:int"/>
+					<xsd:element name="timestamp" type="xsd:double"/>
+					<xsd:element name="message" type="xsd:string"/>
+				</xsd:all>
+			</xsd:complexType>
+			<element name="ArrayOfSimpleEvent" type="impl:ArrayOfSimpleEvent"/>
+			<complexType name="ArrayOfSimpleEvent">
+				<xsd:sequence>
+					<xsd:element minOccurs="0" maxOccurs="unbounded" name="item" nillable="true" type="impl:SimpleEvent"/>
+				</xsd:sequence>
+			</complexType>
+			<element name="MeshInterfaceObject" type="impl:MeshInterfaceObject"/>
+			<xsd:complexType name="MeshInterfaceObject">
+				<xsd:all>
+					<xsd:element name="x" type="xsd:int"/>
+					<xsd:element name="y" type="xsd:int"/>
+					<xsd:element name="value" type="xsd:double"/>
+				</xsd:all>
+			</xsd:complexType>
+			<element name="ArrayOfMeshInterfaceObject" type="impl:ArrayOfMeshInterfaceObject"/>
+			<complexType name="ArrayOfMeshInterfaceObject">
+				<xsd:sequence>
+					<xsd:element minOccurs="0" maxOccurs="unbounded" name="item" nillable="true" type="impl:MeshInterfaceObject"/>
+				</xsd:sequence>
+			</complexType>
+		</schema>
+	</wsdl:types>
+	<wsdl:message name="echoIntsRequest">
+		<wsdl:part name="parameters" element="impl:echoInts"/>
+	</wsdl:message>
+	<wsdl:message name="echoBase64Request">
+		<wsdl:part name="parameters" element="impl:echoBase64"/>
+	</wsdl:message>
+	<wsdl:message name="echoVoidResponse">
+		<wsdl:part name="parameters" element="impl:echoVoidResponse"/>
+	</wsdl:message>
+	<wsdl:message name="receiveDoublesRequest">
+		<wsdl:part name="parameters" element="impl:receiveDoubles"/>
+	</wsdl:message>
+	<wsdl:message name="sendBase64Response">
+		<wsdl:part name="parameters" element="impl:sendBase64Response"/>
+	</wsdl:message>
+	<wsdl:message name="echoStringsRequest">
+		<wsdl:part name="parameters" element="impl:echoStrings"/>
+	</wsdl:message>
+	<wsdl:message name="sendStringsRequest">
+		<wsdl:part name="parameters" element="impl:sendStrings"/>
+	</wsdl:message>
+	<wsdl:message name="sendIntsRequest">
+		<wsdl:part name="parameters" element="impl:sendInts"/>
+	</wsdl:message>
+	<wsdl:message name="receiveStringsRequest">
+		<wsdl:part name="parameters" element="impl:receiveStrings"/>
+	</wsdl:message>
+	<wsdl:message name="echoBase64Response">
+		<wsdl:part name="parameters" element="impl:echoBase64Response"/>
+	</wsdl:message>
+	<wsdl:message name="receiveIntsRequest">
+		<wsdl:part name="parameters" element="impl:receiveInts"/>
+	</wsdl:message>
+	<wsdl:message name="sendIntsResponse">
+		<wsdl:part name="parameters" element="impl:sendIntsResponse"/>
+	</wsdl:message>
+	<wsdl:message name="receiveBase64Request">
+		<wsdl:part name="parameters" element="impl:receiveBase64"/>
+	</wsdl:message>
+	<wsdl:message name="sendDoublesResponse">
+		<wsdl:part name="parameters" element="impl:sendDoublesResponse"/>
+	</wsdl:message>
+	<wsdl:message name="receiveBase64Response">
+		<wsdl:part name="parameters" element="impl:receiveBase64Response"/>
+	</wsdl:message>
+	<wsdl:message name="echoIntsResponse">
+		<wsdl:part name="parameters" element="impl:echoIntsResponse"/>
+	</wsdl:message>
+	<wsdl:message name="echoDoublesRequest">
+		<wsdl:part name="parameters" element="impl:echoDoubles"/>
+	</wsdl:message>
+	<wsdl:message name="sendDoublesRequest">
+		<wsdl:part name="parameters" element="impl:sendDoubles"/>
+	</wsdl:message>
+	<wsdl:message name="sendStringsResponse">
+		<wsdl:part name="parameters" element="impl:sendStringsResponse"/>
+	</wsdl:message>
+	<wsdl:message name="echoStringsResponse">
+		<wsdl:part name="parameters" element="impl:echoStringsResponse"/>
+	</wsdl:message>
+	<wsdl:message name="receiveIntsResponse">
+		<wsdl:part name="parameters" element="impl:receiveIntsResponse"/>
+	</wsdl:message>
+	<wsdl:message name="receiveDoublesResponse">
+		<wsdl:part name="parameters" element="impl:receiveDoublesResponse"/>
+	</wsdl:message>
+	<wsdl:message name="echoVoidRequest">
+		<wsdl:part name="parameters" element="impl:echoVoid"/>
+	</wsdl:message>
+	<wsdl:message name="receiveStringsResponse">
+		<wsdl:part name="parameters" element="impl:receiveStringsResponse"/>
+	</wsdl:message>
+	<wsdl:message name="sendBase64Request">
+		<wsdl:part name="parameters" element="impl:sendBase64"/>
+	</wsdl:message>
+	<wsdl:message name="echoDoublesResponse">
+		<wsdl:part name="parameters" element="impl:echoDoublesResponse"/>
+	</wsdl:message>
+	<wsdl:message name="echoSimpleEventsRequest">
+		<wsdl:part name="input" element="impl:echoSimpleEventsRequest"/>
+	</wsdl:message>
+	<wsdl:message name="echoSimpleEventsResponse">
+		<wsdl:part name="output" element="impl:echoSimpleEventsResponse"/>
+	</wsdl:message>
+	<wsdl:message name="echoMeshInterfaceObjectsRequest">
+		<wsdl:part name="input" element="impl:echoMeshInterfaceObjectsRequest"/>
+	</wsdl:message>
+	<wsdl:message name="echoMeshInterfaceObjectsResponse">
+		<wsdl:part name="output" element="impl:echoMeshInterfaceObjectsResponse"/>
+	</wsdl:message>
+	<wsdl:message name="receiveSimpleEventsRequest">
+		<wsdl:part name="input" element="impl:receiveSimpleEventsRequest"/>
+	</wsdl:message>
+	<wsdl:message name="receiveSimpleEventsResponse">
+		<wsdl:part name="size" element="impl:receiveSimpleEventsResponse"/>
+	</wsdl:message>
+	<wsdl:message name="receiveMeshInterfaceObjectsRequest">
+		<wsdl:part name="input" element="impl:receiveMeshInterfaceObjectsRequest"/>
+	</wsdl:message>
+	<wsdl:message name="receiveMeshInterfaceObjectsResponse">
+		<wsdl:part name="size" element="impl:receiveMeshInterfaceObjectsResponse"/>
+	</wsdl:message>
+	<wsdl:message name="sendSimpleEventsRequest">
+		<wsdl:part name="size" element="impl:sendSimpleEventsRequest"/>
+	</wsdl:message>
+	<wsdl:message name="sendSimpleEventsResponse">
+		<wsdl:part name="output" element="impl:sendSimpleEventsResponse"/>
+	</wsdl:message>
+	<wsdl:message name="sendMeshInterfaceObjectsRequest">
+		<wsdl:part name="size" element="impl:sendMeshInterfaceObjectsRequest"/>
+	</wsdl:message>
+	<wsdl:message name="sendMeshInterfaceObjectsResponse">
+		<wsdl:part name="output" element="impl:sendMeshInterfaceObjectsResponse"/>
+	</wsdl:message>
+	<wsdl:portType name="Benchmark">
+		<wsdl:operation name="echoVoid">
+			<wsdl:input name="echoVoidRequest" message="impl:echoVoidRequest"/>
+			<wsdl:output name="echoVoidResponse" message="impl:echoVoidResponse"/>
+		</wsdl:operation>
+		<wsdl:operation name="echoBase64">
+			<wsdl:input name="echoBase64Request" message="impl:echoBase64Request"/>
+			<wsdl:output name="echoBase64Response" message="impl:echoBase64Response"/>
+		</wsdl:operation>
+		<wsdl:operation name="echoStrings">
+			<wsdl:input name="echoStringsRequest" message="impl:echoStringsRequest"/>
+			<wsdl:output name="echoStringsResponse" message="impl:echoStringsResponse"/>
+		</wsdl:operation>
+		<wsdl:operation name="echoInts">
+			<wsdl:input name="echoIntsRequest" message="impl:echoIntsRequest"/>
+			<wsdl:output name="echoIntsResponse" message="impl:echoIntsResponse"/>
+		</wsdl:operation>
+		<wsdl:operation name="echoDoubles">
+			<wsdl:input name="echoDoublesRequest" message="impl:echoDoublesRequest"/>
+			<wsdl:output name="echoDoublesResponse" message="impl:echoDoublesResponse"/>
+		</wsdl:operation>
+		<wsdl:operation name="echoSimpleEvents">
+			<wsdl:input name="echoSimpleEventsRequest" message="impl:echoSimpleEventsRequest"/>
+			<wsdl:output name="echoSimpleEventsResponse" message="impl:echoSimpleEventsResponse"/>
+		</wsdl:operation>
+		<wsdl:operation name="echoMeshInterfaceObjects">
+			<wsdl:input name="echoMeshInterfaceObjectsRequest" message="impl:echoMeshInterfaceObjectsRequest"/>
+			<wsdl:output name="echoMeshInterfaceObjectsResponse" message="impl:echoMeshInterfaceObjectsResponse"/>
+		</wsdl:operation>
+		<wsdl:operation name="receiveBase64">
+			<wsdl:input name="receiveBase64Request" message="impl:receiveBase64Request"/>
+			<wsdl:output name="receiveBase64Response" message="impl:receiveBase64Response"/>
+		</wsdl:operation>
+		<wsdl:operation name="receiveStrings">
+			<wsdl:input name="receiveStringsRequest" message="impl:receiveStringsRequest"/>
+			<wsdl:output name="receiveStringsResponse" message="impl:receiveStringsResponse"/>
+		</wsdl:operation>
+		<wsdl:operation name="receiveInts">
+			<wsdl:input name="receiveIntsRequest" message="impl:receiveIntsRequest"/>
+			<wsdl:output name="receiveIntsResponse" message="impl:receiveIntsResponse"/>
+		</wsdl:operation>
+		<wsdl:operation name="receiveDoubles">
+			<wsdl:input name="receiveDoublesRequest" message="impl:receiveDoublesRequest"/>
+			<wsdl:output name="receiveDoublesResponse" message="impl:receiveDoublesResponse"/>
+		</wsdl:operation>
+		<wsdl:operation name="receiveSimpleEvents">
+			<wsdl:input name="receiveSimpleEventsRequest" message="impl:receiveSimpleEventsRequest"/>
+			<wsdl:output name="receiveSimpleEventsResponse" message="impl:receiveSimpleEventsResponse"/>
+		</wsdl:operation>
+		<wsdl:operation name="receiveMeshInterfaceObjects">
+			<wsdl:input name="receiveMeshInterfaceObjectsRequest" message="impl:receiveMeshInterfaceObjectsRequest"/>
+			<wsdl:output name="receiveMeshInterfaceObjectsResponse" message="impl:receiveMeshInterfaceObjectsResponse"/>
+		</wsdl:operation>
+		<wsdl:operation name="sendBase64">
+			<wsdl:input name="sendBase64Request" message="impl:sendBase64Request"/>
+			<wsdl:output name="sendBase64Response" message="impl:sendBase64Response"/>
+		</wsdl:operation>
+		<wsdl:operation name="sendStrings">
+			<wsdl:input name="sendStringsRequest" message="impl:sendStringsRequest"/>
+			<wsdl:output name="sendStringsResponse" message="impl:sendStringsResponse"/>
+		</wsdl:operation>
+		<wsdl:operation name="sendInts">
+			<wsdl:input name="sendIntsRequest" message="impl:sendIntsRequest"/>
+			<wsdl:output name="sendIntsResponse" message="impl:sendIntsResponse"/>
+		</wsdl:operation>
+		<wsdl:operation name="sendDoubles">
+			<wsdl:input name="sendDoublesRequest" message="impl:sendDoublesRequest"/>
+			<wsdl:output name="sendDoublesResponse" message="impl:sendDoublesResponse"/>
+		</wsdl:operation>
+		<wsdl:operation name="sendSimpleEvents">
+			<wsdl:input name="sendSimpleEventsRequest" message="impl:sendSimpleEventsRequest"/>
+			<wsdl:output name="sendSimpleEventsResponse" message="impl:sendSimpleEventsResponse"/>
+		</wsdl:operation>
+		<wsdl:operation name="sendMeshInterfaceObjects">
+			<wsdl:input name="sendMeshInterfaceObjectsRequest" message="impl:sendMeshInterfaceObjectsRequest"/>
+			<wsdl:output name="sendMeshInterfaceObjectsResponse" message="impl:sendMeshInterfaceObjectsResponse"/>
+		</wsdl:operation>
+	</wsdl:portType>
+	<wsdl:binding name="BenchmarkSoapBinding" type="impl:Benchmark">
+		<wsdlsoap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
+		<wsdl:operation name="echoVoid">
+			<wsdlsoap:operation soapAction="echoVoid"/>
+			<wsdl:input>
+				<wsdlsoap:body use="literal"/>
+			</wsdl:input>
+			<wsdl:output>
+				<wsdlsoap:body use="literal"/>
+			</wsdl:output>
+		</wsdl:operation>
+		<wsdl:operation name="echoBase64">
+			<wsdlsoap:operation soapAction="echoBase64"/>
+			<wsdl:input>
+				<wsdlsoap:body use="literal"/>
+			</wsdl:input>
+			<wsdl:output>
+				<wsdlsoap:body use="literal"/>
+			</wsdl:output>
+		</wsdl:operation>
+		<wsdl:operation name="echoStrings">
+			<wsdlsoap:operation soapAction="echoStrings"/>
+			<wsdl:input>
+				<wsdlsoap:body use="literal"/>
+			</wsdl:input>
+			<wsdl:output>
+				<wsdlsoap:body use="literal"/>
+			</wsdl:output>
+		</wsdl:operation>
+		<wsdl:operation name="echoInts">
+			<wsdlsoap:operation soapAction="echoInts"/>
+			<wsdl:input>
+				<wsdlsoap:body use="literal"/>
+			</wsdl:input>
+			<wsdl:output>
+				<wsdlsoap:body use="literal"/>
+			</wsdl:output>
+		</wsdl:operation>
+		<wsdl:operation name="echoDoubles">
+			<wsdlsoap:operation soapAction="echoDoubles"/>
+			<wsdl:input>
+				<wsdlsoap:body use="literal"/>
+			</wsdl:input>
+			<wsdl:output>
+				<wsdlsoap:body use="literal"/>
+			</wsdl:output>
+		</wsdl:operation>
+		<wsdl:operation name="echoSimpleEvents">
+			<wsdlsoap:operation soapAction="echoSimpleEvents"/>
+			<wsdl:input>
+				<wsdlsoap:body use="literal"/>
+			</wsdl:input>
+			<wsdl:output>
+				<wsdlsoap:body use="literal"/>
+			</wsdl:output>
+		</wsdl:operation>
+		<wsdl:operation name="echoMeshInterfaceObjects">
+			<wsdlsoap:operation soapAction="echoMeshInterfaceObjects"/>
+			<wsdl:input>
+				<wsdlsoap:body use="literal"/>
+			</wsdl:input>
+			<wsdl:output>
+				<wsdlsoap:body use="literal"/>
+			</wsdl:output>
+		</wsdl:operation>
+		<wsdl:operation name="receiveBase64">
+			<wsdlsoap:operation soapAction="receiveBase64"/>
+			<wsdl:input>
+				<wsdlsoap:body use="literal"/>
+			</wsdl:input>
+			<wsdl:output>
+				<wsdlsoap:body use="literal"/>
+			</wsdl:output>
+		</wsdl:operation>
+		<wsdl:operation name="receiveStrings">
+			<wsdlsoap:operation soapAction="receiveStrings"/>
+			<wsdl:input>
+				<wsdlsoap:body use="literal"/>
+			</wsdl:input>
+			<wsdl:output>
+				<wsdlsoap:body use="literal"/>
+			</wsdl:output>
+		</wsdl:operation>
+		<wsdl:operation name="receiveInts">
+			<wsdlsoap:operation soapAction="receiveInts"/>
+			<wsdl:input>
+				<wsdlsoap:body use="literal"/>
+			</wsdl:input>
+			<wsdl:output>
+				<wsdlsoap:body use="literal"/>
+			</wsdl:output>
+		</wsdl:operation>
+		<wsdl:operation name="receiveDoubles">
+			<wsdlsoap:operation soapAction="receiveDoubles"/>
+			<wsdl:input>
+				<wsdlsoap:body use="literal"/>
+			</wsdl:input>
+			<wsdl:output>
+				<wsdlsoap:body use="literal"/>
+			</wsdl:output>
+		</wsdl:operation>
+		<wsdl:operation name="receiveSimpleEvents">
+			<wsdlsoap:operation soapAction="receiveSimpleEvents"/>
+			<wsdl:input>
+				<wsdlsoap:body use="literal"/>
+			</wsdl:input>
+			<wsdl:output>
+				<wsdlsoap:body use="literal"/>
+			</wsdl:output>
+		</wsdl:operation>
+		<wsdl:operation name="receiveMeshInterfaceObjects">
+			<wsdlsoap:operation soapAction="receiveMeshInterfaceObjects"/>
+			<wsdl:input>
+				<wsdlsoap:body use="literal"/>
+			</wsdl:input>
+			<wsdl:output>
+				<wsdlsoap:body use="literal"/>
+			</wsdl:output>
+		</wsdl:operation>
+		<wsdl:operation name="sendBase64">
+			<wsdlsoap:operation soapAction="sendBase64"/>
+			<wsdl:input>
+				<wsdlsoap:body use="literal"/>
+			</wsdl:input>
+			<wsdl:output>
+				<wsdlsoap:body use="literal"/>
+			</wsdl:output>
+		</wsdl:operation>
+		<wsdl:operation name="sendStrings">
+			<wsdlsoap:operation soapAction="sendStrings"/>
+			<wsdl:input>
+				<wsdlsoap:body use="literal"/>
+			</wsdl:input>
+			<wsdl:output>
+				<wsdlsoap:body use="literal"/>
+			</wsdl:output>
+		</wsdl:operation>
+		<wsdl:operation name="sendInts">
+			<wsdlsoap:operation soapAction="sendInts"/>
+			<wsdl:input>
+				<wsdlsoap:body use="literal"/>
+			</wsdl:input>
+			<wsdl:output>
+				<wsdlsoap:body use="literal"/>
+			</wsdl:output>
+		</wsdl:operation>
+		<wsdl:operation name="sendDoubles">
+			<wsdlsoap:operation soapAction="sendDoubles"/>
+			<wsdl:input>
+				<wsdlsoap:body use="literal"/>
+			</wsdl:input>
+			<wsdl:output>
+				<wsdlsoap:body use="literal"/>
+			</wsdl:output>
+		</wsdl:operation>
+		<wsdl:operation name="sendSimpleEvents">
+			<wsdlsoap:operation soapAction="sendSimpleEvents"/>
+			<wsdl:input>
+				<wsdlsoap:body use="literal"/>
+			</wsdl:input>
+			<wsdl:output>
+				<wsdlsoap:body use="literal"/>
+			</wsdl:output>
+		</wsdl:operation>
+		<wsdl:operation name="sendMeshInterfaceObjects">
+			<wsdlsoap:operation soapAction="sendMeshInterfaceObjects"/>
+			<wsdl:input>
+				<wsdlsoap:body use="literal"/>
+			</wsdl:input>
+			<wsdl:output>
+				<wsdlsoap:body use="literal"/>
+			</wsdl:output>
+		</wsdl:operation>
+	</wsdl:binding>
+	<wsdl:service name="Benchmark">
+		<wsdl:port name="Benchmark" binding="impl:BenchmarkSoapBinding">
+			<wsdlsoap:address location="http://localhost:8080/cxf/services/Benchmark"/>
+		</wsdl:port>
+	</wsdl:service>
+	<!--WSDL created by Apache Axis version: 1.4
+Built on Jan 01, 2006 (10:17:00 EST)-->
+</wsdl:definitions>

Propchange: incubator/cxf/trunk/test/benchmark1/wsdl/Benchmark.wsdl
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: incubator/cxf/trunk/test/benchmark1/wsdl/Benchmark.wsdl
------------------------------------------------------------------------------
    svn:keywords = Rev Date

Propchange: incubator/cxf/trunk/test/benchmark1/wsdl/Benchmark.wsdl
------------------------------------------------------------------------------
    svn:mime-type = text/xml



Mime
View raw message