| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| package org.apache.axis2.engine; |
| |
| import junit.framework.TestCase; |
| import org.apache.axiom.om.OMAbstractFactory; |
| import org.apache.axiom.om.util.UUIDGenerator; |
| import org.apache.axiom.soap.SOAPFactory; |
| import org.apache.axis2.AxisFault; |
| import org.apache.axis2.addressing.EndpointReference; |
| import org.apache.axis2.context.ConfigurationContext; |
| import org.apache.axis2.context.MessageContext; |
| import org.apache.axis2.context.OperationContext; |
| import org.apache.axis2.context.SelfManagedDataManager; |
| import org.apache.axis2.context.ServiceContext; |
| import org.apache.axis2.context.ServiceGroupContext; |
| import org.apache.axis2.description.AxisOperation; |
| import org.apache.axis2.description.AxisService; |
| import org.apache.axis2.description.AxisServiceGroup; |
| import org.apache.axis2.description.InOutAxisOperation; |
| import org.apache.axis2.description.TransportInDescription; |
| import org.apache.axis2.description.TransportOutDescription; |
| import org.apache.axis2.dispatchers.AddressingBasedDispatcher; |
| import org.apache.axis2.dispatchers.RequestURIBasedDispatcher; |
| import org.apache.axis2.dispatchers.SOAPActionBasedDispatcher; |
| import org.apache.axis2.dispatchers.SOAPMessageBodyBasedDispatcher; |
| import org.apache.axis2.handlers.AbstractHandler; |
| import org.apache.axis2.receivers.RawXMLINOnlyMessageReceiver; |
| import org.apache.axis2.receivers.RawXMLINOutMessageReceiver; |
| import org.apache.axis2.transport.http.CommonsHTTPTransportSender; |
| import org.apache.axis2.transport.http.SimpleHTTPServer; |
| import org.apache.commons.logging.Log; |
| import org.apache.commons.logging.LogFactory; |
| |
| import javax.xml.namespace.QName; |
| import java.io.ByteArrayInputStream; |
| import java.io.ByteArrayOutputStream; |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.FileOutputStream; |
| import java.io.IOException; |
| import java.io.ObjectInputStream; |
| import java.io.ObjectOutputStream; |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| public class MessageContextSelfManagedDataTest extends TestCase { |
| protected static final Log log = LogFactory.getLog(MessageContextSelfManagedDataTest.class); |
| |
| private File theFile = null; |
| boolean savedMessageContext = false; |
| boolean restoredMessageContext = false; |
| |
| private String serviceGroupName = new String("NullServiceGroup"); |
| private QName serviceName = new QName("NullService"); |
| private QName operationName = new QName("DummyOp"); |
| |
| private ConfigurationContext cfgContext = null; |
| private ServiceGroupContext serviceGroupContext = null; |
| private ServiceContext serviceContext = null; |
| private OperationContext operationContext = null; |
| |
| private AxisConfiguration axisConfiguration = null; |
| private AxisServiceGroup axisServiceGroup = null; |
| private AxisService axisService = null; |
| private AxisOperation axisOperation = null; |
| |
| private TransportOutDescription transportOut = null; |
| private TransportOutDescription transportOut2 = null; |
| private TransportOutDescription transportOut3 = null; |
| private TransportInDescription transportIn = null; |
| private TransportInDescription transportIn2 = null; |
| private TransportInDescription transportIn3 = null; |
| |
| private MessageContext mc = null; |
| |
| private TempHandler01 handler01; |
| private TempHandler02 handler02; |
| private TempHandler02 subhandler; // this handler is intended to be a few levels down in executionChain |
| private TempHandler03 handler03; |
| private TempHandler04 handler04; |
| private Phase phase1; |
| private Phase phase2; |
| private Phase phase3; |
| private Phase subPhase; |
| |
| // use this to count how many times methods get called for a particular test |
| private int invokecallcount = 0; |
| |
| // key-value pairs to be used for self managed data |
| |
| private String key01 = "key01"; |
| private String testData01 = "TempHandler01_01"; |
| |
| private String key02 = "key02"; |
| private String testData02 = "TempHandler01_02"; |
| |
| private String key03 = "key03"; |
| private byte [] testData03 = {0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x01, |
| 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F}; |
| |
| private String key04 = "key04"; |
| private long [] testData04 = {0L, 1L, -6601664200673063531L, -7753637088257391858L}; |
| |
| private String key05 = "key05"; |
| private int testData05 = 123456; |
| |
| |
| public MessageContextSelfManagedDataTest(String arg0) { |
| super(arg0); |
| initAll(); |
| } |
| |
| |
| protected void initAll() { |
| try { |
| prepare(); |
| } |
| catch (Exception e) { |
| log.debug( |
| "MessageContextSelfManagedDataTest:initAll: error in setting up object graph [" + |
| e.getClass().getName() + " : " + e.getMessage() + "]"); |
| } |
| |
| if (handler01 == null) { |
| handler01 = new TempHandler01(101); |
| } |
| |
| if (handler02 == null) { |
| handler02 = new TempHandler02(102); |
| } |
| |
| if (handler03 == null) { |
| handler03 = new TempHandler03(103); |
| } |
| |
| if (handler04 == null) { |
| handler04 = new TempHandler04(104); |
| } |
| |
| if (subhandler == null) { |
| subhandler = new TempHandler02(1000); |
| } |
| |
| } |
| |
| |
| // |
| // prepare the object hierarchy for testing |
| // |
| private void prepare() throws Exception { |
| //----------------------------------------------------------------- |
| |
| axisConfiguration = new AxisConfiguration(); |
| |
| cfgContext = new ConfigurationContext(axisConfiguration); |
| |
| cfgContext.getAxisConfiguration().addMessageReceiver( |
| "http://www.w3.org/2004/08/wsdl/in-only", new RawXMLINOnlyMessageReceiver()); |
| cfgContext.getAxisConfiguration().addMessageReceiver( |
| "http://www.w3.org/2004/08/wsdl/in-out", new RawXMLINOutMessageReceiver()); |
| |
| DispatchPhase dispatchPhase = new DispatchPhase(); |
| dispatchPhase.setName("Dispatch"); |
| |
| AddressingBasedDispatcher abd = new AddressingBasedDispatcher(); |
| abd.initDispatcher(); |
| |
| RequestURIBasedDispatcher rud = new RequestURIBasedDispatcher(); |
| rud.initDispatcher(); |
| |
| SOAPActionBasedDispatcher sabd = new SOAPActionBasedDispatcher(); |
| sabd.initDispatcher(); |
| |
| SOAPMessageBodyBasedDispatcher smbd = new SOAPMessageBodyBasedDispatcher(); |
| smbd.initDispatcher(); |
| |
| dispatchPhase.addHandler(abd); |
| dispatchPhase.addHandler(rud); |
| dispatchPhase.addHandler(sabd); |
| dispatchPhase.addHandler(smbd); |
| |
| cfgContext.getAxisConfiguration().getInFlowPhases().add(dispatchPhase); |
| |
| //----------------------------------------------------------------- |
| |
| axisServiceGroup = new AxisServiceGroup(axisConfiguration); |
| axisServiceGroup.setServiceGroupName("ServiceGroupTest"); |
| |
| |
| axisService = new AxisService(serviceName.getLocalPart()); |
| axisServiceGroup.addService(axisService); |
| |
| |
| axisOperation = new InOutAxisOperation(operationName); |
| axisOperation.setMessageReceiver(new MessageReceiver() { |
| public void receive(MessageContext messageCtx) { |
| |
| } |
| }); |
| |
| axisService.addOperation(axisOperation); |
| axisService.mapActionToOperation(operationName.getLocalPart(), axisOperation); |
| |
| |
| cfgContext.getAxisConfiguration().addService(axisService); |
| |
| //----------------------------------------------------------------- |
| |
| serviceGroupContext = |
| cfgContext.createServiceGroupContext(axisService.getAxisServiceGroup()); |
| serviceGroupContext.setId("ServiceGroupContextTest"); |
| |
| serviceContext = serviceGroupContext.getServiceContext(axisService); |
| |
| operationContext = serviceContext.createOperationContext(operationName); |
| |
| //----------------------------------------------------------------- |
| |
| transportOut = new TransportOutDescription("null"); |
| transportOut2 = new TransportOutDescription("happy"); |
| transportOut3 = new TransportOutDescription("golucky"); |
| transportOut.setSender(new CommonsHTTPTransportSender()); |
| transportOut2.setSender(new CommonsHTTPTransportSender()); |
| transportOut3.setSender(new CommonsHTTPTransportSender()); |
| axisConfiguration.addTransportOut(transportOut3); |
| axisConfiguration.addTransportOut(transportOut2); |
| axisConfiguration.addTransportOut(transportOut); |
| |
| transportIn = new TransportInDescription("null"); |
| transportIn2 = new TransportInDescription("always"); |
| transportIn3 = new TransportInDescription("thebest"); |
| transportIn.setReceiver(new SimpleHTTPServer()); |
| transportIn2.setReceiver(new SimpleHTTPServer()); |
| transportIn3.setReceiver(new SimpleHTTPServer()); |
| axisConfiguration.addTransportIn(transportIn2); |
| axisConfiguration.addTransportIn(transportIn); |
| axisConfiguration.addTransportIn(transportIn3); |
| |
| } |
| |
| |
| /* |
| * (non-Javadoc) |
| * @see junit.framework.TestCase#setUp() |
| * |
| * setUp gets called before each test* method. In this class, a new |
| * MessageContext object is created for each test* method. The test* |
| * methods are responsible for adding whichever handler they may need |
| * in order to run the desired test. See the handler class comments |
| * for their respective functions. |
| */ |
| protected void setUp() throws Exception { |
| //org.apache.log4j.BasicConfigurator.configure(); |
| |
| invokecallcount = 0; |
| |
| mc = cfgContext.createMessageContext(); |
| mc.setTransportIn(transportIn); |
| mc.setTransportOut(transportOut); |
| |
| mc.setServerSide(true); |
| mc.setProperty(MessageContext.TRANSPORT_OUT, System.out); |
| |
| SOAPFactory omFac = OMAbstractFactory.getSOAP11Factory(); |
| mc.setEnvelope(omFac.getDefaultEnvelope()); |
| |
| phase1 = new Phase("1"); |
| phase1.addHandler(new TempHandler02(0)); |
| phase1.addHandler(new TempHandler02(1)); |
| |
| phase2 = new Phase("2"); |
| phase2.addHandler(new TempHandler02(2)); |
| phase2.addHandler(handler02); |
| phase2.addHandler(new TempHandler02(3)); |
| |
| phase3 = new Phase("3"); |
| phase3.addHandler(new TempHandler02(4)); |
| phase3.addHandler(subhandler); |
| phase3.addHandler(handler02); // same instance, second insertion |
| phase3.addHandler(new TempHandler02(5)); |
| |
| /* |
| * TODO: WARNING WARNING WARNING |
| * Ideally inserting subPhase here would make the axis2 engine call |
| * the invoke of nested subhandler. It does not do this. Please see the |
| * warning at bottom of testPause06 method. |
| */ |
| subPhase = new Phase("sub"); |
| subPhase.addHandler(subhandler); |
| phase3.addHandler(subPhase); |
| phase3.addHandler(new TempHandler02(6)); |
| phase3.addHandler(new TempHandler02(7)); |
| |
| axisOperation.getRemainingPhasesInFlow().add(phase1); |
| axisOperation.getRemainingPhasesInFlow().add(phase2); |
| axisOperation.getRemainingPhasesInFlow().add(phase3); |
| |
| |
| mc.setMessageID(UUIDGenerator.getUUID()); |
| |
| //operationContext.addMessageContext(mc); gets done via the register |
| axisOperation.registerOperationContext(mc, operationContext); |
| mc.setOperationContext(operationContext); |
| mc.setServiceContext(serviceContext); |
| |
| mc.setTo(new EndpointReference("axis2/services/NullService")); |
| |
| mc.setWSAAction(operationName.getLocalPart()); |
| mc.setSoapAction(operationName.getLocalPart()); |
| |
| } |
| |
| //------------------------------------------------------------------------- |
| // test cases |
| //------------------------------------------------------------------------- |
| |
| |
| /** |
| * Test case for setting and removing data from a message context |
| */ |
| public void testSelfManagedData01() { |
| log.debug( |
| "MessageContextSelfManagedDataTest::testSelfManagedData01()======================================="); |
| try { |
| ArrayList handlers = new ArrayList(); |
| handlers.add(handler01); |
| cfgContext.getAxisConfiguration().setInPhasesUptoAndIncludingPostDispatch(handlers); |
| |
| mc.setTo(new EndpointReference("axis2/services/NullService")); |
| mc.setWSAAction("DummyOp"); |
| |
| AxisEngine.receive(mc); |
| |
| } |
| catch (Exception e) { |
| e.printStackTrace(); |
| } |
| |
| assertEquals(testData01, handler01.getTestData01FromMessageContext(mc)); |
| assertEquals(testData02, handler01.getTestData02FromMessageContext(mc)); |
| |
| boolean isOk3 = isEquals(testData03, handler01.getTestData03FromMessageContext(mc)); |
| assertTrue(isOk3); |
| |
| boolean isOk4 = isEquals(testData04, handler01.getTestData04FromMessageContext(mc)); |
| assertTrue(isOk4); |
| |
| assertEquals(1, invokecallcount); |
| } |
| |
| |
| /** |
| * Test for setting, saving, restoring self managed data with no exceptions |
| */ |
| public void testPause01_noExceptions() { |
| log.debug( |
| "MessageContextSelfManagedDataTest::testPause01_noExceptions()======================================="); |
| |
| try { |
| ArrayList handlers = new ArrayList(); |
| handlers.add(handler02); |
| cfgContext.getAxisConfiguration().setInPhasesUptoAndIncludingPostDispatch(handlers); |
| |
| mc.setTo(new EndpointReference("axis2/services/NullService")); |
| mc.setWSAAction("DummyOp"); |
| |
| AxisEngine.receive(mc); |
| } |
| catch (Exception e) { |
| e.printStackTrace(); |
| } |
| |
| // if we didn't get any exceptions during save/restore, these will be true |
| assertTrue(savedMessageContext); |
| assertTrue(restoredMessageContext); |
| assertEquals(1, invokecallcount); |
| } |
| |
| |
| /** |
| * Test for verifying the self managed data used during the save and restore |
| */ |
| public void testPause02_saveRestoreSelfManagedData() { |
| log.debug( |
| "MessageContextSelfManagedDataTest::testPause02_saveRestoreSelfManagedData()======================================="); |
| |
| try { |
| ArrayList handlers = new ArrayList(); |
| handlers.add(handler02); |
| cfgContext.getAxisConfiguration().setInPhasesUptoAndIncludingPostDispatch(handlers); |
| |
| mc.setTo(new EndpointReference("axis2/services/NullService")); |
| mc.setWSAAction("DummyOp"); |
| |
| AxisEngine.receive(mc); |
| } |
| catch (Exception e) { |
| e.printStackTrace(); |
| } |
| |
| // make sure the data in our handler got restored |
| assertEquals(handler02.testData, handler02.getTestDataFromMessageContext(mc)); |
| assertEquals(1, invokecallcount); |
| } |
| |
| /** |
| * Test for save and restore of self managed data and the AxisOperation |
| */ |
| public void testPause03_saveRestoreOperation() { |
| log.debug( |
| "MessageContextSelfManagedDataTest::testPause03_saveRestoreOperation()======================================="); |
| |
| try { |
| ArrayList handlers = new ArrayList(); |
| handlers.add(handler02); |
| cfgContext.getAxisConfiguration().setInPhasesUptoAndIncludingPostDispatch(handlers); |
| |
| mc.setTo(new EndpointReference("axis2/services/NullService")); |
| mc.setWSAAction("DummyOp"); |
| |
| AxisEngine.receive(mc); |
| } |
| catch (Exception e) { |
| e.printStackTrace(); |
| } |
| |
| // make sure the operation got restored in the MessageContext object |
| assertEquals(operationName.toString(), mc.getAxisOperation().getName().toString()); |
| assertEquals(1, invokecallcount); |
| |
| } |
| |
| |
| /** |
| * Test for save and restore of self managed data and the AxisService |
| */ |
| public void testPause04_saveRestoreAxisService() { |
| log.debug( |
| "MessageContextSelfManagedDataTest::testPause04_saveRestoreAxisService()======================================="); |
| |
| try { |
| ArrayList handlers = new ArrayList(); |
| handlers.add(handler02); |
| cfgContext.getAxisConfiguration().setInPhasesUptoAndIncludingPostDispatch(handlers); |
| |
| mc.setTo(new EndpointReference("axis2/services/NullService")); |
| mc.setWSAAction("DummyOp"); |
| |
| AxisEngine.receive(mc); |
| } |
| catch (Exception e) { |
| e.printStackTrace(); |
| } |
| |
| // make sure the service got restored in the MessageContext object |
| assertEquals(serviceName.toString(), mc.getAxisService().getName().toString()); |
| assertEquals(1, invokecallcount); |
| } |
| |
| |
| /** |
| * Test for save and restore of self managed data and the AxisServiceGroup |
| */ |
| public void testPause05_saveRestoreAxisServiceGroup() { |
| log.debug( |
| "MessageContextSelfManagedDataTest::testPause05_saveRestoreAxisServiceGroup()======================================="); |
| |
| try { |
| ArrayList handlers = new ArrayList(); |
| handlers.add(handler02); |
| cfgContext.getAxisConfiguration().setInPhasesUptoAndIncludingPostDispatch(handlers); |
| |
| mc.setTo(new EndpointReference("axis2/services/NullService")); |
| mc.setWSAAction("DummyOp"); |
| |
| AxisEngine.receive(mc); |
| |
| } |
| catch (Exception e) { |
| e.printStackTrace(); |
| } |
| |
| // make sure the serviceGroup got restored in the MessageContext object |
| //assertEquals(serviceGroupName.toString(), mc.getAxisServiceGroup().getServiceGroupName()); |
| assertEquals(1, invokecallcount); |
| } |
| |
| |
| /** |
| * Test for phases |
| */ |
| public void testPause06_saveRestorePhases() { |
| log.debug( |
| "MessageContextSelfManagedDataTest::testPause06_saveRestorePhases()======================================="); |
| |
| TempHandler02 handlerA = new TempHandler02(666); |
| |
| Phase phase601 = new Phase("01"); |
| phase601.addHandler(new TempHandler02(61)); // slot 1 |
| phase601.addHandler(new TempHandler03(62)); // slot 2 |
| |
| Phase phase602 = new Phase("02"); |
| phase602.addHandler(new TempHandler02(63)); // slot 3 |
| phase602.addHandler(handlerA); // slot 4 |
| phase602.addHandler(new TempHandler03(64)); // slot 5 |
| |
| Phase phase603 = new Phase("03"); |
| phase603.addHandler(new TempHandler02(65)); // slot 6 |
| phase603.addHandler(subhandler); // slot 7 |
| phase603.addHandler(handlerA); // slot 8 - same instance, second insertion |
| phase603.addHandler(new TempHandler03(66)); // slot 9 |
| |
| /* |
| * TODO: WARNING WARNING WARNING |
| * Ideally inserting subPhase here would make the axis2 engine call |
| * the invoke of nested subhandler. It does not do this. |
| * Please see the warning later in this method. |
| */ |
| Phase subPhase601 = new Phase("sub6"); |
| subPhase601.addHandler(subhandler); |
| phase603.addHandler(subPhase601); // slot 10 |
| phase603.addHandler(new TempHandler02(67)); // slot 11 |
| phase603.addHandler(new TempHandler03(68)); // slot 12 |
| |
| try { |
| ArrayList phases = new ArrayList(); |
| phases.add(phase601); |
| phases.add(phase602); |
| phases.add(phase603); |
| |
| cfgContext.getAxisConfiguration().setInPhasesUptoAndIncludingPostDispatch(phases); |
| |
| mc.setTo(new EndpointReference("axis2/services/NullService")); |
| mc.setWSAAction("DummyOp"); |
| |
| AxisEngine.receive(mc); |
| } |
| catch (Exception e) { |
| e.printStackTrace(); |
| } |
| |
| // get the phase lists and see if they match up |
| ArrayList restoredPhases = mc.getExecutionChain(); |
| int it_count = 0; |
| |
| Iterator it = restoredPhases.iterator(); |
| while (it.hasNext()) { |
| // we know everything at this level is a Phase. |
| // if you change it, you might get a ClassCastException |
| Phase restored_phase = (Phase) it.next(); |
| |
| Phase original_phase = null; |
| |
| it_count++; |
| |
| if (it_count == 1) { |
| original_phase = phase601; |
| } else if (it_count == 2) { |
| original_phase = phase602; |
| } else if (it_count == 3) { |
| original_phase = phase603; |
| } |
| |
| //comparePhases(restored_phase.getHandlers().iterator(), original_phase.getHandlers()); |
| |
| boolean isOk = comparePhases(restored_phase, original_phase); |
| assertTrue(isOk); |
| } |
| |
| // TODO WARNING WARNING WARNING |
| // The axis2 engine is not calling the invoke on nested handlers! |
| // The way this testcase works is that the handler's invoke() method is |
| // what sets the data. So, any handlers that are in subPhase will |
| // not get called, and thus will not set or restore any data. |
| // Notice we do currently have a subhandler in the subPhase object. |
| // When axis2 decides to support nested handlers, the |
| // first three assertEquals below will fail. |
| log.debug( |
| "MessageContextSelfManagedDataTest::testPause06_saveRestorePhases():: invokecallcount [" + |
| invokecallcount + "]"); |
| assertEquals(11, invokecallcount); |
| |
| // even though there are two occurrances of the same instance of |
| // handlerA in the executionChain, its serialize and deserialize |
| // should only be called once per unique instance in the list |
| int count_s = handlerA.getSerializecallcount(); |
| log.debug( |
| "MessageContextSelfManagedDataTest::testPause06_saveRestorePhases():: handlerA serialize call count [" + |
| count_s + "]"); |
| assertEquals(11, count_s); |
| |
| // here comes some fun math... |
| // Since a handler (TempHandler02) in this case |
| // doesn't add any data until its invoke method gets called, |
| // and the invoke is what causes the save/restore (and thus |
| // the serialize/deserialize) there is no data for handlerA |
| // to deserialize until the first occurance of handlerA |
| // invoke is called in the executionChain. Observing our phases, |
| // we see it is in slot #3. 11 - 3 = 8 |
| int count_d = handlerA.getDeserializecallcount(); |
| log.debug( |
| "MessageContextSelfManagedDataTest::testPause06_saveRestorePhases():: handlerA deserialize call count [" + |
| count_d + "]"); |
| assertEquals(8, count_d); |
| assertEquals(subhandler.testData, subhandler.getTestDataFromMessageContext(mc)); |
| |
| } |
| |
| |
| /** |
| * Test for save and restore of binary self managed data |
| */ |
| public void testSelfManagedData07() { |
| log.debug( |
| "MessageContextSelfManagedDataTest::testSelfManagedData07()======================================="); |
| try { |
| ArrayList handlers = new ArrayList(); |
| handlers.add(handler03); |
| cfgContext.getAxisConfiguration().setInPhasesUptoAndIncludingPostDispatch(handlers); |
| |
| mc.setTo(new EndpointReference("axis2/services/NullService")); |
| mc.setWSAAction("DummyOp"); |
| |
| AxisEngine.receive(mc); |
| } |
| catch (Exception e) { |
| e.printStackTrace(); |
| } |
| |
| boolean isOk3 = isEquals(testData03, (byte []) handler03.getTestDataFromMessageContext(mc)); |
| assertTrue(isOk3); |
| |
| assertEquals(1, invokecallcount); |
| } |
| |
| |
| /** |
| * Test for handler04 |
| */ |
| public void testSelfManagedData08() { |
| log.debug( |
| "MessageContextSelfManagedDataTest::testSelfManagedData08()======================================="); |
| try { |
| |
| ArrayList handlers = new ArrayList(); |
| handlers.add(handler04); |
| cfgContext.getAxisConfiguration().setInPhasesUptoAndIncludingPostDispatch(handlers); |
| |
| mc.setTo(new EndpointReference("axis2/services/NullService")); |
| mc.setWSAAction("DummyOp"); |
| |
| AxisEngine.receive(mc); |
| |
| } |
| catch (Exception e) { |
| e.printStackTrace(); |
| } |
| |
| boolean isOk4 = isEquals(testData04, (long []) handler04.getTestDataFromMessageContext(mc)); |
| assertTrue(isOk4); |
| |
| assertEquals(1, invokecallcount); |
| } |
| |
| |
| /** |
| * Test for handler03 and handler04 |
| */ |
| public void testSelfManagedData09() { |
| log.debug( |
| "MessageContextSelfManagedDataTest::testSelfManagedData09()======================================="); |
| try { |
| |
| ArrayList handlers = new ArrayList(); |
| handlers.add(handler03); |
| handlers.add(handler04); |
| cfgContext.getAxisConfiguration().setInPhasesUptoAndIncludingPostDispatch(handlers); |
| |
| mc.setTo(new EndpointReference("axis2/services/NullService")); |
| mc.setWSAAction("DummyOp"); |
| |
| AxisEngine.receive(mc); |
| |
| } |
| catch (Exception e) { |
| e.printStackTrace(); |
| } |
| |
| boolean isOk3 = isEquals(testData03, (byte []) handler03.getTestDataFromMessageContext(mc)); |
| assertTrue(isOk3); |
| |
| boolean isOk4 = isEquals(testData04, (long []) handler04.getTestDataFromMessageContext(mc)); |
| assertTrue(isOk4); |
| |
| assertEquals(2, invokecallcount); |
| } |
| |
| //------------------------------------------------------------------------- |
| // internal helper methods |
| //------------------------------------------------------------------------- |
| |
| /** |
| * Saves the specified message context to a temporary |
| * file, then restores it. |
| * |
| * @param mc1 The message context object to save |
| * @param fnprefix A prefix for the filename of the temporary file |
| * @param desc Text that describes the caller's situation |
| * @return The restored message context object or NULL |
| */ |
| private MessageContext saveAndRestore(MessageContext mc1, String fnprefix, String desc) { |
| MessageContext msgContext2 = null; |
| String title = "MessageContextSelfManagedDataTest::saveAndRestore::[" + desc + "] "; |
| log.debug(title); |
| |
| try { |
| theFile = File.createTempFile(fnprefix, null); |
| log.debug(title + "temp file = [" + theFile.getName() + "]"); |
| } |
| catch (Exception ex) { |
| log.debug(title + "error creating temp file = [" + ex.getMessage() + "]"); |
| theFile = null; |
| } |
| |
| if (theFile != null) { |
| try { |
| // setup an output stream to a physical file |
| FileOutputStream outStream = new FileOutputStream(theFile); |
| |
| // attach a stream capable of writing objects to the |
| // stream connected to the file |
| ObjectOutputStream outObjStream = new ObjectOutputStream(outStream); |
| |
| // try to save the message context |
| log.debug(title + "saving message context ...."); |
| savedMessageContext = false; |
| |
| outObjStream.writeObject(mc1); |
| outObjStream.close(); |
| outStream.close(); |
| |
| // no exceptions, set savedMessageContext to true |
| savedMessageContext = true; |
| |
| log.debug(title + "....saved message context ....."); |
| |
| // setup an input stream to the file |
| FileInputStream inStream = new FileInputStream(theFile); |
| |
| // attach a stream capable of reading objects from the |
| // stream connected to the file |
| ObjectInputStream inObjStream = new ObjectInputStream(inStream); |
| |
| // try to restore the message context |
| log.debug(title + "restoring message context ....."); |
| restoredMessageContext = false; |
| msgContext2 = (MessageContext) inObjStream.readObject(); |
| inObjStream.close(); |
| inStream.close(); |
| msgContext2.activate(mc1.getConfigurationContext()); |
| |
| // no exceptions, set restoredMessageContext to true |
| restoredMessageContext = true; |
| |
| // VERY IMPORTANT: replace testcase's messagecontext object with the new restored one |
| mc = msgContext2; |
| |
| log.debug(title + "....restored message context ....."); |
| |
| } |
| catch (Exception ex2) { |
| if (savedMessageContext != true) { |
| log.debug(title + "Error with saving message context = [" + |
| ex2.getClass().getName() + " : " + ex2.getMessage() + "]"); |
| ex2.printStackTrace(); |
| } else { |
| log.debug(title + "Error with restoring message context = [" + |
| ex2.getClass().getName() + " : " + ex2.getMessage() + "]"); |
| ex2.printStackTrace(); |
| } |
| } |
| |
| // if the save/restore of the message context succeeded, |
| // then don't keep the temporary file around |
| boolean removeTmpFile = savedMessageContext && restoredMessageContext; |
| if (removeTmpFile) { |
| try { |
| theFile.delete(); |
| } |
| catch (Exception e) { |
| // just absorb it |
| } |
| } |
| } |
| |
| return msgContext2; |
| } |
| |
| |
| /** |
| * Gets the ID associated with the handler object. |
| * |
| * @param o The handler object |
| * @return The ID associated with the handler, |
| * -1 otherwise |
| */ |
| private int getHandlerID(Object o) { |
| int id = -1; |
| |
| if (o instanceof TempHandler01) { |
| id = ((TempHandler01) o).getID(); |
| } else if (o instanceof TempHandler02) { |
| id = ((TempHandler02) o).getID(); |
| } else if (o instanceof TempHandler03) { |
| id = ((TempHandler03) o).getID(); |
| } else if (o instanceof TempHandler04) { |
| id = ((TempHandler04) o).getID(); |
| } |
| |
| return id; |
| } |
| |
| |
| /** |
| * Check the handler objects to see if they are equivalent. |
| * |
| * @param o1 The first handler |
| * @param o2 The second handler |
| * @return TRUE if the handler objects are equivalent, |
| * FALSE otherwise |
| */ |
| private boolean compareHandlers(Object o1, Object o2) { |
| if ((o1 == null) && (o2 == null)) { |
| return true; |
| } |
| |
| if ((o1 != null) && (o2 != null)) { |
| String c1 = o1.getClass().getName(); |
| String c2 = o2.getClass().getName(); |
| |
| if (c1.equals(c2)) { |
| log.debug("MessagecontextSelfManagedDataTest::compareHandlers: class [" + |
| c1 + "] match "); |
| |
| int id1 = getHandlerID(o1); |
| int id2 = getHandlerID(o2); |
| |
| if (id1 == id2) { |
| log.debug("MessagecontextSelfManagedDataTest::compareHandlers: id [" + |
| id1 + "] match"); |
| return true; |
| } else { |
| log.debug("MessagecontextSelfManagedDataTest::compareHandlers: id1 [" + id1 + |
| "] != id2 [" + id2 + "] "); |
| return false; |
| } |
| } else { |
| log.debug("MessagecontextSelfManagedDataTest::compareHandlers: class1 [" + |
| c1 + "] != class2 [" + c2 + "] "); |
| return false; |
| } |
| } |
| |
| return false; |
| } |
| |
| |
| /** |
| * Compare two phases. |
| * |
| * @param o1 The first phase object |
| * @param o2 The second phase object |
| * @return TRUE if the phases are equivalent, |
| * FALSE otherwise |
| */ |
| private boolean comparePhases(Object o1, Object o2) { |
| if ((o1 == null) && (o2 == null)) { |
| return true; |
| } |
| |
| try { |
| if (((o1 != null) && (o2 != null)) |
| && ((o1 instanceof Phase) && (o2 instanceof Phase)) |
| ) { |
| Phase p1 = (Phase) o1; |
| Phase p2 = (Phase) o2; |
| |
| List list1 = p1.getHandlers(); |
| List list2 = p2.getHandlers(); |
| |
| if ((list1 == null) && (list2 == null)) { |
| return true; |
| } |
| |
| if ((list1 != null) && (list2 != null)) { |
| int size1 = list1.size(); |
| int size2 = list2.size(); |
| |
| if (size1 != size2) { |
| return false; |
| } |
| |
| for (int j = 0; j < size1; j++) { |
| Object obj1 = list1.get(j); |
| Object obj2 = list2.get(j); |
| |
| if ((obj1 == null) && (obj2 == null)) { |
| // ok |
| } else if ((obj1 != null) && (obj2 != null)) { |
| boolean check = false; |
| |
| if (obj1 instanceof Phase) { |
| check = comparePhases(obj1, obj2); |
| } else { |
| // must be a handler |
| check = compareHandlers(obj1, obj2); |
| } |
| |
| if (check == false) { |
| return false; |
| } |
| } else { |
| // mismatch |
| return false; |
| } |
| } |
| |
| // if we got here, the comparison completed ok |
| // with a match |
| |
| return true; |
| } |
| |
| } |
| } |
| catch (Exception e) { |
| // some error |
| e.printStackTrace(); |
| } |
| |
| return false; |
| } |
| |
| /* |
| private void comparePhases(Iterator it, ArrayList al) |
| { |
| int it_count = -1; |
| |
| while (it.hasNext()) |
| { |
| it_count++; |
| Handler handler = (Handler)it.next(); |
| if (handler instanceof Phase) |
| { |
| comparePhases(((Phase)handler).getHandlers().iterator(), ((Phase)al.get(it_count)).getHandlers()); |
| } |
| else |
| { |
| assertEquals(handler, (TempHandler02)al.get(it_count)); |
| } |
| } |
| } |
| |
| */ |
| |
| //------------------------------------------------------------------------- |
| // internal handlers |
| //------------------------------------------------------------------------- |
| |
| |
| /* |
| * TempHandler01 simply sets and/or removes data from the MessageContext |
| * object. |
| */ |
| public class TempHandler01 extends AbstractHandler { |
| private int id = -2; |
| |
| public TempHandler01() { |
| id = -1; |
| } |
| |
| public TempHandler01(int id) { |
| this.id = id; |
| } |
| |
| public int getID() { |
| return this.id; |
| } |
| |
| public String getName() { |
| return new String(Integer.toString(id)); |
| } |
| |
| public String getTestData01FromMessageContext(MessageContext _mc) { |
| return (String) _mc.getSelfManagedData(this.getClass(), key01); |
| } |
| |
| public String getTestData02FromMessageContext(MessageContext _mc) { |
| return (String) _mc.getSelfManagedData(this.getClass(), key02); |
| } |
| |
| public byte [] getTestData03FromMessageContext(MessageContext _mc) { |
| return (byte []) _mc.getSelfManagedData(this.getClass(), key03); |
| } |
| |
| public long [] getTestData04FromMessageContext(MessageContext _mc) { |
| return (long []) _mc.getSelfManagedData(this.getClass(), key04); |
| } |
| |
| /* we're just using the invoke to set/change/remove data |
| * Tests: |
| * for key01: set, remove, set, get |
| * for key02: set, get, set |
| * for key03: set, remove, set, get |
| * for key04: set, get, set, get |
| */ |
| public InvocationResponse invoke(MessageContext _mc) throws AxisFault { |
| |
| String desc = "TempHandler01[id=" + id + "].invoke()"; |
| String title = "MessageContextSelfManagedDataTest::" + desc; |
| log.debug(title); |
| |
| String tmp = "whaaa?"; |
| _mc.setSelfManagedData(this.getClass(), key02, tmp); |
| String data2 = (String) _mc.getSelfManagedData(this.getClass(), key02); |
| assertEquals(tmp, data2); |
| |
| _mc.setSelfManagedData(this.getClass(), key01, testData01); |
| _mc.removeSelfManagedData(this.getClass(), key01); |
| _mc.setSelfManagedData(this.getClass(), key01, testData01); |
| String data1 = (String) _mc.getSelfManagedData(this.getClass(), key01); |
| assertEquals(data1, testData01); |
| |
| _mc.setSelfManagedData(this.getClass(), key02, testData02); |
| |
| _mc.setSelfManagedData(this.getClass(), key03, testData03); |
| byte [] data3 = (byte []) _mc.getSelfManagedData(this.getClass(), key03); |
| boolean isOk3 = isEquals(data3, testData03); |
| assertTrue(isOk3); |
| |
| _mc.removeSelfManagedData(this.getClass(), key03); |
| _mc.setSelfManagedData(this.getClass(), key03, testData03); |
| |
| _mc.setSelfManagedData(this.getClass(), key04, testData04); |
| long [] data4 = (long []) _mc.getSelfManagedData(this.getClass(), key04); |
| boolean isOk4 = isEquals(data4, testData04); |
| assertTrue(isOk4); |
| |
| invokecallcount++; |
| |
| log.debug(title + ": Completed"); |
| return InvocationResponse.CONTINUE; |
| } |
| |
| } |
| |
| |
| /* |
| * TempHandler02 sets data, saves it (via the serializeSelfManagedData method |
| * called by the MessageContext object when saved in this handler's invoke()), |
| * |
| */ |
| public class TempHandler02 extends AbstractHandler implements SelfManagedDataManager { |
| private int id = -2; |
| private int serializecallcount = 0; |
| private int deserializecallcount = 0; |
| public String testData = new String("this is some test data"); |
| |
| /* |
| * constructor |
| */ |
| public TempHandler02() { |
| this.id = -1; |
| this.serializecallcount = 0; |
| this.deserializecallcount = 0; |
| } |
| |
| /* |
| * constructor |
| */ |
| public TempHandler02(int id) { |
| this.id = id; |
| this.serializecallcount = 0; |
| this.deserializecallcount = 0; |
| } |
| |
| public int getID() { |
| return this.id; |
| } |
| |
| public String getName() { |
| return new String(Integer.toString(id)); |
| } |
| |
| public String getTestDataFromMessageContext(MessageContext _mc) { |
| return (String) _mc.getSelfManagedData(this.getClass(), Integer.toString(id)); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * @see org.apache.axis2.engine.Handler#invoke(org.apache.axis2.context.MessageContext) |
| * |
| * This invoke() method will test several things: |
| * 1. verify that serializeSelfManagedData is actually called when saving the MessageContext object |
| * 2. verify that deserializeSelfManagedData is actually called when restoring the MessageContext object |
| * 3. verify that any SelfManagedData stored in the MessageContext is properly saved/restored (via serializeSelfManagedData/deserializeSelfManagedData) |
| */ |
| public InvocationResponse invoke(MessageContext _mc) throws AxisFault { |
| String desc = "TempHandler02[id=" + id + "].invoke()"; |
| String title = "MessageContextSelfManagedDataTest::" + desc; |
| log.debug(title); |
| |
| MessageContext msgContext2 = null; // this will be the restored one |
| |
| _mc.setSelfManagedData(this.getClass(), Integer.toString(id), |
| testData + Integer.toString(id)); |
| |
| log.debug(title + ": Setting self managed data using key [" + |
| Integer.toString(id) + "]"); |
| |
| msgContext2 = saveAndRestore(_mc, "TempHandler02_", desc); |
| |
| boolean result = (msgContext2 != null); |
| assertTrue(result); |
| |
| invokecallcount++; |
| |
| log.debug(title + ": Completed"); |
| return InvocationResponse.CONTINUE; |
| } |
| |
| |
| public void deserializeSelfManagedData(ByteArrayInputStream data, MessageContext _mc) |
| throws IOException { |
| deserializecallcount++; |
| |
| String desc = "TempHandler02[id=" + id + "].deserializeSelfManagedData() count [" + |
| deserializecallcount + "]"; |
| String title = "MessageContextSelfManagedDataTest::" + desc; |
| log.debug(title); |
| |
| ObjectInputStream ois = new ObjectInputStream(data); |
| testData = ois.readUTF().concat(" with extra text " + Integer.toString(id)); |
| _mc.setSelfManagedData(this.getClass(), Integer.toString(id), testData); |
| } |
| |
| |
| public void restoreTransientData(MessageContext _mc) { |
| // not necessary to test |
| } |
| |
| |
| public ByteArrayOutputStream serializeSelfManagedData(MessageContext _mc) |
| throws IOException { |
| serializecallcount++; |
| |
| String desc = "TempHandler02[id=" + id + "].serializeSelfManagedData() count [" + |
| serializecallcount + "]"; |
| String title = "MessageContextSelfManagedDataTest::" + desc; |
| log.debug(title); |
| |
| String storedTestData = |
| (String) _mc.getSelfManagedData(this.getClass(), Integer.toString(id)); |
| if (storedTestData == null) { |
| log.debug(title + ": No self managed data to serialize"); |
| return null; |
| } |
| |
| ByteArrayOutputStream baos = new ByteArrayOutputStream(); |
| ObjectOutputStream oos = new ObjectOutputStream(baos); |
| oos.writeUTF(storedTestData); |
| oos.close(); |
| int baos_size = baos.size(); |
| baos.close(); |
| |
| log.debug(title + ": saved self managed data string length [" + |
| storedTestData.length() + "]"); |
| log.debug(title + |
| ": saved self managed data byte array output stream (UTF) length [" + |
| baos_size + "]"); |
| return baos; |
| } |
| |
| public int getDeserializecallcount() { |
| return deserializecallcount; |
| } |
| |
| public int getSerializecallcount() { |
| return serializecallcount; |
| } |
| } |
| |
| |
| /* |
| * TempHandler03 sets binary data, saves it (via the serializeSelfManagedData method |
| * called by the MessageContext object when saved in this handler's invoke()), |
| * |
| */ |
| public class TempHandler03 extends AbstractHandler implements SelfManagedDataManager { |
| private int id = -2; |
| private int serializecallcount = 0; |
| private int deserializecallcount = 0; |
| |
| public TempHandler03() { |
| id = -1; |
| } |
| |
| public TempHandler03(int id) { |
| this.id = id; |
| } |
| |
| public int getID() { |
| return this.id; |
| } |
| |
| public String getName() { |
| return new String(Integer.toString(id)); |
| } |
| |
| public Object getTestDataFromMessageContext(MessageContext _mc) { |
| return _mc.getSelfManagedData(this.getClass(), Integer.toString(id)); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * @see org.apache.axis2.engine.Handler#invoke(org.apache.axis2.context.MessageContext) |
| * |
| * This invoke() method will test several things: |
| * 1. verify that serializeSelfManagedData is actually called when saving the MessageContext object |
| * 2. verify that deserializeSelfManagedData is actually called when restoring the MessageContext object |
| * 3. verify that any SelfManagedData stored in the MessageContext is properly saved/restored (via serializeSelfManagedData/deserializeSelfManagedData) |
| */ |
| public InvocationResponse invoke(MessageContext _mc) throws AxisFault { |
| |
| String desc = "TempHandler03[id=" + id + "].invoke()"; |
| String title = "MessageContextSelfManagedDataTest::" + desc; |
| log.debug(title); |
| |
| MessageContext msgContext2 = null; // this will be the restored one |
| |
| // add the byte [] of data |
| _mc.setSelfManagedData(this.getClass(), Integer.toString(id), testData03); |
| |
| log.debug(title + ": Setting self managed data using key [" + |
| Integer.toString(id) + "]"); |
| |
| msgContext2 = saveAndRestore(_mc, "TempHandler03_", desc); |
| |
| boolean result = (msgContext2 != null); |
| assertTrue(result); |
| |
| invokecallcount++; |
| |
| log.debug(title + ": Completed"); |
| return InvocationResponse.CONTINUE; |
| } |
| |
| public void deserializeSelfManagedData(ByteArrayInputStream data, MessageContext _mc) |
| throws IOException { |
| boolean isOK = true; |
| |
| deserializecallcount++; |
| |
| String desc = "TempHandler03[id=" + id + "].deserializeSelfManagedData() count [" + |
| deserializecallcount + "]"; |
| String title = "MessageContextSelfManagedDataTest::" + desc; |
| log.debug(title); |
| |
| int expected = testData03.length; |
| |
| byte [] tmp = new byte [expected]; |
| |
| boolean keepGoing = true; |
| int index = 0; |
| |
| while (keepGoing) { |
| int tmpdata = data.read(); |
| |
| if (tmpdata != -1) { |
| Integer value = new Integer(tmpdata); |
| tmp[index] = value.byteValue(); |
| index++; |
| |
| if (index > expected) { |
| isOK = false; |
| assertTrue(isOK); |
| } |
| } else { |
| keepGoing = false; |
| } |
| } |
| |
| isOK = isEquals(tmp, testData03); |
| assertTrue(isOK); |
| |
| _mc.setSelfManagedData(this.getClass(), Integer.toString(id), tmp); |
| } |
| |
| public void restoreTransientData(MessageContext _mc) { |
| // not necessary to test |
| } |
| |
| public ByteArrayOutputStream serializeSelfManagedData(MessageContext _mc) |
| throws IOException { |
| |
| serializecallcount++; |
| |
| String desc = "TempHandler03[id=" + id + "].serializeSelfManagedData() count [" + |
| serializecallcount + "]"; |
| String title = "MessageContextSelfManagedDataTest::" + desc; |
| log.debug(title); |
| |
| byte [] tmp = (byte []) _mc.getSelfManagedData(this.getClass(), Integer.toString(id)); |
| |
| if (tmp == null) { |
| log.debug(title + ": No self managed data to serialize"); |
| return null; |
| } |
| |
| ByteArrayOutputStream baos = new ByteArrayOutputStream(); |
| baos.write(tmp, 0, tmp.length); |
| int baos_size = baos.size(); |
| baos.close(); |
| |
| log.debug(title + ": saved self managed data byte [] length [" + tmp.length + "]"); |
| log.debug(title + |
| ": saved self managed data byte array output stream length [" + baos_size + |
| "]"); |
| return baos; |
| } |
| |
| |
| public int getDeserializecallcout() { |
| return deserializecallcount; |
| } |
| |
| public int getSerializecallcount() { |
| return serializecallcount; |
| } |
| } |
| |
| |
| /* |
| * TempHandler04 sets binary data, saves it (via the serializeSelfManagedData method |
| * called by the MessageContext object when saved in this handler's invoke()), |
| * |
| */ |
| public class TempHandler04 extends AbstractHandler implements SelfManagedDataManager { |
| private int id = -2; |
| private int serializecallcount = 0; |
| private int deserializecallcount = 0; |
| |
| |
| public TempHandler04() { |
| id = -1; |
| } |
| |
| public TempHandler04(int id) { |
| this.id = id; |
| } |
| |
| public int getID() { |
| return this.id; |
| } |
| |
| public String getName() { |
| return new String(Integer.toString(id)); |
| } |
| |
| public Object getTestDataFromMessageContext(MessageContext _mc) { |
| return _mc.getSelfManagedData(this.getClass(), Integer.toString(id)); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * @see org.apache.axis2.engine.Handler#invoke(org.apache.axis2.context.MessageContext) |
| * |
| * This invoke() method will test several things: |
| * 1. verify that serializeSelfManagedData is actually called when saving the MessageContext object |
| * 2. verify that deserializeSelfManagedData is actually called when restoring the MessageContext object |
| * 3. verify that any SelfManagedData stored in the MessageContext is properly saved/restored (via serializeSelfManagedData/deserializeSelfManagedData) |
| */ |
| public InvocationResponse invoke(MessageContext _mc) throws AxisFault { |
| |
| String desc = "TempHandler04[id=" + id + "].invoke()"; |
| String title = "MessageContextSelfManagedDataTest::" + desc; |
| log.debug(title); |
| |
| MessageContext msgContext2 = null; // this will be the restored one |
| |
| // add the byte [] of data |
| _mc.setSelfManagedData(this.getClass(), Integer.toString(id), testData04); |
| |
| log.debug(title + ": Setting self managed data using key [" + |
| Integer.toString(id) + "]"); |
| |
| msgContext2 = saveAndRestore(_mc, "TempHandler04_", desc); |
| |
| boolean result = (msgContext2 != null); |
| assertTrue(result); |
| |
| invokecallcount++; |
| |
| log.debug(title + ": Completed"); |
| return InvocationResponse.CONTINUE; |
| } |
| |
| public void deserializeSelfManagedData(ByteArrayInputStream data, MessageContext _mc) |
| throws IOException { |
| boolean isOK = true; |
| |
| deserializecallcount++; |
| |
| String desc = "TempHandler04[id=" + id + "].deserializeSelfManagedData() count [" + |
| deserializecallcount + "]"; |
| String title = "MessageContextSelfManagedDataTest::" + desc; |
| log.debug(title); |
| |
| int expected = testData04.length; |
| |
| long [] tmp = new long [expected]; |
| |
| ObjectInputStream ois = new ObjectInputStream(data); |
| |
| boolean keepGoing = true; |
| int index = 0; |
| |
| int sizeWritten = ois.readInt(); |
| |
| if (sizeWritten > 0) { |
| while (keepGoing) { |
| try { |
| long tmpdata = ois.readLong(); |
| |
| tmp[index] = tmpdata; |
| index++; |
| |
| if (index > expected) { |
| isOK = false; |
| assertTrue(isOK); |
| } |
| } |
| catch (Exception exc) { |
| keepGoing = false; |
| } |
| } |
| |
| isOK = isEquals(tmp, testData04); |
| assertTrue(isOK); |
| |
| _mc.setSelfManagedData(this.getClass(), Integer.toString(id), tmp); |
| } |
| |
| } |
| |
| public void restoreTransientData(MessageContext _mc) { |
| // not necessary to test |
| } |
| |
| public ByteArrayOutputStream serializeSelfManagedData(MessageContext _mc) |
| throws IOException { |
| |
| serializecallcount++; |
| |
| String desc = "TempHandler04[id=" + id + "].serializeSelfManagedData() count [" + |
| serializecallcount + "]"; |
| String title = "MessageContextSelfManagedDataTest::" + desc; |
| log.debug(title); |
| |
| long [] tmp = (long []) _mc.getSelfManagedData(this.getClass(), Integer.toString(id)); |
| |
| if (tmp == null) { |
| log.debug(title + ": No self managed data to serialize"); |
| return null; |
| } |
| |
| ByteArrayOutputStream baos = new ByteArrayOutputStream(); |
| ObjectOutputStream oos = new ObjectOutputStream(baos); |
| |
| int size = tmp.length; |
| |
| oos.writeInt(size); |
| |
| for (int i = 0; i < size; i++) { |
| oos.writeLong(tmp[i]); |
| } |
| |
| oos.close(); |
| int baos_size = baos.size(); |
| baos.close(); |
| |
| log.debug(title + ": saved self managed data byte [] length [" + tmp.length + "]"); |
| log.debug(title + |
| ": saved self managed data byte array output stream length [" + baos_size + |
| "]"); |
| return baos; |
| } |
| |
| |
| public int getDeserializecallcount() { |
| return deserializecallcount; |
| } |
| |
| public int getSerializecallcount() { |
| return serializecallcount; |
| } |
| } |
| |
| |
| /* |
| * compares the two byte arrays to see if they are equal |
| */ |
| private boolean isEquals(byte [] b1, byte [] b2) { |
| int size1 = b1.length; |
| int size2 = b2.length; |
| |
| if (size1 != size2) { |
| return false; |
| } |
| |
| for (int i = 0; i < size1; i++) { |
| if (b1[i] != b2[i]) { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| /* |
| * compares the two long arrays to see if they are equal |
| */ |
| private boolean isEquals(long [] L1, long [] L2) { |
| int size1 = L1.length; |
| int size2 = L2.length; |
| |
| if (size1 != size2) { |
| return false; |
| } |
| |
| for (int i = 0; i < size1; i++) { |
| if (L1[i] != L2[i]) { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| |
| } |
