| /* |
| * Copyright 2001-2004 The Apache Software Foundation. |
| * |
| * Licensed 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 samples.echo ; |
| |
| import org.apache.axis.AxisFault; |
| import org.apache.axis.client.Stub; |
| import org.apache.axis.types.HexBinary; |
| import org.apache.axis.types.NegativeInteger; |
| import org.apache.axis.types.NonNegativeInteger; |
| import org.apache.axis.types.NonPositiveInteger; |
| import org.apache.axis.types.NormalizedString; |
| import org.apache.axis.types.PositiveInteger; |
| import org.apache.axis.types.Token; |
| import org.apache.axis.types.UnsignedByte; |
| import org.apache.axis.types.UnsignedInt; |
| import org.apache.axis.types.UnsignedLong; |
| import org.apache.axis.types.UnsignedShort; |
| import org.apache.axis.utils.JavaUtils; |
| import org.apache.axis.utils.Options; |
| |
| import javax.xml.rpc.holders.FloatHolder; |
| import javax.xml.rpc.holders.IntHolder; |
| import javax.xml.rpc.holders.StringHolder; |
| import java.io.PrintWriter; |
| import java.io.StringWriter; |
| import java.lang.reflect.Array; |
| import java.math.BigDecimal; |
| import java.util.Calendar; |
| import java.util.Date; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.TimeZone; |
| |
| |
| /** |
| * Test Client for the echo interop service. See the main entrypoint |
| * for more details on usage. |
| * |
| * @author Sam Ruby <rubys@us.ibm.com> |
| * Modified to use WSDL2Java generated stubs and artifacts by |
| * @author Rich Scheuerle <scheu@us.ibm.com> |
| */ |
| public abstract class TestClient { |
| |
| private static InteropTestPortType binding = null; |
| |
| /** |
| * When testMode is true, we throw exceptions up to the caller |
| * instead of recording them and continuing. |
| */ |
| private boolean testMode = false; |
| |
| public TestClient() { |
| } |
| |
| /** |
| * Constructor which sets testMode |
| */ |
| public TestClient(boolean testMode) { |
| this.testMode = testMode; |
| } |
| |
| /** |
| * Determine if two objects are equal. Handles nulls and recursively |
| * verifies arrays are equal. Accepts dates within a tolerance of |
| * 999 milliseconds. |
| */ |
| protected boolean equals(Object obj1, Object obj2) { |
| if (obj1 == null || obj2 == null) return (obj1 == obj2); |
| if (obj1.equals(obj2)) return true; |
| |
| // For comparison purposes, get the array of bytes representing |
| // the HexBinary object. |
| if (obj1 instanceof HexBinary) { |
| obj1 = ((HexBinary) obj1).getBytes(); |
| } |
| if (obj2 instanceof HexBinary) { |
| obj2 = ((HexBinary) obj2).getBytes(); |
| } |
| |
| if (obj1 instanceof Calendar && obj2 instanceof Calendar) { |
| if (Math.abs(((Calendar)obj1).getTime().getTime() - ((Calendar)obj2).getTime().getTime()) < 1000) { |
| return true; |
| } |
| } |
| |
| if ((obj1 instanceof Map) && (obj2 instanceof Map)) { |
| Map map1 = (Map)obj1; |
| Map map2 = (Map)obj2; |
| Set keys1 = map1.keySet(); |
| Set keys2 = map2.keySet(); |
| if (!(keys1.equals(keys2))) return false; |
| |
| // Check map1 is a subset of map2. |
| Iterator i = keys1.iterator(); |
| while (i.hasNext()) { |
| Object key = i.next(); |
| if (!equals(map1.get(key), map2.get(key))) |
| return false; |
| } |
| |
| // Check map2 is a subset of map1. |
| Iterator j = keys2.iterator(); |
| while (j.hasNext()) { |
| Object key = j.next(); |
| if (!equals(map1.get(key), map2.get(key))) |
| return false; |
| } |
| return true; |
| } |
| |
| if (obj1 instanceof List) |
| obj1 = JavaUtils.convert(obj1, Object[].class); |
| if (obj2 instanceof List) |
| obj2 = JavaUtils.convert(obj2, Object[].class); |
| |
| if (!obj2.getClass().isArray()) return false; |
| if (!obj1.getClass().isArray()) return false; |
| if (Array.getLength(obj1) != Array.getLength(obj2)) return false; |
| for (int i=0; i<Array.getLength(obj1); i++) |
| if (!equals(Array.get(obj1,i),Array.get(obj2,i))) return false; |
| return true; |
| } |
| |
| /** |
| * Set up the call object. |
| */ |
| public void setURL(String url) |
| throws AxisFault |
| { |
| try { |
| binding = new InteropTestServiceLocator(). |
| getecho(new java.net.URL(url)); |
| |
| // safety first |
| ((InteropTestSoapBindingStub)binding).setTimeout(60000); |
| ((InteropTestSoapBindingStub)binding).setMaintainSession(true); |
| } catch (Exception exp) { |
| throw AxisFault.makeFault(exp); |
| } |
| } |
| |
| void setUser(String user) { |
| ((Stub)binding).setUsername(user); |
| } |
| |
| void setPassword(String password) { |
| ((Stub)binding).setPassword(password); |
| } |
| |
| /** |
| * Execute all tests. |
| */ |
| public void executeAll() throws Exception { |
| execute2A(); |
| execute2B(); |
| executeAxisXSD(); |
| } |
| |
| /** |
| * Test custom mapping of xsd types not standardized: xsd:token and |
| * xsd:normalizedString. |
| */ |
| public void executeAxisXSD() throws Exception { |
| Object output = null; |
| |
| // Test xsd:token |
| Token tInput = new Token("abccdefg"); |
| try { |
| output = binding.echoToken(tInput); |
| verify("echoToken", tInput, output); |
| } catch (Exception e) { |
| if (!testMode) { |
| verify("echoToken", tInput, e); |
| } else { |
| throw e; |
| } |
| } |
| |
| // Test xsd:normalizedString |
| NormalizedString nsInput = new NormalizedString("abccdefg"); |
| try { |
| output = binding.echoNormalizedString(nsInput); |
| verify("echoNormalizedString", nsInput, output); |
| } catch (Exception e) { |
| if (!testMode) { |
| verify("echoNormalizedString", nsInput, e); |
| } else { |
| throw e; |
| } |
| } |
| |
| // Test xsd:unsignedLong |
| UnsignedLong ulInput = new UnsignedLong(100); |
| try { |
| output = binding.echoUnsignedLong(ulInput); |
| verify("echoUnsignedLong", ulInput, output); |
| } catch (Exception e) { |
| if (!testMode) { |
| verify("echoUnsignedLong", ulInput, e); |
| } else { |
| throw e; |
| } |
| } |
| |
| // Test xsd:unsignedInt |
| UnsignedInt uiInput = new UnsignedInt(101); |
| try { |
| output = binding.echoUnsignedInt(uiInput); |
| verify("echoUnsignedInt", uiInput, output); |
| } catch (Exception e) { |
| if (!testMode) { |
| verify("echoUnsignedInt", uiInput, e); |
| } else { |
| throw e; |
| } |
| } |
| |
| // Test xsd:unsignedShort |
| UnsignedShort usInput = new UnsignedShort(102); |
| try { |
| output = binding.echoUnsignedShort(usInput); |
| verify("echoUnsignedShort", usInput, output); |
| } catch (Exception e) { |
| if (!testMode) { |
| verify("echoUnsignedShort", usInput, e); |
| } else { |
| throw e; |
| } |
| } |
| |
| // Test xsd:unsignedByte |
| UnsignedByte ubInput = new UnsignedByte(103); |
| try { |
| output = binding.echoUnsignedByte(ubInput); |
| verify("echoUnsignedByte", ubInput, output); |
| } catch (Exception e) { |
| if (!testMode) { |
| verify("echoUnsignedByte", ubInput, e); |
| } else { |
| throw e; |
| } |
| } |
| |
| // Test xsd:nonNegativeInteger |
| NonNegativeInteger nniInput = new NonNegativeInteger("12345678901234567890"); |
| try { |
| output = binding.echoNonNegativeInteger(nniInput); |
| verify("echoNonNegativeInteger", nniInput, output); |
| } catch (Exception e) { |
| if (!testMode) { |
| verify("echoNonNegativeInteger", nniInput, e); |
| } else { |
| throw e; |
| } |
| } |
| |
| // Test xsd:positiveInteger |
| PositiveInteger piInput = new PositiveInteger("12345678901234567890"); |
| try { |
| output = binding.echoPositiveInteger(piInput); |
| verify("echoPositiveInteger", piInput, output); |
| } catch (Exception e) { |
| if (!testMode) { |
| verify("echoPositiveInteger", piInput, e); |
| } else { |
| throw e; |
| } |
| } |
| |
| // Test xsd:nonPositiveInteger |
| NonPositiveInteger npiInput = new NonPositiveInteger("-12345678901234567890"); |
| try { |
| output = binding.echoNonPositiveInteger(npiInput); |
| verify("echoNonPositiveInteger", npiInput, output); |
| } catch (Exception e) { |
| if (!testMode) { |
| verify("echoNonPositiveInteger", npiInput, e); |
| } else { |
| throw e; |
| } |
| } |
| |
| // Test xsd:negativeInteger |
| NegativeInteger niInput = new NegativeInteger("-12345678901234567890"); |
| try { |
| output = binding.echoNegativeInteger(niInput); |
| verify("echoNegativeInteger", niInput, output); |
| } catch (Exception e) { |
| if (!testMode) { |
| verify("echoNegativeInteger", niInput, e); |
| } else { |
| throw e; |
| } |
| } |
| |
| } |
| |
| /** |
| * Execute the 2A tests |
| */ |
| public void execute2A() throws Exception { |
| // execute the tests |
| Object output = null; |
| |
| { |
| String input = "abccdefg"; |
| try { |
| output = binding.echoString(input); |
| verify("echoString", input, output); |
| } catch (Exception e) { |
| if (!testMode) { |
| verify("echoString", input, e); |
| } else { |
| throw e; |
| } |
| } |
| } |
| |
| { |
| String[] input = new String[] {"abc", "def"}; |
| try { |
| output = binding.echoStringArray(input); |
| verify("echoStringArray", input, output); |
| } catch (Exception e) { |
| if (!testMode) { |
| verify("echoStringArray", input, e); |
| } else { |
| throw e; |
| } |
| } |
| } |
| |
| { |
| Integer input = new Integer(42); |
| try { |
| output = new Integer( binding.echoInteger(input.intValue())); |
| verify("echoInteger", input, output); |
| } catch (Exception e) { |
| if (!testMode) { |
| verify("echoInteger", input, e); |
| } else { |
| throw e; |
| } |
| } |
| } |
| |
| { |
| int[] input = new int[] {42}; |
| try { |
| output = binding.echoIntegerArray(input); |
| verify("echoIntegerArray", input, output); |
| } catch (Exception e) { |
| if (!testMode) { |
| verify("echoIntegerArray", input, e); |
| } else { |
| throw e; |
| } |
| } |
| } |
| |
| { |
| Float input = new Float(3.7F); |
| try { |
| output = new Float(binding.echoFloat(input.floatValue())); |
| verify("echoFloat", input, output); |
| } catch (Exception e) { |
| if (!testMode) { |
| verify("echoFloat", input, e); |
| } else { |
| throw e; |
| } |
| } |
| } |
| |
| { |
| float[] input = new float[] {3.7F, 7F}; |
| try { |
| output = binding.echoFloatArray(input); |
| verify("echoFloatArray", input, output); |
| } catch (Exception e) { |
| if (!testMode) { |
| verify("echoFloatArray", input, e); |
| } else { |
| throw e; |
| } |
| } |
| } |
| |
| { |
| SOAPStruct input = new SOAPStruct(); |
| input.setVarInt(5); |
| input.setVarString("Hello"); |
| input.setVarFloat(103F); |
| try { |
| output = binding.echoStruct(input); |
| verify("echoStruct", input, output); |
| } catch (Exception e) { |
| if (!testMode) { |
| verify("echoStruct", input, e); |
| } else { |
| throw e; |
| } |
| } |
| } |
| |
| { |
| SOAPStruct[] input = new SOAPStruct[] { |
| new SOAPStruct(), |
| new SOAPStruct(), |
| new SOAPStruct()}; |
| input[0].setVarInt(1); |
| input[0].setVarString("one"); |
| input[0].setVarFloat(1.1F); |
| input[1].setVarInt(2); |
| input[1].setVarString("two"); |
| input[1].setVarFloat(2.2F); |
| input[2].setVarInt(3); |
| input[2].setVarString("three"); |
| input[2].setVarFloat(3.3F); |
| |
| try { |
| output = binding.echoStructArray(input); |
| verify("echoStructArray", input, output); |
| } catch (Exception e) { |
| if (!testMode) { |
| verify("echoStructArray", input, e); |
| } else { |
| throw e; |
| } |
| } |
| } |
| |
| { |
| try { |
| binding.echoVoid(); |
| verify("echoVoid", null, null); |
| } catch (Exception e) { |
| if (!testMode) { |
| verify("echoVoid", null, e); |
| } else { |
| throw e; |
| } |
| } |
| } |
| |
| { |
| byte[] input = "Base64".getBytes(); |
| try { |
| output = binding.echoBase64(input); |
| verify("echoBase64", input, output); |
| } catch (Exception e) { |
| if (!testMode) { |
| verify("echoBase64", input, e); |
| } else { |
| throw e; |
| } |
| } |
| } |
| |
| { |
| HexBinary input = new HexBinary("3344"); |
| try { |
| output = binding.echoHexBinary(input.getBytes()); |
| verify("echoHexBinary", input, output); |
| } catch (Exception e) { |
| if (!testMode) { |
| verify("echoHexBinary", input, e); |
| } else { |
| throw e; |
| } |
| } |
| } |
| Calendar inputDate = Calendar.getInstance(); |
| inputDate.setTimeZone(TimeZone.getTimeZone("GMT")); |
| inputDate.setTime(new Date()); |
| { |
| try { |
| output = binding.echoDate(inputDate); |
| verify("echoDate", inputDate, output); |
| } catch (Exception e) { |
| if (!testMode) { |
| verify("echoDate", inputDate, e); |
| } else { |
| throw e; |
| } |
| } |
| } |
| |
| { |
| BigDecimal input = new BigDecimal("3.14159"); |
| try { |
| output = binding.echoDecimal(input); |
| verify("echoDecimal", input, output); |
| } catch (Exception e) { |
| if (!testMode) { |
| verify("echoDecimal", input, e); |
| } else { |
| throw e; |
| } |
| } |
| } |
| |
| { |
| Boolean input = Boolean.TRUE; |
| try { |
| output = new Boolean( binding.echoBoolean(input.booleanValue())); |
| verify("echoBoolean", input, output); |
| } catch (Exception e) { |
| if (!testMode) { |
| verify("echoBoolean", input, e); |
| } else { |
| throw e; |
| } |
| } |
| } |
| |
| HashMap map = new HashMap(); |
| map.put(new Integer(5), "String Value"); |
| map.put("String Key", inputDate); |
| { |
| HashMap input = map; |
| try { |
| output = binding.echoMap(input); |
| verify("echoMap", input, output); |
| } catch (Exception e) { |
| if (!testMode) { |
| verify("echoMap", input, e); |
| } else { |
| throw e; |
| } |
| } |
| } |
| |
| HashMap map2 = new HashMap(); |
| map2.put("this is the second map", new Boolean(true)); |
| map2.put("test", new Float(411)); |
| { |
| HashMap[] input = new HashMap [] {map, map2 }; |
| try { |
| output = binding.echoMapArray(input); |
| verify("echoMapArray", input, output); |
| } catch (Exception e) { |
| if (!testMode) { |
| verify("echoMapArray", input, e); |
| } else { |
| throw e; |
| } |
| } |
| } |
| } |
| |
| /** |
| * Execute the 2B tests |
| */ |
| public void execute2B() throws Exception { |
| // execute the tests |
| Object output = null; |
| { |
| SOAPStruct input = new SOAPStruct(); |
| input.setVarInt(5); |
| input.setVarString("Hello"); |
| input.setVarFloat(103F); |
| try { |
| StringHolder outputString = new StringHolder(); |
| IntHolder outputInteger = new IntHolder(); |
| FloatHolder outputFloat = new FloatHolder(); |
| binding.echoStructAsSimpleTypes(input, outputString, |
| outputInteger, outputFloat); |
| output = new SOAPStruct(); |
| ((SOAPStruct)output).setVarInt(outputInteger.value); |
| ((SOAPStruct)output).setVarString(outputString.value); |
| ((SOAPStruct)output).setVarFloat(outputFloat.value); |
| verify("echoStructAsSimpleTypes", |
| input, output); |
| } catch (Exception e) { |
| if (!testMode) { |
| verify("echoStructAsSimpleTypes", input, e); |
| } else { |
| throw e; |
| } |
| } |
| } |
| |
| { |
| SOAPStruct input = new SOAPStruct(); |
| input.setVarInt(5); |
| input.setVarString("Hello"); |
| input.setVarFloat(103F); |
| try { |
| output = binding.echoSimpleTypesAsStruct( |
| input.getVarString(), input.getVarInt(), input.getVarFloat()); |
| verify("echoSimpleTypesAsStruct", |
| input, |
| output); |
| } catch (Exception e) { |
| if (!testMode) { |
| verify("echoSimpleTypesAsStruct", input, e); |
| } else { |
| throw e; |
| } |
| } |
| } |
| |
| { |
| String[][] input = new String[2][2]; |
| input[0][0] = "00"; |
| input[0][1] = "01"; |
| input[1][0] = "10"; |
| input[1][1] = "11"; |
| try { |
| output = binding.echo2DStringArray(input); |
| verify("echo2DStringArray", |
| input, |
| output); |
| } catch (Exception e) { |
| if (!testMode) { |
| verify("echo2DStringArray", input, e); |
| } else { |
| throw e; |
| } |
| } |
| } |
| |
| { |
| SOAPStruct inputS =new SOAPStruct(); |
| inputS.setVarInt(5); |
| inputS.setVarString("Hello"); |
| inputS.setVarFloat(103F); |
| SOAPStructStruct input = new SOAPStructStruct(); |
| input.setVarString("AXIS"); |
| input.setVarInt(1); |
| input.setVarFloat(3F); |
| input.setVarStruct(inputS); |
| try { |
| output = binding.echoNestedStruct(input); |
| verify("echoNestedStruct", input, output); |
| } catch (Exception e) { |
| if (!testMode) { |
| verify("echoNestedStruct", input, e); |
| } else { |
| throw e; |
| } |
| } |
| } |
| { |
| SOAPArrayStruct input = new SOAPArrayStruct(); |
| input.setVarString("AXIS"); |
| input.setVarInt(1); |
| input.setVarFloat(3F); |
| input.setVarArray(new String[] {"one", "two", "three"}); |
| try { |
| output = binding.echoNestedArray(input); |
| verify("echoNestedArray", input, output); |
| } catch (Exception e) { |
| if (!testMode) { |
| verify("echoNestedArray", input, e); |
| } else { |
| throw e; |
| } |
| } |
| } |
| } |
| |
| /** |
| * Verify that the object sent was, indeed, the one you got back. |
| * Subclasses are sent to override this with their own output. |
| */ |
| protected abstract void verify(String method, Object sent, Object gotBack); |
| |
| /** |
| * Main entry point. Tests a variety of echo methods and reports |
| * on their results. |
| * |
| * Arguments are of the form: |
| * -h localhost -p 8080 -s /soap/servlet/rpcrouter |
| * -h indicats the host |
| */ |
| public static void main(String args[]) throws Exception { |
| Options opts = new Options(args); |
| |
| boolean testPerformance = opts.isFlagSet('k') > 0; |
| boolean allTests = opts.isFlagSet('A') > 0; |
| boolean onlyB = opts.isFlagSet('b') > 0; |
| boolean testMode = opts.isFlagSet('t') > 0; |
| |
| // set up tests so that the results are sent to System.out |
| TestClient client; |
| |
| if (testPerformance) { |
| client = new TestClient(testMode) { |
| public void verify(String method, Object sent, Object gotBack) { |
| } |
| }; |
| } else { |
| client = new TestClient(testMode) { |
| public void verify(String method, Object sent, Object gotBack) { |
| String message; |
| if (this.equals(sent, gotBack)) { |
| message = "OK"; |
| } else { |
| if (gotBack instanceof Exception) { |
| if (gotBack instanceof AxisFault) { |
| message = "Fault: " + |
| ((AxisFault)gotBack).getFaultString(); |
| } else { |
| StringWriter sw = new StringWriter(); |
| PrintWriter pw = new PrintWriter(sw); |
| message = "Exception: "; |
| ((Exception)gotBack).printStackTrace(pw); |
| message += sw.getBuffer().toString(); |
| } |
| } else { |
| message = "Fail:" + gotBack + " expected " + sent; |
| } |
| } |
| // Line up the output |
| String tab = ""; |
| int l = method.length(); |
| while (l < 25) { |
| tab += " "; |
| l++; |
| } |
| System.out.println(method + tab + " " + message); |
| } |
| }; |
| } |
| |
| // set up the call object |
| client.setURL(opts.getURL()); |
| client.setUser(opts.getUser()); |
| client.setPassword(opts.getPassword()); |
| |
| if (testPerformance) { |
| long startTime = System.currentTimeMillis(); |
| for (int i = 0; i < 10; i++) { |
| if (allTests) { |
| client.executeAll(); |
| } else if (onlyB) { |
| client.execute2B(); |
| } else { |
| client.execute2A(); |
| } |
| } |
| long stopTime = System.currentTimeMillis(); |
| System.out.println("That took " + (stopTime - startTime) + " milliseconds"); |
| } else { |
| if (allTests) { |
| client.executeAll(); |
| } else if (onlyB) { |
| client.execute2B(); |
| } else { |
| client.execute2A(); |
| } |
| } |
| } |
| } |
