| /* |
| * 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 test.wsdl.roundtrip; |
| |
| import junit.framework.TestCase; |
| import test.wsdl.roundtrip.holders.BondInvestmentHolder; |
| |
| import javax.xml.rpc.ServiceException; |
| import javax.xml.rpc.holders.StringHolder; |
| import java.math.BigDecimal; |
| import java.math.BigInteger; |
| import java.rmi.RemoteException; |
| import java.util.Calendar; |
| import java.util.Date; |
| import java.util.HashMap; |
| import java.util.TimeZone; |
| |
| /** |
| * This class contains the test methods to verify that Java mapping |
| * to XML/WSDL works as specified by the JAX-RPC specification. |
| * |
| * The following items are tested: |
| * - Primitives |
| * - Standard Java Classes |
| * - Arrays |
| * - Multiple Arrays |
| * - JAX-RPC Value Types |
| * - Nillables (when used with literal element declarations) |
| * |
| * @version 1.00 06 Feb 2002 |
| * @author Brent Ulbricht |
| */ |
| public class RoundtripTestServiceTestCase extends TestCase { |
| |
| private RoundtripPortType binding = null; |
| private RoundtripPortType binding2 = null; |
| private static final double DOUBLE_DELTA = 0.0D; |
| private static final float FLOAT_DELTA = 0.0F; |
| |
| /** |
| * The Junit framework requires that each class that subclasses |
| * TestCase define a constructor accepting a string. This method |
| * can be used to specify a specific testXXXXX method in this |
| * class to run. |
| */ |
| public RoundtripTestServiceTestCase(String name) { |
| super(name); |
| } // Constructor |
| |
| /** |
| * The setUp method executes before each test method in this class |
| * to get the binding. |
| */ |
| public void setUp() { |
| |
| try { |
| binding = new RoundtripPortTypeServiceLocator().getRoundtripTest(); |
| binding2 = new RoundtripPortTypeServiceLocator().getRoundtripTest2(); |
| } catch (ServiceException jre) { |
| fail("JAX-RPC ServiceException caught: " + jre); |
| } |
| assertTrue("binding is null", binding != null); |
| |
| } // setUp |
| |
| /** |
| * Test to insure that a JAX-RPC Value Type works correctly. StockInvestment |
| * subclasses Investment and should pass data members in both the Investment |
| * and StockInvestment classes across the wire correctly. |
| */ |
| public void testStockInvestment() throws Exception { |
| StockInvestment stock = new StockInvestment(); |
| stock.setName("International Business Machines"); |
| stock.setId(1); |
| stock.setTradeExchange("NYSE"); |
| stock.setLastTradePrice(200.55F); |
| float lastTradePrice = binding.getRealtimeLastTradePrice(stock); |
| assertEquals("The expected and actual values did not match.", |
| 201.25F, |
| lastTradePrice, |
| FLOAT_DELTA); |
| // Make sure static field dontMapToWSDL is not mapped. |
| try { |
| (StockInvestment.class). |
| getDeclaredMethod("getDontMapToWSDL", |
| new Class[] {}); |
| fail("Should not map static member dontMapToWSDL"); |
| } catch (NoSuchMethodException e) { |
| // Cool the method should not be in the class |
| } |
| |
| // Make sure private field avgYearlyReturn is not mapped. |
| try { |
| (StockInvestment.class).getDeclaredMethod("getAvgYearlyReturn", |
| new Class[] {}); |
| fail("Should not map private member avgYearlyReturn"); |
| } catch (NoSuchMethodException e) { |
| // Cool the method should not be in the class |
| } |
| } // testStockInvestment |
| |
| /** |
| * Like the above test, but uses the alternate port. |
| */ |
| public void testStockInvestmentWithPort2() throws Exception { |
| StockInvestment stock = new StockInvestment(); |
| stock.setName("International Business Machines"); |
| stock.setId(1); |
| stock.setTradeExchange("NYSE"); |
| stock.setLastTradePrice(200.55F); |
| float lastTradePrice = binding2.getRealtimeLastTradePrice(stock); |
| assertEquals("The expected and actual values did not match.", |
| 201.25F, |
| lastTradePrice, |
| FLOAT_DELTA); |
| // Make sure static field dontMapToWSDL is not mapped. |
| try { |
| (StockInvestment.class).getDeclaredMethod("getDontMapToWSDL", |
| new Class[] {}); |
| fail("Should not map static member dontMapToWSDL"); |
| } catch (NoSuchMethodException e) { |
| // Cool the method should not be in the class |
| } |
| |
| // Make sure private field avgYearlyReturn is not mapped. |
| try { |
| (StockInvestment.class).getDeclaredMethod("getAvgYearlyReturn", |
| new Class[] {}); |
| fail("Should not map private member avgYearlyReturn"); |
| } catch (NoSuchMethodException e) { |
| // Cool the method should not be in the class |
| } |
| } // testStockInvestmentWithPort2 |
| |
| /** |
| * Test to insure that a JAX-RPC Value Type works correctly. PreferredStockInvestment |
| * subclasses StockInvestment and should pass data members in both the Investment, |
| * StockInvestment, and PreferredStockInvestment classes across the wire correctly. |
| */ |
| public void testPreferredStockInvestment() throws RemoteException { |
| PreferredStockInvestment oldStock = new PreferredStockInvestment(); |
| oldStock.setName("SOAP Inc."); |
| oldStock.setId(202); |
| oldStock.setTradeExchange("NASDAQ"); |
| oldStock.setLastTradePrice(10.50F); |
| oldStock.setDividendsInArrears(100.44D); |
| oldStock.setPreferredYield(new BigDecimal("7.00")); |
| PreferredStockInvestment newStock = binding.getDividends(oldStock); |
| assertEquals("The expected and actual values did not match.", |
| newStock.getName(), |
| "AXIS Inc."); |
| assertEquals("The expected and actual values did not match.", |
| 203, |
| newStock.getId()); |
| assertEquals("The expected and actual values did not match.", |
| "NASDAQ", |
| newStock.getTradeExchange()); |
| assertEquals("The expected and actual values did not match.", |
| 101.44D, |
| newStock.getDividendsInArrears(), |
| DOUBLE_DELTA); |
| assertEquals("The expected and actual values did not match.", |
| new BigDecimal("8.00"), |
| newStock.getPreferredYield()); |
| assertEquals("The expected and actual values did not match.", |
| 11.50F, |
| newStock.getLastTradePrice(), |
| FLOAT_DELTA); |
| } // testPreferredStockInvestment |
| |
| /** |
| * The BondInvestment class contains all the supported data members: |
| * primitives, standard Java classes, arrays, and primitive wrapper |
| * classes. This test insures that the data is transmitted across |
| * the wire correctly. |
| */ |
| public void testRoundtripBondInvestment() throws RemoteException { |
| CallOptions[] callOptions = new CallOptions[2]; |
| callOptions[0] = new CallOptions(); |
| Calendar date = Calendar.getInstance(); |
| TimeZone gmt = TimeZone.getTimeZone("GMT"); |
| date.setTimeZone(gmt); |
| date.setTime(new Date(1013441507388L)); |
| callOptions[0].setCallDate(date); |
| callOptions[1] = new CallOptions(); |
| date = Calendar.getInstance(); |
| date.setTimeZone(gmt); |
| date.setTime(new Date(1013441507390L)); |
| callOptions[1].setCallDate(date); |
| HashMap map = new HashMap(); |
| map.put("Test", "Test Works"); |
| |
| short[] shortArray = {(short) 30}; |
| byte[] byteArray = {(byte) 1}; |
| Short[] wrapperShortArray = {new Short((short) 23), new Short((short) 56)}; |
| Byte[] wrapperByteArray = {new Byte((byte) 2), new Byte((byte) 15)}; |
| |
| BondInvestment sendValue = new BondInvestment(); |
| |
| sendValue.setMap(map); |
| sendValue.setOptions(callOptions); |
| sendValue.setOptions2(callOptions); |
| sendValue.setOptions3(callOptions[0]); |
| sendValue.setWrapperShortArray(wrapperShortArray); |
| sendValue.setWrapperByteArray(wrapperByteArray); |
| sendValue.setWrapperDouble(new Double(2323.232D)); |
| sendValue.setWrapperFloat(new Float(23.023F)); |
| sendValue.setWrapperInteger(new Integer(2093)); |
| sendValue.setWrapperShort(new Short((short) 203)); |
| sendValue.setWrapperByte(new Byte((byte) 20)); |
| sendValue.setWrapperBoolean(new Boolean(true)); |
| sendValue.setShortArray(shortArray); |
| sendValue.setByteArray(byteArray); |
| date = Calendar.getInstance(); |
| date.setTimeZone(gmt); |
| date.setTime(new Date(1012937861996L)); |
| sendValue.setCallableDate(date); |
| sendValue.setBondAmount(new BigDecimal("2675.23")); |
| sendValue.setPortfolioType(new BigInteger("2093")); |
| sendValue.setTradeExchange("NYSE"); |
| sendValue.setFiftyTwoWeekHigh(45.012D); |
| sendValue.setLastTradePrice(87895.32F); |
| sendValue.setYield(5475L); |
| sendValue.setStockBeta(32); |
| sendValue.setDocType((short) 35); |
| sendValue.setTaxIndicator((byte) 3); |
| |
| BondInvestment actual = binding.methodBondInvestmentInOut(sendValue); |
| date.setTime(new Date(1013441507308L)); |
| |
| assertEquals("Returned map is not correct.", |
| actual.getMap().get("Test"), "Test Works"); |
| assertEquals("The expected and actual values did not match.", |
| date, |
| actual.getOptions()[0].getCallDate()); |
| date.setTime(new Date(1013441507328L)); |
| assertEquals("The expected and actual values did not match.", |
| date, |
| actual.getOptions()[1].getCallDate()); |
| assertEquals("The expected and actual values did not match.", |
| new Short((short) 33), |
| actual.getWrapperShortArray()[0]); |
| assertEquals("The expected and actual values did not match.", |
| new Short((short) 86), |
| actual.getWrapperShortArray()[1]); |
| assertEquals("The expected and actual values did not match.", |
| new Byte((byte) 4), |
| actual.getWrapperByteArray()[0]); |
| assertEquals("The expected and actual values did not match.", |
| new Byte((byte) 18), |
| actual.getWrapperByteArray()[1]); |
| assertEquals("The expected and actual values did not match.", |
| new Double(33.232D), |
| actual.getWrapperDouble()); |
| assertEquals("The expected and actual values did not match.", |
| new Float(2.23F), |
| actual.getWrapperFloat()); |
| assertEquals("The expected and actual values did not match.", |
| new Integer(3), |
| actual.getWrapperInteger()); |
| assertEquals("The expected and actual values did not match.", |
| new Short((short) 2), |
| actual.getWrapperShort()); |
| assertEquals("The expected and actual values did not match.", |
| new Byte((byte) 21), |
| actual.getWrapperByte()); |
| assertEquals("The expected and actual values did not match.", |
| new Boolean(false), |
| actual.getWrapperBoolean()); |
| assertEquals("The expected and actual values did not match.", |
| (short) 36, |
| actual.getShortArray()[0]); |
| assertEquals("The expected and actual values did not match.", |
| (byte) 7, |
| actual.getByteArray()[0]); |
| date.setTime(new Date(1012937862997L)); |
| assertEquals("The expected and actual values did not match.", |
| date, |
| actual.getCallableDate()); |
| assertEquals("The expected and actual values did not match.", |
| new BigDecimal("2735.23"), |
| actual.getBondAmount()); |
| assertEquals("The expected and actual values did not match.", |
| new BigInteger("21093"), |
| actual.getPortfolioType()); |
| assertEquals("The expected and actual values did not match.", |
| new String("AMEX"), |
| actual.getTradeExchange()); |
| assertEquals("The expected and actual values did not match.", |
| 415.012D, |
| actual.getFiftyTwoWeekHigh(), |
| DOUBLE_DELTA); |
| assertEquals("The expected and actual values did not match.", |
| 8795.32F, |
| actual.getLastTradePrice(), |
| FLOAT_DELTA); |
| assertEquals("The expected and actual values did not match.", |
| 575L, |
| actual.getYield()); |
| assertEquals("The expected and actual values did not match.", |
| 3, |
| actual.getStockBeta()); |
| assertEquals("The expected and actual values did not match.", |
| (short) 45, |
| actual.getDocType()); |
| assertEquals("The expected and actual values did not match.", |
| (byte) 8, |
| actual.getTaxIndicator()); |
| } // testRoundtripBondInvestment |
| |
| /** |
| * The BondInvestment class contains all the supported data members: |
| * primitives, standard Java classes, arrays, and primitive wrapper |
| * classes. This test insures that a BondInvestment class received |
| * by a remote method contains the expected values. |
| */ |
| public void testBondInvestmentOut() throws RemoteException { |
| BondInvestment actual = binding.methodBondInvestmentOut(); |
| Calendar date = Calendar.getInstance(); |
| TimeZone gmt = TimeZone.getTimeZone("GMT"); |
| date.setTimeZone(gmt); |
| date.setTime(new Date(1013441507308L)); |
| assertEquals("Returned map is not correct.", |
| actual.getMap().get("Test"), "Test Works"); |
| assertEquals("The expected and actual values did not match.", |
| date, |
| actual.getOptions()[0].getCallDate()); |
| date.setTime(new Date(1013441507328L)); |
| assertEquals("The expected and actual values did not match.", |
| date, |
| actual.getOptions()[1].getCallDate()); |
| assertEquals("The expected and actual values did not match.", |
| new Short((short) 33), |
| actual.getWrapperShortArray()[0]); |
| assertEquals("The expected and actual values did not match.", |
| new Short((short) 86), |
| actual.getWrapperShortArray()[1]); |
| assertEquals("The expected and actual values did not match.", |
| new Byte((byte) 4), |
| actual.getWrapperByteArray()[0]); |
| assertEquals("The expected and actual values did not match.", |
| new Byte((byte) 18), |
| actual.getWrapperByteArray()[1]); |
| assertEquals("The expected and actual values did not match.", |
| new Double(33.232D), |
| actual.getWrapperDouble()); |
| assertEquals("The expected and actual values did not match.", |
| new Float(2.23F), |
| actual.getWrapperFloat()); |
| assertEquals("The expected and actual values did not match.", |
| new Integer(3), |
| actual.getWrapperInteger()); |
| assertEquals("The expected and actual values did not match.", |
| new Short((short) 2), |
| actual.getWrapperShort()); |
| assertEquals("The expected and actual values did not match.", |
| new Byte((byte) 21), |
| actual.getWrapperByte()); |
| assertEquals("The expected and actual values did not match.", |
| new Boolean(false), |
| actual.getWrapperBoolean()); |
| assertEquals("The expected and actual values did not match.", |
| (short) 36, |
| actual.getShortArray()[0]); |
| assertEquals("The expected and actual values did not match.", |
| (byte) 7, |
| actual.getByteArray()[0]); |
| date.setTime(new Date(1012937862997L)); |
| assertEquals("The expected and actual values did not match.", |
| date, |
| actual.getCallableDate()); |
| assertEquals("The expected and actual values did not match.", |
| new BigDecimal("2735.23"), |
| actual.getBondAmount()); |
| assertEquals("The expected and actual values did not match.", |
| new BigInteger("21093"), |
| actual.getPortfolioType()); |
| assertEquals("The expected and actual values did not match.", |
| new String("AMEX"), |
| actual.getTradeExchange()); |
| assertEquals("The expected and actual values did not match.", |
| 415.012D, |
| actual.getFiftyTwoWeekHigh(), |
| DOUBLE_DELTA); |
| assertEquals("The expected and actual values did not match.", |
| 8795.32F, |
| actual.getLastTradePrice(), |
| FLOAT_DELTA); |
| assertEquals("The expected and actual values did not match.", |
| 575L, |
| actual.getYield()); |
| assertEquals("The expected and actual values did not match.", |
| 3, |
| actual.getStockBeta()); |
| assertEquals("The expected and actual values did not match.", |
| (short) 45, |
| actual.getDocType()); |
| assertEquals("The expected and actual values did not match.", |
| (byte) 8, |
| actual.getTaxIndicator()); |
| } // testBondInvestmentOut |
| |
| /** |
| * The BondInvestment class contains all the supported data members: |
| * primitives, standard Java classes, arrays, and primitive wrapper |
| * classes. This test insures that a remote method can recieve the |
| * BondInvestment class and that its values match the expected values. |
| */ |
| public void testBondInvestmentIn() throws RemoteException { |
| CallOptions[] callOptions = new CallOptions[2]; |
| callOptions[0] = new CallOptions(); |
| Calendar date = Calendar.getInstance(); |
| TimeZone gmt = TimeZone.getTimeZone("GMT"); |
| date.setTimeZone(gmt); |
| date.setTime(new Date(1013441507388L)); |
| callOptions[0].setCallDate(date); |
| callOptions[1] = new CallOptions(); |
| date = Calendar.getInstance(); |
| date.setTimeZone(gmt); |
| date.setTime(new Date(1013441507390L)); |
| callOptions[1].setCallDate(date); |
| HashMap map = new HashMap(); |
| map.put("Test", "Test Works"); |
| |
| |
| short[] shortArray = {(short) 30}; |
| byte[] byteArray = {(byte) 1}; |
| Short[] wrapperShortArray = {new Short((short) 23), new Short((short) 56)}; |
| Byte[] wrapperByteArray = {new Byte((byte) 2), new Byte((byte) 15)}; |
| |
| BondInvestment sendValue = new BondInvestment(); |
| |
| sendValue.setMap(map); |
| sendValue.setOptions(callOptions); |
| sendValue.setOptions2(callOptions); |
| sendValue.setOptions3(callOptions[0]); |
| sendValue.setWrapperShortArray(wrapperShortArray); |
| sendValue.setWrapperByteArray(wrapperByteArray); |
| sendValue.setWrapperDouble(new Double(2323.232D)); |
| sendValue.setWrapperFloat(new Float(23.023F)); |
| sendValue.setWrapperInteger(new Integer(2093)); |
| sendValue.setWrapperShort(new Short((short) 203)); |
| sendValue.setWrapperByte(new Byte((byte) 20)); |
| sendValue.setWrapperBoolean(new Boolean(true)); |
| sendValue.setShortArray(shortArray); |
| sendValue.setByteArray(byteArray); |
| date = Calendar.getInstance(); |
| date.setTimeZone(gmt); |
| date.setTime(new Date(1012937861996L)); |
| sendValue.setCallableDate(date); |
| sendValue.setBondAmount(new BigDecimal("2675.23")); |
| sendValue.setPortfolioType(new BigInteger("2093")); |
| sendValue.setTradeExchange("NYSE"); |
| sendValue.setFiftyTwoWeekHigh(45.012D); |
| sendValue.setLastTradePrice(87895.32F); |
| sendValue.setYield(5475L); |
| sendValue.setStockBeta(32); |
| sendValue.setDocType((short) 35); |
| sendValue.setTaxIndicator((byte) 3); |
| |
| binding.methodBondInvestmentIn(sendValue); |
| } // testBondInvestmentIn |
| |
| /** |
| * Test the overloaded method getId with a BondInvestment. |
| */ |
| public void testBondInvestmentGetId() throws RemoteException { |
| CallOptions[] callOptions = new CallOptions[2]; |
| callOptions[0] = new CallOptions(); |
| Calendar date = Calendar.getInstance(); |
| TimeZone gmt = TimeZone.getTimeZone("GMT"); |
| date.setTimeZone(gmt); |
| date.setTime(new Date(1013441507388L)); |
| callOptions[0].setCallDate(date); |
| callOptions[1] = new CallOptions(); |
| date = Calendar.getInstance(); |
| date.setTimeZone(gmt); |
| date.setTime(new Date(1013441507390L)); |
| callOptions[1].setCallDate(date); |
| |
| short[] shortArray = {(short) 30}; |
| byte[] byteArray = {(byte) 1}; |
| Short[] wrapperShortArray = {new Short((short) 23), new Short((short) 56)}; |
| Byte[] wrapperByteArray = {new Byte((byte) 2), new Byte((byte) 15)}; |
| |
| BondInvestment sendValue = new BondInvestment(); |
| |
| sendValue.setOptions(callOptions); |
| sendValue.setOptions2(callOptions); |
| sendValue.setOptions3(callOptions[0]); |
| sendValue.setWrapperShortArray(wrapperShortArray); |
| sendValue.setWrapperByteArray(wrapperByteArray); |
| sendValue.setWrapperDouble(new Double(2323.232D)); |
| sendValue.setWrapperFloat(new Float(23.023F)); |
| sendValue.setWrapperInteger(new Integer(2093)); |
| sendValue.setWrapperShort(new Short((short) 203)); |
| sendValue.setWrapperByte(new Byte((byte) 20)); |
| sendValue.setWrapperBoolean(new Boolean(true)); |
| sendValue.setShortArray(shortArray); |
| sendValue.setByteArray(byteArray); |
| date = Calendar.getInstance(); |
| date.setTimeZone(gmt); |
| date.setTime(new Date(1012937861996L)); |
| sendValue.setCallableDate(date); |
| sendValue.setBondAmount(new BigDecimal("2675.23")); |
| sendValue.setPortfolioType(new BigInteger("2093")); |
| sendValue.setTradeExchange("NYSE"); |
| sendValue.setFiftyTwoWeekHigh(45.012D); |
| sendValue.setLastTradePrice(87895.32F); |
| sendValue.setYield(5475L); |
| sendValue.setStockBeta(32); |
| sendValue.setDocType((short) 35); |
| sendValue.setTaxIndicator((byte) 3); |
| sendValue.setId(-123); |
| |
| int id = binding.getId(sendValue); |
| assertEquals("The wrong id was sent back", -123, id); |
| } // testBondInvestmentGetId |
| |
| /** |
| * Test the overloaded method getId with a StockInvestment. |
| */ |
| public void testInvestmentGetId() throws RemoteException { |
| StockInvestment stock = new StockInvestment(); |
| stock.setName("International Business Machines"); |
| stock.setId(1); |
| stock.setTradeExchange("NYSE"); |
| stock.setLastTradePrice(200.55F); |
| |
| // Temporarily commented out until I can get this to work. |
| int id = binding.getId(stock); |
| assertEquals("The wrong id was sent back", 1, id); |
| } // testInvestmentGetId |
| |
| /** |
| * Test to insure that a multiple array sent by a remote method can be |
| * received and its values match the expected values. |
| */ |
| public void testMethodStringMArrayOut() throws RemoteException { |
| String[][] expected = {{"Out-0-0"}, {"Out-1-0"}}; |
| String[][] actual = binding.methodStringMArrayOut(); |
| assertEquals("The expected and actual values did not match.", |
| expected[0][0], |
| actual[0][0]); |
| assertEquals("The expected and actual values did not match.", |
| expected[1][0], |
| actual[1][0]); |
| } // testMethodStringMArrayOut |
| |
| /** |
| * Test to insure that a multiple array can be sent to a remote method. The |
| * server matches the received array against its expected values. |
| */ |
| public void testMethodStringMArrayIn() throws RemoteException { |
| String[][] sendArray = {{"In-0-0", "In-0-1"}, {"In-1-0", "In-1-1"}}; |
| binding.methodStringMArrayIn(sendArray); |
| } // testMethodStringMArrayIn |
| |
| /** |
| * Test to insure that a multiple array matches the expected values on both |
| * the client and server. |
| */ |
| public void testMethodStringMArrayInOut() throws RemoteException { |
| String[][] sendArray = {{"Request-0-0", "Request-0-1"}, {"Request-1-0", "Request-1-1"}}; |
| String[][] expected = {{"Response-0-0", "Response-0-1"}, {"Response-1-0", "Response-1-1"}}; |
| String[][] actual = binding.methodStringMArrayInOut(sendArray); |
| assertEquals("The expected and actual values did not match.", |
| expected[0][0], |
| actual[0][0]); |
| assertEquals("The expected and actual values did not match.", |
| expected[0][1], |
| actual[0][1]); |
| assertEquals("The expected and actual values did not match.", |
| expected[1][0], |
| actual[1][0]); |
| assertEquals("The expected and actual values did not match.", |
| expected[1][1], |
| actual[1][1]); |
| } // testMethodStringMArrayInOut |
| |
| /** |
| * Test to insure that an int array can be sent by a remote method and |
| * the received values match the expected values on the client. |
| */ |
| public void testMethodIntArrayOut() throws RemoteException { |
| int[] expected = {3, 78, 102}; |
| int[] actual = binding.methodIntArrayOut(); |
| assertEquals("The expected and actual values did not match.", |
| expected[0], |
| actual[0]); |
| assertEquals("The expected and actual values did not match.", |
| expected[1], |
| actual[1]); |
| assertEquals("The expected and actual values did not match.", |
| expected[2], |
| actual[2]); |
| } // testMethodIntArrayOut |
| |
| /** |
| * Test to insure that an int array can be sent to a remote method. The server |
| * checks the received array against its expected values. |
| */ |
| public void testMethodIntArrayIn() throws RemoteException { |
| int[] sendValue = {91, 54, 47, 10}; |
| binding.methodIntArrayIn(sendValue); |
| } // testMethodIntArrayIn |
| |
| /** |
| * Test to insure that an int array can roundtrip between the client |
| * and server. The actual and expected values are compared on both |
| * the client and server. |
| */ |
| public void testMethodIntArrayInOut() throws RemoteException { |
| int[] sendValue = {90, 34, 45, 239, 45, 10}; |
| int[] expected = {12, 39, 50, 60, 28, 39}; |
| int[] actual = binding.methodIntArrayInOut(sendValue); |
| assertEquals("The expected and actual values did not match.", |
| expected[0], |
| actual[0]); |
| assertEquals("The expected and actual values did not match.", |
| expected[1], |
| actual[1]); |
| assertEquals("The expected and actual values did not match.", |
| expected[2], |
| actual[2]); |
| assertEquals("The expected and actual values did not match.", |
| expected[3], |
| actual[3]); |
| assertEquals("The expected and actual values did not match.", |
| expected[4], |
| actual[4]); |
| assertEquals("The expected and actual values did not match.", |
| expected[5], |
| actual[5]); |
| } // testMethodIntArrayInOut |
| |
| /** |
| * Test to insure that all the XML -> Java types can be sent to a remote |
| * method. The server checks for the expected values. |
| */ |
| public void testMethodAllTypesIn() throws RemoteException { |
| byte[] sendByteArray = {(byte) 5, (byte) 10, (byte) 12}; |
| Byte[] sendWrapperByteArray = {new Byte((byte) 9), new Byte((byte) 7)}; |
| Calendar dateTime = Calendar.getInstance(); |
| TimeZone gmt = TimeZone.getTimeZone("GMT"); |
| dateTime.setTimeZone(gmt); |
| dateTime.setTime(new Date(1012937861986L)); |
| binding.methodAllTypesIn(new String("Request methodAllTypesIn"), |
| new BigInteger("545"), |
| new BigDecimal("546.545"), |
| dateTime, |
| dateTime, |
| true, |
| (byte) 2, |
| (short) 14, |
| 234, |
| 10900L, |
| 23098.23F, |
| 2098098.01D, |
| sendByteArray, |
| new Boolean(false), |
| new Byte((byte) 11), |
| new Short((short) 45), |
| new Integer(101), |
| new Long(232309L), |
| new Float(67634.12F), |
| new Double(892387.232D), |
| sendWrapperByteArray); |
| } // testMethodAllTypesIn |
| |
| /** |
| * Test to insure that a primitive byte array matches the expected values on |
| * both the client and server. |
| */ |
| public void testMethodByteArray() throws RemoteException { |
| byte[] expected = {(byte) 5, (byte) 4}; |
| byte[] sendByte = {(byte) 3, (byte) 9}; |
| byte[] actual = binding.methodByteArray(sendByte); |
| assertEquals("The expected and actual values did not match.", |
| expected[0], |
| actual[0]); |
| assertEquals("The expected and actual values did not match.", |
| expected[1], |
| actual[1]); |
| } // testMethodByteArray |
| |
| /** |
| * Test to insure that a Calendar object matches the expected values |
| * on both the client and server. |
| */ |
| public void testMethodDateTime() throws RemoteException { |
| Calendar expected = Calendar.getInstance(); |
| TimeZone gmt = TimeZone.getTimeZone("GMT"); |
| expected.setTimeZone(gmt); |
| expected.setTime(new Date(1012937861800L)); |
| Calendar parameter = Calendar.getInstance(); |
| parameter.setTimeZone(gmt); |
| parameter.setTime(new Date(1012937861996L)); |
| Calendar actual = binding.methodDateTime(parameter); |
| assertEquals("The expected and actual values did not match.", |
| expected, |
| actual); |
| } // testMethodDateTime |
| |
| /** |
| * Just do the same thing that testMethodDateTime does. The REAL |
| * test here is a compile test. Both Calendar and Date map to |
| * xsd:dateTime. The original SEI in this roundtrip test contained |
| * method: "Date methodDate(Date)". But taking that Java -> WSDL -> |
| * Java should result in: "Calendar methodDate(Calendar)". If that |
| * didn't happen, then the compile would fail. |
| */ |
| public void testMethodDate() throws RemoteException { |
| Calendar expected = Calendar.getInstance(); |
| TimeZone gmt = TimeZone.getTimeZone("GMT"); |
| expected.setTimeZone(gmt); |
| expected.setTime(new Date(1012937861800L)); |
| Calendar parameter = Calendar.getInstance(); |
| parameter.setTimeZone(gmt); |
| parameter.setTime(new Date(1012937861996L)); |
| Calendar actual = binding.methodDate(parameter); |
| assertEquals("The expected and actual values did not match.", |
| expected, |
| actual); |
| } // testMethodDate |
| |
| /** |
| * Test to insure that a BigDecimal matches the expected values on |
| * both the client and server. |
| */ |
| public void testMethodBigDecimal() throws RemoteException { |
| BigDecimal expected = new BigDecimal("903483.304"); |
| BigDecimal actual = binding.methodBigDecimal(new BigDecimal("3434.456")); |
| assertEquals("The expected and actual values did not match.", |
| expected, |
| actual); |
| } // testMethodBigDecimal |
| |
| /** |
| * Test to insure that a BigInteger matches the expected values on |
| * both the client and server. |
| */ |
| public void testMethodBigInteger() throws RemoteException { |
| BigInteger expected = new BigInteger("2323"); |
| BigInteger actual = binding.methodBigInteger(new BigInteger("8789")); |
| assertEquals("The expected and actual values did not match.", |
| expected, |
| actual); |
| } // testMethodBigInteger |
| |
| /** |
| * Test to insure that a String matches the expected values on |
| * both the client and server. |
| */ |
| public void testMethodString() throws RemoteException { |
| String expected = "Response"; |
| String actual = binding.methodString(new String("Request")); |
| assertEquals("The expected and actual values did not match.", |
| expected, |
| actual); |
| } // testMethodString |
| |
| /** |
| * Test to insure that a primitive double matches the expected |
| * values on both the client and server. |
| */ |
| public void testMethodDouble() throws RemoteException { |
| double expected = 567.547D; |
| double actual = binding.methodDouble(87502.002D); |
| assertEquals("The expected and actual values did not match.", |
| expected, |
| actual, |
| DOUBLE_DELTA); |
| } // testMethodDouble |
| |
| /** |
| * Test to insure that a primitive float matches the expected |
| * values on both the client and server. |
| */ |
| public void testMethodFloat() throws RemoteException { |
| float expected = 12325.545F; |
| float actual = binding.methodFloat(8787.25F); |
| assertEquals("The expected and actual values did not match.", |
| expected, |
| actual, |
| FLOAT_DELTA); |
| } // testMethodFloat |
| |
| /** |
| * Test to insure that a primitive long matches the expected |
| * values on both the client and server. |
| */ |
| public void testMethodLong() throws RemoteException { |
| long expected = 787985L; |
| long actual = binding.methodLong(45425L); |
| assertEquals("The expected and actual values did not match.", |
| expected, |
| actual); |
| } // testMethodLong |
| |
| /** |
| * Test to insure that a primitive int matches the expected |
| * values on both the client and server. |
| */ |
| public void testMethodInt() throws RemoteException { |
| int expected = 10232; |
| int actual = binding.methodInt(1215); |
| assertEquals("The expected and actual values did not match.", |
| expected, |
| actual); |
| } // testMethodInt |
| |
| /** |
| * Test to insure that a primitive short matches the expected |
| * values on both the client and server. |
| */ |
| public void testMethodShort() throws RemoteException { |
| short expected = (short) 124; |
| short actual = binding.methodShort((short) 302); |
| assertEquals("The expected and actual values did not match.", |
| expected, |
| actual); |
| } // testMethodShort |
| |
| /** |
| * Test to insure that a primitive byte matches the expected |
| * values on both the client and server. |
| */ |
| public void testMethodByte() throws RemoteException { |
| byte expected = (byte) 35; |
| byte actual = binding.methodByte((byte) 61); |
| assertEquals("The expected and actual values did not match.", |
| expected, |
| actual); |
| } // testMethodByte |
| |
| /** |
| * Test to insure that a primitive boolean matches the expected |
| * values on both the client and server. |
| */ |
| public void testMethodBoolean() throws RemoteException { |
| boolean expected = false; |
| boolean actual = binding.methodBoolean(true); |
| assertEquals("The expected and actual values did not match.", |
| expected, |
| actual); |
| } // testMethodBoolean |
| |
| |
| /** |
| * Test to insure that an array of a user defined class matches |
| * the expected values on both the client and server. |
| */ |
| public void testMethodCallOptions() throws RemoteException { |
| CallOptions[] callOptions = new CallOptions[1]; |
| callOptions[0] = new CallOptions(); |
| Calendar cal = Calendar.getInstance(); |
| TimeZone gmt = TimeZone.getTimeZone("GMT"); |
| cal.setTimeZone(gmt); |
| cal.setTime(new Date(1013459984577L)); |
| callOptions[0].setCallDate(cal); |
| |
| CallOptions[] actual = binding.methodCallOptions(callOptions); |
| cal.setTime(new Date(1013459984507L)); |
| assertEquals("The expected and actual values did not match.", |
| cal, |
| actual[0].getCallDate()); |
| } // testMethodCallOptions |
| |
| /** |
| * Test to insure that a wrapper Float object matches |
| * the expected values on both the client and server. |
| */ |
| public void testMethodSoapFloat() throws RemoteException { |
| Float actual = binding.methodSoapFloat(new Float(23423.234F)); |
| assertEquals("The expected and actual values did not match.", |
| new Float(232.23F), |
| actual); |
| } // testMethodSoapFloat |
| |
| /** |
| * Test to insure that a wrapper Double object matches |
| * the expected values on both the client and server. |
| */ |
| public void testMethodSoapDouble() throws RemoteException { |
| Double actual = binding.methodSoapDouble(new Double(123423.234D)); |
| assertEquals("The expected and actual values did not match.", |
| new Double(2232.23D), |
| actual); |
| } // testMethodSoapDouble |
| |
| /** |
| * Test to insure that a wrapper Boolean object matches |
| * the expected values on both the client and server. |
| */ |
| public void testMethodSoapBoolean() throws RemoteException { |
| Boolean actual = binding.methodSoapBoolean(new Boolean(true)); |
| assertEquals("The expected and actual values did not match.", |
| new Boolean(false), |
| actual); |
| } // testMethodSoapBoolean |
| |
| /** |
| * Test to insure that a wrapper Byte object matches |
| * the expected values on both the client and server. |
| */ |
| public void testMethodSoapByte() throws RemoteException { |
| Byte actual = binding.methodSoapByte(new Byte((byte) 9)); |
| assertEquals("The expected and actual values did not match.", |
| new Byte((byte) 10), |
| actual); |
| } // testMethodSoapByte |
| |
| /** |
| * Test to insure that a wrapper Short object matches |
| * the expected values on both the client and server. |
| */ |
| public void testMethodSoapShort() throws RemoteException { |
| Short actual = binding.methodSoapShort(new Short((short) 32)); |
| assertEquals("The expected and actual values did not match.", |
| new Short((short) 44), |
| actual); |
| } // testMethodSoapShort |
| |
| /** |
| * Test to insure that a wrapper Integer object matches |
| * the expected values on both the client and server. |
| */ |
| public void testMethodSoapInt() throws RemoteException { |
| Integer actual = binding.methodSoapInt(new Integer(332)); |
| assertEquals("The expected and actual values did not match.", |
| new Integer(441), |
| actual); |
| } // testMethodSoapInt |
| |
| /** |
| * Test to insure that a wrapper Long object matches |
| * the expected values on both the client and server. |
| */ |
| public void testMethodSoapLong() throws RemoteException { |
| Long actual = binding.methodSoapLong(new Long(3321L)); |
| assertEquals("The expected and actual values did not match.", |
| new Long(4412L), |
| actual); |
| } // testMethodSoapLong |
| |
| /** |
| * Test to insure that a user defined exception can be |
| * thrown and received. |
| */ |
| public void testInvalidTickerSymbol() throws RemoteException { |
| try { |
| binding.throwInvalidTickerException(); |
| fail("Should have received an InvalidTickerSymbol exception."); |
| } catch (InvalidTickerSymbol its) { |
| // Test was successful |
| assertEquals("The expected and actual values did not match.", |
| "ABC", |
| its.getTickerSymbol()); |
| } |
| } // testInvalidTickerSymbol |
| |
| /** |
| * Test to insure that more than one user defined exception can be |
| * defined in a method. |
| */ |
| public void testInvalidTradeExchange() throws RemoteException { |
| try { |
| binding.throwInvalidTradeExchange(); |
| fail("TRY: Should have received an InvalidTradeExchange exception."); |
| } catch (InvalidTradeExchange ite) { |
| // Test was successful |
| assertEquals("The expected and actual values did not match.", |
| "XYZ", |
| ite.getTradeExchange()); |
| } catch (InvalidTickerSymbol its) { |
| fail("ITS: Should have received an InvalidTradeExchange exception."); |
| } catch (InvalidCompanyId ici) { |
| fail("ICI: Should have received an InvalidTradeExchange exception."); |
| } |
| } // testInvalidTradeExchange |
| |
| /** |
| * Make sure holder inout parameters can be round tripped. |
| */ |
| public void testHolderTest() throws RemoteException { |
| StringHolder sh = new StringHolder("hi there"); |
| BondInvestment bi = new BondInvestment(); |
| BondInvestmentHolder bih = new BondInvestmentHolder(bi); |
| binding.holderTest(sh, bih); |
| } // testHolderTest |
| |
| } // End class RoundtripTestServiceTestCase |
