Upgraded tests.

core/src/test/java/org/springframework/ws/client/core/SimpleFaultMessageResolverTest.java

@@ -16,34 +16,40 @@
 
 package org.springframework.ws.client.core;
 
-import junit.framework.TestCase;
-import org.easymock.MockControl;
 import org.springframework.ws.FaultAwareWebServiceMessage;
 import org.springframework.ws.client.WebServiceFaultException;
 
-public class SimpleFaultMessageResolverTest extends TestCase {
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.easymock.EasyMock.*;
+
+public class SimpleFaultMessageResolverTest {
 
     private SimpleFaultMessageResolver resolver;
 
-    @Override
-    protected void setUp() throws Exception {
+    @Before
+    public void setUp() throws Exception {
         resolver = new SimpleFaultMessageResolver();
     }
 
+    @Test
     public void testResolveFault() throws Exception {
-        MockControl messageControl = MockControl.createControl(FaultAwareWebServiceMessage.class);
-        FaultAwareWebServiceMessage messageMock = (FaultAwareWebServiceMessage) messageControl.getMock();
+        FaultAwareWebServiceMessage messageMock = createMock(FaultAwareWebServiceMessage.class);
         String message = "message";
-        messageControl.expectAndReturn(messageMock.getFaultReason(), message);
-        messageControl.replay();
+        expect(messageMock.getFaultReason()).andReturn(message);
+
+        replay(messageMock);
+
         try {
             resolver.resolveFault(messageMock);
-            fail("WebServiceFaultExcpetion expected");
+            Assert.fail("WebServiceFaultExcpetion expected");
         }
         catch (WebServiceFaultException ex) {
             // expected
-            assertEquals("Invalid exception message", message, ex.getMessage());
+            Assert.assertEquals("Invalid exception message", message, ex.getMessage());
         }
-        messageControl.verify();
+        verify(messageMock);
     }
 }

core/src/test/java/org/springframework/ws/client/core/SimpleSaajServlet.java

@@ -55,7 +55,7 @@ public class SimpleSaajServlet extends HttpServlet {
     }
 
     private MimeHeaders getHeaders(HttpServletRequest httpServletRequest) {
-        Enumeration enumeration = httpServletRequest.getHeaderNames();
+        Enumeration<?> enumeration = httpServletRequest.getHeaderNames();
         MimeHeaders headers = new MimeHeaders();
         while (enumeration.hasMoreElements()) {
             String headerName = (String) enumeration.nextElement();
@@ -69,7 +69,7 @@ public class SimpleSaajServlet extends HttpServlet {
     }
 
     private void putHeaders(MimeHeaders headers, HttpServletResponse res) {
-        Iterator it = headers.getAllHeaders();
+        Iterator<?> it = headers.getAllHeaders();
         while (it.hasNext()) {
             MimeHeader header = (MimeHeader) it.next();
             String[] values = headers.getHeader(header.getName());

core/src/test/java/org/springframework/ws/client/core/WebServiceTemplateTest.java

@@ -18,14 +18,14 @@ package org.springframework.ws.client.core;
 
 import java.io.IOException;
 import java.net.URI;
-
-import org.custommonkey.xmlunit.XMLTestCase;
-import org.easymock.MockControl;
+import javax.xml.transform.Result;
+import javax.xml.transform.Source;
 
 import org.springframework.oxm.Marshaller;
 import org.springframework.oxm.Unmarshaller;
 import org.springframework.ws.MockWebServiceMessage;
 import org.springframework.ws.MockWebServiceMessageFactory;
+import org.springframework.ws.WebServiceMessage;
 import org.springframework.ws.client.WebServiceTransportException;
 import org.springframework.ws.client.support.destination.DestinationProvider;
 import org.springframework.ws.client.support.interceptor.ClientInterceptor;
@@ -37,25 +37,28 @@ import org.springframework.ws.transport.WebServiceMessageSender;
 import org.springframework.xml.transform.StringResult;
 import org.springframework.xml.transform.StringSource;
 
-public class WebServiceTemplateTest extends XMLTestCase {
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.easymock.EasyMock.*;
+
+public class WebServiceTemplateTest {
 
     private WebServiceTemplate template;
 
-    private MockControl connectionControl;
-
     private FaultAwareWebServiceConnection connectionMock;
 
     private MockWebServiceMessageFactory messageFactory;
 
-    @Override
-    protected void setUp() throws Exception {
+    @Before
+    public void setUp() throws Exception {
         template = new WebServiceTemplate();
         messageFactory = new MockWebServiceMessageFactory();
         template.setMessageFactory(messageFactory);
-        connectionControl = MockControl.createStrictControl(FaultAwareWebServiceConnection.class);
-        connectionMock = (FaultAwareWebServiceConnection) connectionControl.getMock();
+        connectionMock = createMock(FaultAwareWebServiceConnection.class);
         final URI expectedUri = new URI("http://www.springframework.org/spring-ws");
-        connectionControl.expectAndDefaultReturn(connectionMock.getUri(), expectedUri);
+        expect(connectionMock.getUri()).andReturn(expectedUri).anyTimes();
         template.setMessageSender(new WebServiceMessageSender() {
 
             public WebServiceConnection createConnection(URI uri) throws IOException {
@@ -63,286 +66,257 @@ public class WebServiceTemplateTest extends XMLTestCase {
             }
 
             public boolean supports(URI uri) {
-                assertEquals("Invalid uri", expectedUri, uri);
+                Assert.assertEquals("Invalid uri", expectedUri, uri);
                 return true;
             }
         });
         template.setDefaultUri(expectedUri.toString());
     }
 
+    @Test
     public void testMarshalAndSendNoMarshallerSet() throws Exception {
         connectionMock.close();
-        connectionControl.replay();
+
+        replay(connectionMock);
+
         template.setMarshaller(null);
         try {
             template.marshalSendAndReceive(new Object());
-            fail("IllegalStateException expected");
+            Assert.fail("IllegalStateException expected");
         }
         catch (IllegalStateException ex) {
             // expected behavior
         }
-        connectionControl.verify();
+
+        verify(connectionMock);
     }
 
+    @Test
     public void testMarshalAndSendNoUnmarshallerSet() throws Exception {
         connectionMock.close();
-        connectionControl.replay();
+
+        replay(connectionMock);
+
         template.setUnmarshaller(null);
         try {
             template.marshalSendAndReceive(new Object());
-            fail("IllegalStateException expected");
+            Assert.fail("IllegalStateException expected");
         }
         catch (IllegalStateException ex) {
             // expected behavior
         }
-        connectionControl.verify();
+
+        verify(connectionMock);
     }
 
+    @Test
     public void testSendAndReceiveMessageResponse() throws Exception {
-        MockControl callbackControl = MockControl.createControl(WebServiceMessageCallback.class);
-        WebServiceMessageCallback requestCallback = (WebServiceMessageCallback) callbackControl.getMock();
-        requestCallback.doWithMessage(null);
-        callbackControl.setMatcher(MockControl.ALWAYS_MATCHER);
-        callbackControl.replay();
+        WebServiceMessageCallback requestCallback = createMock(WebServiceMessageCallback.class);
+        requestCallback.doWithMessage(isA(WebServiceMessage.class));
 
-        MockControl extractorControl = MockControl.createControl(WebServiceMessageExtractor.class);
-        WebServiceMessageExtractor extractorMock = (WebServiceMessageExtractor) extractorControl.getMock();
-        extractorMock.extractData(null);
-        extractorControl.setMatcher(MockControl.ALWAYS_MATCHER);
+        WebServiceMessageExtractor extractorMock = createMock(WebServiceMessageExtractor.class);
         Object extracted = new Object();
-        extractorControl.setReturnValue(extracted);
-        extractorControl.replay();
+        expect(extractorMock.extractData(isA(WebServiceMessage.class))).andReturn(extracted);
 
-        connectionMock.send(null);
-        connectionControl.setMatcher(MockControl.ALWAYS_MATCHER);
-        connectionControl.expectAndReturn(connectionMock.hasError(), false);
-        connectionControl
-                .expectAndReturn(connectionMock.receive(messageFactory), new MockWebServiceMessage("<response/>"));
-        connectionControl.expectAndReturn(connectionMock.hasFault(), false);
+        connectionMock.send(isA(WebServiceMessage.class));
+        expect(connectionMock.hasError()).andReturn(false);
+        expect(connectionMock.receive(messageFactory)).andReturn(new MockWebServiceMessage("<response/>"));
+        expect(connectionMock.hasFault()).andReturn(false);
         connectionMock.close();
-        connectionControl.replay();
+
+        replay(connectionMock, requestCallback, extractorMock);
 
         Object result = template.sendAndReceive(requestCallback, extractorMock);
-        assertEquals("Invalid response", extracted, result);
+        Assert.assertEquals("Invalid response", extracted, result);
 
-        callbackControl.verify();
-        extractorControl.verify();
-        connectionControl.verify();
+        verify(connectionMock, requestCallback, extractorMock);
     }
 
+    @Test
     public void testSendAndReceiveMessageNoResponse() throws Exception {
-        MockControl extractorControl = MockControl.createControl(WebServiceMessageExtractor.class);
-        WebServiceMessageExtractor extractorMock = (WebServiceMessageExtractor) extractorControl.getMock();
-        extractorControl.replay();
+        WebServiceMessageExtractor extractorMock = createMock(WebServiceMessageExtractor.class);
 
-        connectionMock.send(null);
-        connectionControl.setMatcher(MockControl.ALWAYS_MATCHER);
-        connectionControl.expectAndReturn(connectionMock.hasError(), false);
-        connectionControl.expectAndReturn(connectionMock.receive(messageFactory), null);
+        connectionMock.send(isA(WebServiceMessage.class));
+        expect(connectionMock.hasError()).andReturn(false);
+        expect(connectionMock.receive(messageFactory)).andReturn(null);
         connectionMock.close();
-        connectionControl.replay();
+
+        replay(connectionMock, extractorMock);
 
         Object result = template.sendAndReceive(null, extractorMock);
-        assertNull("Invalid response", result);
-        extractorControl.verify();
-        connectionControl.verify();
+        Assert.assertNull("Invalid response", result);
+
+        verify(connectionMock, extractorMock);
     }
 
+    @Test
     public void testSendAndReceiveMessageFault() throws Exception {
-        MockControl extractorControl = MockControl.createControl(WebServiceMessageExtractor.class);
-        WebServiceMessageExtractor extractorMock = (WebServiceMessageExtractor) extractorControl.getMock();
-        extractorControl.replay();
+        WebServiceMessageExtractor extractorMock = createMock(WebServiceMessageExtractor.class);
 
-        MockControl faultResolverControl = MockControl.createControl(FaultMessageResolver.class);
-        FaultMessageResolver faultMessageResolverMock = (FaultMessageResolver) faultResolverControl.getMock();
+        FaultMessageResolver faultMessageResolverMock = createMock(FaultMessageResolver.class);
         template.setFaultMessageResolver(faultMessageResolverMock);
-        faultMessageResolverMock.resolveFault(null);
-        faultResolverControl.setMatcher(MockControl.ALWAYS_MATCHER);
-        faultResolverControl.replay();
+        faultMessageResolverMock.resolveFault(isA(WebServiceMessage.class));
 
         MockWebServiceMessage response = new MockWebServiceMessage("<response/>");
         response.setFault(true);
 
-        connectionMock.send(null);
-        connectionControl.setMatcher(MockControl.ALWAYS_MATCHER);
-        connectionControl.expectAndReturn(connectionMock.hasError(), true);
-        connectionControl.expectAndReturn(connectionMock.hasFault(), true);
-        connectionControl
-                .expectAndReturn(connectionMock.receive(messageFactory), response);
-        connectionControl.expectAndReturn(connectionMock.hasFault(), true);
+        connectionMock.send(isA(WebServiceMessage.class));
+        expect(connectionMock.hasError()).andReturn(false);
+        expect(connectionMock.hasFault()).andReturn(true).times(2);
+        expect(connectionMock.receive(messageFactory)).andReturn(response);
         connectionMock.close();
-        connectionControl.replay();
+
+        replay(connectionMock, extractorMock, faultMessageResolverMock);
 
         Object result = template.sendAndReceive(null, extractorMock);
-        assertNull("Invalid response", result);
+        Assert.assertNull("Invalid response", result);
 
-        extractorControl.verify();
-        connectionControl.verify();
-        faultResolverControl.verify();
+        verify(connectionMock, extractorMock, faultMessageResolverMock);
     }
 
+    @Test
     public void testSendAndReceiveConnectionError() throws Exception {
-        MockControl extractorControl = MockControl.createControl(WebServiceMessageExtractor.class);
-        WebServiceMessageExtractor extractorMock = (WebServiceMessageExtractor) extractorControl.getMock();
-        extractorControl.replay();
+        WebServiceMessageExtractor extractorMock = createMock(WebServiceMessageExtractor.class);
 
         template.setFaultMessageResolver(null);
 
-        connectionMock.send(null);
-        connectionControl.setMatcher(MockControl.ALWAYS_MATCHER);
-        connectionControl.expectAndReturn(connectionMock.hasError(), true);
-        connectionControl.expectAndReturn(connectionMock.hasFault(), false);
+        connectionMock.send(isA(WebServiceMessage.class));
+        expect(connectionMock.hasError()).andReturn(true);
+        expect(connectionMock.hasFault()).andReturn(false);
         String errorMessage = "errorMessage";
-        connectionControl.expectAndReturn(connectionMock.getErrorMessage(), errorMessage);
+        expect(connectionMock.getErrorMessage()).andReturn(errorMessage);
         connectionMock.close();
-        connectionControl.replay();
+
+        replay(connectionMock, extractorMock);
 
         try {
             template.sendAndReceive(null, extractorMock);
-            fail("Expected WebServiceTransportException");
+            Assert.fail("Expected WebServiceTransportException");
         }
         catch (WebServiceTransportException ex) {
             //expected
-            assertEquals("Invalid exception message", errorMessage, ex.getMessage());
+            Assert.assertEquals("Invalid exception message", errorMessage, ex.getMessage());
         }
 
-        extractorControl.verify();
-        connectionControl.verify();
+        verify(connectionMock, extractorMock);
     }
 
+    @Test
     public void testSendAndReceiveSourceResponse() throws Exception {
-        MockControl extractorControl = MockControl.createControl(SourceExtractor.class);
-        SourceExtractor extractorMock = (SourceExtractor) extractorControl.getMock();
-        extractorMock.extractData(null);
-        extractorControl.setMatcher(MockControl.ALWAYS_MATCHER);
+        SourceExtractor extractorMock = createMock(SourceExtractor.class);
         Object extracted = new Object();
-        extractorControl.setReturnValue(extracted);
-        extractorControl.replay();
+        expect(extractorMock.extractData(isA(Source.class))).andReturn(extracted);
 
-        connectionMock.send(null);
-        connectionControl.setMatcher(MockControl.ALWAYS_MATCHER);
-        connectionControl.expectAndReturn(connectionMock.hasError(), false);
-        connectionControl
-                .expectAndReturn(connectionMock.receive(messageFactory), new MockWebServiceMessage("<response/>"));
-        connectionControl.expectAndReturn(connectionMock.hasFault(), false);
+        connectionMock.send(isA(WebServiceMessage.class));
+        expect(connectionMock.hasError()).andReturn(false);
+        expect(connectionMock.receive(messageFactory)).andReturn(new MockWebServiceMessage("<response/>"));
+        expect(connectionMock.hasFault()).andReturn(false);
         connectionMock.close();
-        connectionControl.replay();
+
+        replay(connectionMock, extractorMock);
 
         Object result = template.sendSourceAndReceive(new StringSource("<request />"), extractorMock);
-        assertEquals("Invalid response", extracted, result);
+        Assert.assertEquals("Invalid response", extracted, result);
 
-        extractorControl.verify();
-        connectionControl.verify();
+        verify(connectionMock, extractorMock);
     }
 
+    @Test
     public void testSendAndReceiveSourceNoResponse() throws Exception {
-        MockControl extractorControl = MockControl.createControl(SourceExtractor.class);
-        SourceExtractor extractorMock = (SourceExtractor) extractorControl.getMock();
-        extractorControl.replay();
+        SourceExtractor extractorMock = createMock(SourceExtractor.class);
 
-        connectionMock.send(null);
-        connectionControl.setMatcher(MockControl.ALWAYS_MATCHER);
-        connectionControl.expectAndReturn(connectionMock.hasError(), false);
-        connectionControl.expectAndReturn(connectionMock.receive(messageFactory), null);
+        connectionMock.send(isA(WebServiceMessage.class));
+        expect(connectionMock.hasError()).andReturn(false);
+        expect(connectionMock.receive(messageFactory)).andReturn(null);
         connectionMock.close();
-        connectionControl.replay();
+
+        replay(connectionMock, extractorMock);
 
         Object result = template.sendSourceAndReceive(new StringSource("<request />"), extractorMock);
-        assertNull("Invalid response", result);
+        Assert.assertNull("Invalid response", result);
 
-        extractorControl.verify();
-        connectionControl.verify();
+        verify(connectionMock, extractorMock);
     }
 
+    @Test
     public void testSendAndReceiveResultResponse() throws Exception {
-        connectionMock.send(null);
-        connectionControl.setMatcher(MockControl.ALWAYS_MATCHER);
-        connectionControl.expectAndReturn(connectionMock.hasError(), false);
-        connectionControl
-                .expectAndReturn(connectionMock.receive(messageFactory), new MockWebServiceMessage("<response/>"));
-        connectionControl.expectAndReturn(connectionMock.hasFault(), false);
+        connectionMock.send(isA(WebServiceMessage.class));
+        expect(connectionMock.hasError()).andReturn(false);
+        expect(connectionMock.receive(messageFactory)).andReturn(new MockWebServiceMessage("<response/>"));
+        expect(connectionMock.hasFault()).andReturn(false);
         connectionMock.close();
-        connectionControl.replay();
+
+        replay(connectionMock);
 
         StringResult result = new StringResult();
         boolean b = template.sendSourceAndReceiveToResult(new StringSource("<request />"), result);
-        assertTrue("Invalid result", b);
+        Assert.assertTrue("Invalid result", b);
 
-        connectionControl.verify();
+        verify(connectionMock);
     }
 
+    @Test
     public void testSendAndReceiveResultNoResponse() throws Exception {
-        connectionMock.send(null);
-        connectionControl.setMatcher(MockControl.ALWAYS_MATCHER);
-        connectionControl.expectAndReturn(connectionMock.hasError(), false);
-        connectionControl
-                .expectAndReturn(connectionMock.receive(messageFactory), null);
+        connectionMock.send(isA(WebServiceMessage.class));
+        expect(connectionMock.hasError()).andReturn(false);
+        expect(connectionMock.receive(messageFactory)).andReturn(null);
         connectionMock.close();
-        connectionControl.replay();
+
+        replay(connectionMock);
 
         StringResult result = new StringResult();
         boolean b = template.sendSourceAndReceiveToResult(new StringSource("<request />"), result);
-        assertFalse("Invalid result", b);
+        Assert.assertFalse("Invalid result", b);
 
-        connectionControl.verify();
+        verify(connectionMock);
     }
 
+    @Test
     public void testSendAndReceiveMarshalResponse() throws Exception {
-        MockControl marshallerControl = MockControl.createControl(Marshaller.class);
-        Marshaller marshallerMock = (Marshaller) marshallerControl.getMock();
+        Marshaller marshallerMock = createMock(Marshaller.class);
         template.setMarshaller(marshallerMock);
-        marshallerMock.marshal(null, null);
-        marshallerControl.setMatcher(MockControl.ALWAYS_MATCHER);
-        marshallerControl.replay();
+        marshallerMock.marshal(isA(Object.class), isA(Result.class));
 
-        MockControl unmarshallerControl = MockControl.createControl(Unmarshaller.class);
-        Unmarshaller unmarshallerMock = (Unmarshaller) unmarshallerControl.getMock();
+        Unmarshaller unmarshallerMock = createMock(Unmarshaller.class);
         template.setUnmarshaller(unmarshallerMock);
-        unmarshallerMock.unmarshal(null);
-        unmarshallerControl.setMatcher(MockControl.ALWAYS_MATCHER);
         Object unmarshalled = new Object();
-        unmarshallerControl.setReturnValue(unmarshalled);
-        unmarshallerControl.replay();
+        expect(unmarshallerMock.unmarshal(isA(Source.class))).andReturn(unmarshalled);
 
-        connectionMock.send(null);
-        connectionControl.setMatcher(MockControl.ALWAYS_MATCHER);
-        connectionControl.expectAndReturn(connectionMock.hasError(), false);
-        connectionControl
-                .expectAndReturn(connectionMock.receive(messageFactory), new MockWebServiceMessage("<response/>"));
-        connectionControl.expectAndReturn(connectionMock.hasFault(), false);
+        connectionMock.send(isA(WebServiceMessage.class));
+        expect(connectionMock.hasError()).andReturn(false);
+        expect(connectionMock.receive(messageFactory)).andReturn(new MockWebServiceMessage("<response/>"));
+        expect(connectionMock.hasFault()).andReturn(false);
         connectionMock.close();
-        connectionControl.replay();
+
+        replay(connectionMock, marshallerMock, unmarshallerMock);
 
         Object result = template.marshalSendAndReceive(new Object());
-        assertEquals("Invalid result", unmarshalled, result);
+        Assert.assertEquals("Invalid result", unmarshalled, result);
 
-        connectionControl.verify();
-        marshallerControl.verify();
-        unmarshallerControl.verify();
+        verify(connectionMock, marshallerMock, unmarshallerMock);
     }
 
+    @Test
     public void testSendAndReceiveMarshalNoResponse() throws Exception {
-        MockControl marshallerControl = MockControl.createControl(Marshaller.class);
-        Marshaller marshallerMock = (Marshaller) marshallerControl.getMock();
+        Marshaller marshallerMock = createMock(Marshaller.class);
         template.setMarshaller(marshallerMock);
-        marshallerMock.marshal(null, null);
-        marshallerControl.setMatcher(MockControl.ALWAYS_MATCHER);
-        marshallerControl.replay();
+        marshallerMock.marshal(isA(Object.class), isA(Result.class));
 
-        connectionMock.send(null);
-        connectionControl.setMatcher(MockControl.ALWAYS_MATCHER);
-        connectionControl.expectAndReturn(connectionMock.hasError(), false);
-        connectionControl.expectAndReturn(connectionMock.receive(messageFactory), null);
+        connectionMock.send(isA(WebServiceMessage.class));
+        expect(connectionMock.hasError()).andReturn(false);
+        expect(connectionMock.receive(messageFactory)).andReturn(null);
+        expect(connectionMock.hasFault()).andReturn(false);
         connectionMock.close();
-        connectionControl.replay();
+
+        replay(connectionMock, marshallerMock);
 
         Object result = template.marshalSendAndReceive(new Object());
-        assertNull("Invalid result", result);
+        Assert.assertNull("Invalid result", result);
 
-        connectionControl.verify();
-        marshallerControl.verify();
+        verify(connectionMock, marshallerMock);
     }
 
+    @Test
     public void testSendAndReceiveCustomUri() throws Exception {
         final URI customUri = new URI("http://www.springframework.org/spring-ws/custom");
         template.setMessageSender(new WebServiceMessageSender() {
@@ -352,168 +326,128 @@ public class WebServiceTemplateTest extends XMLTestCase {
             }
 
             public boolean supports(URI uri) {
-                assertEquals("Invalid uri", customUri, uri);
+                Assert.assertEquals("Invalid uri", customUri, uri);
                 return true;
             }
         });
-        MockControl callbackControl = MockControl.createControl(WebServiceMessageCallback.class);
-        WebServiceMessageCallback requestCallback = (WebServiceMessageCallback) callbackControl.getMock();
-        requestCallback.doWithMessage(null);
-        callbackControl.setMatcher(MockControl.ALWAYS_MATCHER);
-        callbackControl.replay();
+        WebServiceMessageCallback requestCallback = createMock(WebServiceMessageCallback.class);
+        requestCallback.doWithMessage(isA(WebServiceMessage.class));
 
-        MockControl extractorControl = MockControl.createControl(WebServiceMessageExtractor.class);
-        WebServiceMessageExtractor extractorMock = (WebServiceMessageExtractor) extractorControl.getMock();
-        extractorMock.extractData(null);
-        extractorControl.setMatcher(MockControl.ALWAYS_MATCHER);
+        WebServiceMessageExtractor extractorMock = createMock(WebServiceMessageExtractor.class);
         Object extracted = new Object();
-        extractorControl.setReturnValue(extracted);
-        extractorControl.replay();
+        expect(extractorMock.extractData(isA(WebServiceMessage.class))).andReturn(extracted);
 
-        connectionMock.send(null);
-        connectionControl.setMatcher(MockControl.ALWAYS_MATCHER);
-        connectionControl.expectAndReturn(connectionMock.hasError(), false);
-        connectionControl
-                .expectAndReturn(connectionMock.receive(messageFactory), new MockWebServiceMessage("<response/>"));
-        connectionControl.expectAndReturn(connectionMock.hasFault(), false);
+        connectionMock.send(isA(WebServiceMessage.class));
+        expect(connectionMock.hasError()).andReturn(false);
+        expect(connectionMock.receive(messageFactory)).andReturn(new MockWebServiceMessage("<response/>"));
+        expect(connectionMock.hasFault()).andReturn(false);
         connectionMock.close();
-        connectionControl.replay();
+
+        replay(connectionMock, requestCallback, extractorMock);
 
         Object result = template.sendAndReceive(customUri.toString(), requestCallback, extractorMock);
-        assertEquals("Invalid response", extracted, result);
+        Assert.assertEquals("Invalid response", extracted, result);
 
-        callbackControl.verify();
-        extractorControl.verify();
-        connectionControl.verify();
+        verify(connectionMock, requestCallback, extractorMock);
     }
 
+    @Test
     public void testInterceptors() throws Exception {
-        MockControl interceptorControl = MockControl.createControl(ClientInterceptor.class);
-        interceptorControl.setDefaultMatcher(MockControl.ALWAYS_MATCHER);
-        ClientInterceptor interceptorMock1 = (ClientInterceptor) interceptorControl.getMock();
-        ClientInterceptor interceptorMock2 = (ClientInterceptor) interceptorControl.getMock();
+        ClientInterceptor interceptorMock1 = createStrictMock("interceptor1", ClientInterceptor.class);
+        ClientInterceptor interceptorMock2 = createStrictMock("interceptor2", ClientInterceptor.class);
         template.setInterceptors(new ClientInterceptor[]{interceptorMock1, interceptorMock2});
-        interceptorControl.expectAndReturn(interceptorMock1.handleRequest(null), true);
-        interceptorControl.expectAndReturn(interceptorMock2.handleRequest(null), true);
-        interceptorControl.expectAndReturn(interceptorMock2.handleResponse(null), true);
-        interceptorControl.expectAndReturn(interceptorMock1.handleResponse(null), true);
-        interceptorControl.replay();
+        expect(interceptorMock1.handleRequest(isA(MessageContext.class))).andReturn(true);
+        expect(interceptorMock2.handleRequest(isA(MessageContext.class))).andReturn(true);
+        expect(interceptorMock2.handleResponse(isA(MessageContext.class))).andReturn(true);
+        expect(interceptorMock1.handleResponse(isA(MessageContext.class))).andReturn(true);
 
-        MockControl callbackControl = MockControl.createControl(WebServiceMessageCallback.class);
-        WebServiceMessageCallback requestCallback = (WebServiceMessageCallback) callbackControl.getMock();
-        requestCallback.doWithMessage(null);
-        callbackControl.setMatcher(MockControl.ALWAYS_MATCHER);
-        callbackControl.replay();
+        WebServiceMessageCallback requestCallback = createMock(WebServiceMessageCallback.class);
+        requestCallback.doWithMessage(isA(WebServiceMessage.class));
 
-        MockControl extractorControl = MockControl.createControl(WebServiceMessageExtractor.class);
-        WebServiceMessageExtractor extractorMock = (WebServiceMessageExtractor) extractorControl.getMock();
-        extractorMock.extractData(null);
-        extractorControl.setMatcher(MockControl.ALWAYS_MATCHER);
+        WebServiceMessageExtractor extractorMock = createMock(WebServiceMessageExtractor.class);
         Object extracted = new Object();
-        extractorControl.setReturnValue(extracted);
-        extractorControl.replay();
+        expect(extractorMock.extractData(isA(WebServiceMessage.class))).andReturn(extracted);
 
-        connectionMock.send(null);
-        connectionControl.setMatcher(MockControl.ALWAYS_MATCHER);
-        connectionControl.expectAndReturn(connectionMock.hasError(), false);
-        connectionControl
-                .expectAndReturn(connectionMock.receive(messageFactory), new MockWebServiceMessage("<response/>"));
-        connectionControl.expectAndReturn(connectionMock.hasFault(), false);
+        connectionMock.send(isA(WebServiceMessage.class));
+        expect(connectionMock.hasError()).andReturn(false);
+        expect(connectionMock.receive(messageFactory)).andReturn(new MockWebServiceMessage("<response/>"));
+        expect(connectionMock.hasFault()).andReturn(false);
         connectionMock.close();
-        connectionControl.replay();
+
+        replay(connectionMock, interceptorMock1, interceptorMock2, requestCallback, extractorMock);
 
         Object result = template.sendAndReceive(requestCallback, extractorMock);
-        assertEquals("Invalid response", extracted, result);
+        Assert.assertEquals("Invalid response", extracted, result);
 
-        callbackControl.verify();
-        extractorControl.verify();
-        connectionControl.verify();
-        interceptorControl.verify();
+        verify(connectionMock, interceptorMock1, interceptorMock2, requestCallback, extractorMock);
     }
 
+    @Test
     public void testInterceptorsIntercepted() throws Exception {
         MessageContext messageContext = new DefaultMessageContext(messageFactory);
 
-        MockControl interceptorControl = MockControl.createControl(ClientInterceptor.class);
-        ClientInterceptor interceptorMock1 = (ClientInterceptor) interceptorControl.getMock();
-        ClientInterceptor interceptorMock2 = (ClientInterceptor) interceptorControl.getMock();
+        ClientInterceptor interceptorMock1 = createStrictMock("interceptor1", ClientInterceptor.class);
+        ClientInterceptor interceptorMock2 = createStrictMock("interceptor2", ClientInterceptor.class);
         template.setInterceptors(new ClientInterceptor[]{interceptorMock1, interceptorMock2});
-        interceptorControl.expectAndReturn(interceptorMock1.handleRequest(messageContext), false);
-        interceptorControl.expectAndReturn(interceptorMock1.handleResponse(messageContext), true);
-        interceptorControl.replay();
+        expect(interceptorMock1.handleRequest(isA(MessageContext.class))).andReturn(false);
+        expect(interceptorMock1.handleResponse(isA(MessageContext.class))).andReturn(true);
 
-        MockControl callbackControl = MockControl.createControl(WebServiceMessageCallback.class);
-        WebServiceMessageCallback requestCallback = (WebServiceMessageCallback) callbackControl.getMock();
+        WebServiceMessageCallback requestCallback = createMock(WebServiceMessageCallback.class);
         requestCallback.doWithMessage(messageContext.getRequest());
-        callbackControl.replay();
 
-        MockControl extractorControl = MockControl.createControl(WebServiceMessageExtractor.class);
-        WebServiceMessageExtractor extractorMock = (WebServiceMessageExtractor) extractorControl.getMock();
-        extractorMock.extractData(null);
-        extractorControl.setMatcher(MockControl.ALWAYS_MATCHER);
+        WebServiceMessageExtractor extractorMock = createMock(WebServiceMessageExtractor.class);
         Object extracted = new Object();
-        extractorControl.setReturnValue(extracted);
-        extractorControl.replay();
+        expect(extractorMock.extractData(isA(WebServiceMessage.class))).andReturn(extracted);
 
-        connectionMock.send(messageContext.getRequest());
-        connectionControl.expectAndReturn(connectionMock.hasError(), false);
-        connectionControl
-                .expectAndReturn(connectionMock.receive(messageFactory), new MockWebServiceMessage("<response/>"));
-        connectionControl.expectAndReturn(connectionMock.hasFault(), false);
-        connectionControl.replay();
+        connectionMock.send(isA(WebServiceMessage.class));
+        expect(connectionMock.hasError()).andReturn(false);
+        expect(connectionMock.receive(messageFactory)).andReturn(new MockWebServiceMessage("<response/>"));
+        expect(connectionMock.hasFault()).andReturn(false);
+        connectionMock.close();
+
+        replay(connectionMock, interceptorMock1, interceptorMock2, requestCallback, extractorMock);
 
         Object result = template.doSendAndReceive(messageContext, connectionMock, requestCallback, extractorMock);
-        assertEquals("Invalid response", extracted, result);
+        Assert.assertEquals("Invalid response", extracted, result);
 
-        callbackControl.verify();
-        extractorControl.verify();
-        connectionControl.verify();
-        interceptorControl.verify();
+        verify(connectionMock, interceptorMock1, interceptorMock2, requestCallback, extractorMock);
     }
 
+    @Test
     public void testInterceptorsInterceptedCreateResponse() throws Exception {
         MessageContext messageContext = new DefaultMessageContext(messageFactory);
         // force creation of response
         messageContext.getResponse();
 
-        MockControl interceptorControl = MockControl.createControl(ClientInterceptor.class);
-        ClientInterceptor interceptorMock1 = (ClientInterceptor) interceptorControl.getMock();
-        ClientInterceptor interceptorMock2 = (ClientInterceptor) interceptorControl.getMock();
+        ClientInterceptor interceptorMock1 = createStrictMock("interceptor1", ClientInterceptor.class);
+        ClientInterceptor interceptorMock2 = createStrictMock("interceptor2", ClientInterceptor.class);
         template.setInterceptors(new ClientInterceptor[]{interceptorMock1, interceptorMock2});
-        interceptorControl.expectAndReturn(interceptorMock1.handleRequest(messageContext), false);
-        interceptorControl.expectAndReturn(interceptorMock1.handleResponse(messageContext), true);
-        interceptorControl.replay();
+        expect(interceptorMock1.handleRequest(isA(MessageContext.class))).andReturn(false);
+        expect(interceptorMock1.handleResponse(isA(MessageContext.class))).andReturn(true);
 
-        MockControl callbackControl = MockControl.createControl(WebServiceMessageCallback.class);
-        WebServiceMessageCallback requestCallback = (WebServiceMessageCallback) callbackControl.getMock();
+        WebServiceMessageCallback requestCallback = createMock(WebServiceMessageCallback.class);
         requestCallback.doWithMessage(messageContext.getRequest());
-        callbackControl.replay();
 
-        MockControl extractorControl = MockControl.createControl(WebServiceMessageExtractor.class);
-        WebServiceMessageExtractor extractorMock = (WebServiceMessageExtractor) extractorControl.getMock();
+        WebServiceMessageExtractor extractorMock = createMock(WebServiceMessageExtractor.class);
         Object extracted = new Object();
-        extractorControl.expectAndReturn(extractorMock.extractData(messageContext.getResponse()), extracted);
-        extractorControl.replay();
+        expect(extractorMock.extractData(messageContext.getResponse())).andReturn(extracted);
 
-        connectionControl.expectAndReturn(connectionMock.hasFault(), false);
-        connectionControl.replay();
+        expect(connectionMock.hasFault()).andReturn(false);
+
+        replay(connectionMock, interceptorMock1, interceptorMock2, requestCallback, extractorMock);
 
         Object result = template.doSendAndReceive(messageContext, connectionMock, requestCallback, extractorMock);
-        assertEquals("Invalid response", extracted, result);
+        Assert.assertEquals("Invalid response", extracted, result);
 
-        callbackControl.verify();
-        extractorControl.verify();
-        connectionControl.verify();
-        interceptorControl.verify();
+        verify(connectionMock, interceptorMock1, interceptorMock2, requestCallback, extractorMock);
     }
 
+    @Test
     public void testDestinationResolver() throws Exception {
-        MockControl providerControl = MockControl.createControl(DestinationProvider.class);
-        DestinationProvider providerMock = (DestinationProvider) providerControl.getMock();
-        final URI providerUri = new URI("http://www.springframework.org/spring-ws/destinationProvider");
-        providerControl.expectAndReturn(providerMock.getDestination(), providerUri);
+        DestinationProvider providerMock = createMock(DestinationProvider.class);
         template.setDestinationProvider(providerMock);
-        providerControl.replay();
+        final URI providerUri = new URI("http://www.springframework.org/spring-ws/destinationProvider");
+        expect(providerMock.getDestination()).andReturn(providerUri);
 
         template.setMessageSender(new WebServiceMessageSender() {
 
@@ -522,29 +456,26 @@ public class WebServiceTemplateTest extends XMLTestCase {
             }
 
             public boolean supports(URI uri) {
-                assertEquals("Invalid uri", providerUri, uri);
+                Assert.assertEquals("Invalid uri", providerUri, uri);
                 return true;
             }
         });
 
-        MockControl extractorControl = MockControl.createControl(WebServiceMessageExtractor.class);
-        WebServiceMessageExtractor extractorMock = (WebServiceMessageExtractor) extractorControl.getMock();
-        extractorControl.replay();
+        WebServiceMessageExtractor extractorMock = createMock(WebServiceMessageExtractor.class);
 
-        connectionControl.reset();
-        connectionControl.expectAndDefaultReturn(connectionMock.getUri(), providerUri);
-        connectionMock.send(null);
-        connectionControl.setMatcher(MockControl.ALWAYS_MATCHER);
-        connectionControl.expectAndReturn(connectionMock.hasError(), false);
-        connectionControl.expectAndReturn(connectionMock.receive(messageFactory), null);
+        reset(connectionMock);
+        expect(connectionMock.getUri()).andReturn(providerUri);
+        connectionMock.send(isA(WebServiceMessage.class));
+        expect(connectionMock.hasError()).andReturn(false);
+        expect(connectionMock.receive(messageFactory)).andReturn(null);
         connectionMock.close();
-        connectionControl.replay();
+
+        replay(connectionMock, extractorMock, providerMock);
 
         Object result = template.sendAndReceive(null, extractorMock);
-        assertNull("Invalid response", result);
-        extractorControl.verify();
-        connectionControl.verify();
-        providerControl.verify();
+        Assert.assertNull("Invalid response", result);
+
+        verify(connectionMock, extractorMock, providerMock);
     }
 
 

core/src/test/java/org/springframework/ws/client/support/destination/Wsdl11DestinationProviderTest.java

@@ -19,38 +19,43 @@ package org.springframework.ws.client.support.destination;
 import java.net.URI;
 import java.net.URISyntaxException;
 
-import junit.framework.TestCase;
-
 import org.springframework.core.io.ClassPathResource;
 import org.springframework.core.io.Resource;
 
-public class Wsdl11DestinationProviderTest extends TestCase {
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+public class Wsdl11DestinationProviderTest {
 
     private Wsdl11DestinationProvider provider;
 
-    @Override
-    protected void setUp() throws Exception {
+    @Before
+    public void setUp() throws Exception {
         provider = new Wsdl11DestinationProvider();
     }
 
+    @Test
     public void testSimple() throws URISyntaxException {
         Resource wsdl = new ClassPathResource("simple.wsdl", getClass());
         provider.setWsdl(wsdl);
 
         URI result = provider.getDestination();
 
-        assertEquals("Invalid URI returned", new URI("http://example.com/myService"), result);
+        Assert.assertEquals("Invalid URI returned", new URI("http://example.com/myService"), result);
     }
 
+    @Test
     public void testComplex() throws URISyntaxException {
         Resource wsdl = new ClassPathResource("complex.wsdl", getClass());
         provider.setWsdl(wsdl);
 
         URI result = provider.getDestination();
 
-        assertEquals("Invalid URI returned", new URI("http://example.com/soap11"), result);
+        Assert.assertEquals("Invalid URI returned", new URI("http://example.com/soap11"), result);
     }
 
+    @Test
     public void testCustomExpression() throws URISyntaxException {
         provider.setLocationExpression("/wsdl:definitions/wsdl:service/wsdl:port/soap12:address/@location");
         Resource wsdl = new ClassPathResource("complex.wsdl", getClass());
@@ -58,6 +63,6 @@ public class Wsdl11DestinationProviderTest extends TestCase {
 
         URI result = provider.getDestination();
 
-        assertEquals("Invalid URI returned", new URI("http://example.com/soap12"), result);
+        Assert.assertEquals("Invalid URI returned", new URI("http://example.com/soap12"), result);
     }
 }

core/src/test/java/org/springframework/ws/client/support/interceptor/PayloadValidatingInterceptorTest.java

@@ -25,8 +25,6 @@ import javax.xml.transform.Transformer;
 import javax.xml.transform.TransformerFactory;
 import javax.xml.transform.stream.StreamSource;
 
-import org.custommonkey.xmlunit.XMLTestCase;
-
 import org.springframework.core.io.ClassPathResource;
 import org.springframework.core.io.Resource;
 import org.springframework.ws.MockWebServiceMessage;
@@ -40,7 +38,11 @@ import org.springframework.ws.soap.saaj.SaajSoapMessageFactory;
 import org.springframework.ws.soap.saaj.support.SaajUtils;
 import org.springframework.xml.xsd.SimpleXsdSchema;
 
-public class PayloadValidatingInterceptorTest extends XMLTestCase {
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+public class PayloadValidatingInterceptorTest {
 
     private PayloadValidatingInterceptor interceptor;
 
@@ -64,8 +66,8 @@ public class PayloadValidatingInterceptorTest extends XMLTestCase {
 
     private static final String SCHEMA2 = "schema2.xsd";
 
-    @Override
-    protected void setUp() throws Exception {
+    @Before
+    public void setUp() throws Exception {
         interceptor = new PayloadValidatingInterceptor();
         interceptor.setSchema(new ClassPathResource(SCHEMA, getClass()));
         interceptor.setValidateRequest(true);
@@ -77,6 +79,7 @@ public class PayloadValidatingInterceptorTest extends XMLTestCase {
         transformer = TransformerFactory.newInstance().newTransformer();
     }
 
+    @Test
     public void testHandleInvalidRequest() throws Exception {
         SoapMessage invalidMessage = (SoapMessage) soap11Factory.createWebServiceMessage();
         InputStream inputStream = getClass().getResourceAsStream(INVALID_MESSAGE);
@@ -89,11 +92,12 @@ public class PayloadValidatingInterceptorTest extends XMLTestCase {
         }
         catch (WebServiceClientException e) {
             validated = false;
-            assertNotNull("No exception details provided in WebServiceClientException", e.getMessage());
+            Assert.assertNotNull("No exception details provided in WebServiceClientException", e.getMessage());
         }
-        assertFalse("Invalid response from interceptor", validated);
+        Assert.assertFalse("Invalid response from interceptor", validated);
     }
 
+    @Test
     public void testHandlerInvalidRequest() throws Exception {
         MockWebServiceMessage request = new MockWebServiceMessage();
         request.setPayload(new ClassPathResource(INVALID_MESSAGE, getClass()));
@@ -105,20 +109,22 @@ public class PayloadValidatingInterceptorTest extends XMLTestCase {
         }
         catch (WebServiceClientException e) {
             validated = false;
-            assertNotNull("No exception details provided in WebServiceClientException", e.getMessage());
+            Assert.assertNotNull("No exception details provided in WebServiceClientException", e.getMessage());
         }
-        assertFalse("Invalid response from interceptor", validated);
+        Assert.assertFalse("Invalid response from interceptor", validated);
     }
 
+    @Test
     public void testHandleValidRequest() throws Exception {
         MockWebServiceMessage request = new MockWebServiceMessage();
         request.setPayload(new ClassPathResource(VALID_MESSAGE, getClass()));
         context = new DefaultMessageContext(request, new MockWebServiceMessageFactory());
         boolean result = interceptor.handleRequest(context);
-        assertTrue("Invalid response from interceptor", result);
-        assertFalse("Response set", context.hasResponse());
+        Assert.assertTrue("Invalid response from interceptor", result);
+        Assert.assertFalse("Response set", context.hasResponse());
     }
 
+    @Test
     public void testHandleInvalidResponse() throws Exception {
         MockWebServiceMessage request = new MockWebServiceMessage();
         context = new DefaultMessageContext(request, new MockWebServiceMessageFactory());
@@ -126,18 +132,20 @@ public class PayloadValidatingInterceptorTest extends XMLTestCase {
         response.setPayload(new ClassPathResource(INVALID_MESSAGE, getClass()));
 
         boolean result = interceptor.handleResponse(context);
-        assertFalse("Invalid response from interceptor", result);
+        Assert.assertFalse("Invalid response from interceptor", result);
     }
 
+    @Test
     public void testHandleValidResponse() throws Exception {
         MockWebServiceMessage request = new MockWebServiceMessage();
         context = new DefaultMessageContext(request, new MockWebServiceMessageFactory());
         MockWebServiceMessage response = (MockWebServiceMessage) context.getResponse();
         response.setPayload(new ClassPathResource(VALID_MESSAGE, getClass()));
         boolean result = interceptor.handleResponse(context);
-        assertTrue("Invalid response from interceptor", result);
+        Assert.assertTrue("Invalid response from interceptor", result);
     }
 
+    @Test
     public void testNamespacesInType() throws Exception {
         // Make sure we use Xerces for this testcase: the JAXP implementation used internally by JDK 1.5 has a bug
         // See http://opensource.atlassian.com/projects/spring/browse/SWS-35
@@ -156,8 +164,8 @@ public class PayloadValidatingInterceptorTest extends XMLTestCase {
                     new SaajSoapMessageFactory(messageFactory));
 
             boolean result = interceptor.handleRequest(context);
-            assertTrue("Invalid response from interceptor", result);
-            assertFalse("Response set", context.hasResponse());
+            Assert.assertTrue("Invalid response from interceptor", result);
+            Assert.assertFalse("Response set", context.hasResponse());
         }
         finally {
             // Reset the property
@@ -166,17 +174,19 @@ public class PayloadValidatingInterceptorTest extends XMLTestCase {
         }
     }
 
+    @Test
     public void testNonExistingSchema() throws Exception {
         try {
             interceptor.setSchema(new ClassPathResource("invalid"));
             interceptor.afterPropertiesSet();
-            fail("IllegalArgumentException expected");
+            Assert.fail("IllegalArgumentException expected");
         }
         catch (IllegalArgumentException ex) {
             // expected
         }
     }
 
+    @Test
     public void testHandlerInvalidRequestMultipleSchemas() throws Exception {
         interceptor.setSchemas(new Resource[]{new ClassPathResource(PRODUCT_SCHEMA, getClass()),
                 new ClassPathResource(SIZE_SCHEMA, getClass())});
@@ -190,11 +200,12 @@ public class PayloadValidatingInterceptorTest extends XMLTestCase {
         }
         catch (WebServiceClientException e) {
             validated = false;
-            assertNotNull("No exception details provided in WebServiceClientException", e.getMessage());
+            Assert.assertNotNull("No exception details provided in WebServiceClientException", e.getMessage());
         }
-        assertFalse("Invalid response from interceptor", validated);
+        Assert.assertFalse("Invalid response from interceptor", validated);
     }
 
+    @Test
     public void testHandleValidRequestMultipleSchemas() throws Exception {
         interceptor.setSchemas(new Resource[]{new ClassPathResource(PRODUCT_SCHEMA, getClass()),
                 new ClassPathResource(SIZE_SCHEMA, getClass())});
@@ -203,10 +214,11 @@ public class PayloadValidatingInterceptorTest extends XMLTestCase {
         context = new DefaultMessageContext(request, new MockWebServiceMessageFactory());
 
         boolean result = interceptor.handleRequest(context);
-        assertTrue("Invalid response from interceptor", result);
-        assertFalse("Response set", context.hasResponse());
+        Assert.assertTrue("Invalid response from interceptor", result);
+        Assert.assertFalse("Response set", context.hasResponse());
     }
 
+    @Test
     public void testHandleInvalidResponseMultipleSchemas() throws Exception {
         interceptor.setSchemas(new Resource[]{new ClassPathResource(PRODUCT_SCHEMA, getClass()),
                 new ClassPathResource(SIZE_SCHEMA, getClass())});
@@ -216,9 +228,10 @@ public class PayloadValidatingInterceptorTest extends XMLTestCase {
         MockWebServiceMessage response = (MockWebServiceMessage) context.getResponse();
         response.setPayload(new ClassPathResource(INVALID_MESSAGE, getClass()));
         boolean result = interceptor.handleResponse(context);
-        assertFalse("Invalid response from interceptor", result);
+        Assert.assertFalse("Invalid response from interceptor", result);
     }
 
+    @Test
     public void testHandleValidResponseMultipleSchemas() throws Exception {
         interceptor.setSchemas(new Resource[]{new ClassPathResource(PRODUCT_SCHEMA, getClass()),
                 new ClassPathResource(SIZE_SCHEMA, getClass())});
@@ -228,9 +241,10 @@ public class PayloadValidatingInterceptorTest extends XMLTestCase {
         MockWebServiceMessage response = (MockWebServiceMessage) context.getResponse();
         response.setPayload(new ClassPathResource(VALID_MESSAGE, getClass()));
         boolean result = interceptor.handleResponse(context);
-        assertTrue("Invalid response from interceptor", result);
+        Assert.assertTrue("Invalid response from interceptor", result);
     }
 
+    @Test
     public void testXsdSchema() throws Exception {
         PayloadValidatingInterceptor interceptor = new PayloadValidatingInterceptor();
         SimpleXsdSchema schema = new SimpleXsdSchema(new ClassPathResource(SCHEMA, getClass()));
@@ -243,7 +257,7 @@ public class PayloadValidatingInterceptorTest extends XMLTestCase {
         request.setPayload(new ClassPathResource(VALID_MESSAGE, getClass()));
         context = new DefaultMessageContext(request, new MockWebServiceMessageFactory());
         boolean result = interceptor.handleRequest(context);
-        assertTrue("Invalid response from interceptor", result);
-        assertFalse("Response set", context.hasResponse());
+        Assert.assertTrue("Invalid response from interceptor", result);
+        Assert.assertFalse("Response set", context.hasResponse());
     }
 }

core/src/test/java/org/springframework/ws/config/WebServiceNamespaceHandlerTest.java

@@ -18,23 +18,26 @@ package org.springframework.ws.config;
 
 import java.util.Map;
 
-import junit.framework.TestCase;
-
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.support.ClassPathXmlApplicationContext;
 import org.springframework.ws.server.endpoint.adapter.MarshallingMethodEndpointAdapter;
 
-public class WebServiceNamespaceHandlerTest extends TestCase {
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+public class WebServiceNamespaceHandlerTest {
 
     private ApplicationContext applicationContext;
 
-    @Override
-    protected void setUp() throws Exception {
+    @Before
+    public void setUp() throws Exception {
         applicationContext = new ClassPathXmlApplicationContext("webServiceNamespaceHandlerTest.xml", getClass());
     }
 
+    @Test
     public void testMarshallingMethods() throws Exception {
-        Map result = applicationContext.getBeansOfType(MarshallingMethodEndpointAdapter.class);
-        assertFalse("no MarshallingMethodEndpointAdapter found", result.isEmpty());
+        Map<String, MarshallingMethodEndpointAdapter> result = applicationContext.getBeansOfType(MarshallingMethodEndpointAdapter.class);
+        Assert.assertFalse("no MarshallingMethodEndpointAdapter found", result.isEmpty());
     }
 }

core/src/test/java/org/springframework/ws/config/WebServicesNamespaceHandlerTigerTest.java

@@ -18,30 +18,36 @@ package org.springframework.ws.config;
 
 import java.util.Map;
 
-import junit.framework.TestCase;
-
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.support.ClassPathXmlApplicationContext;
 import org.springframework.ws.server.endpoint.adapter.GenericMarshallingMethodEndpointAdapter;
 import org.springframework.ws.server.endpoint.adapter.XPathParamAnnotationMethodEndpointAdapter;
 
-public class WebServicesNamespaceHandlerTigerTest extends TestCase {
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+public class WebServicesNamespaceHandlerTigerTest {
 
     private ApplicationContext applicationContext;
 
-    @Override
-    protected void setUp() throws Exception {
+    @Before
+    public void setUp() throws Exception {
         applicationContext =
                 new ClassPathXmlApplicationContext("webServicesNamespaceHandlerTest-tiger.xml", getClass());
     }
 
+    @Test
     public void testMarshallingEndpoints() throws Exception {
-        Map result = applicationContext.getBeansOfType(GenericMarshallingMethodEndpointAdapter.class);
-        assertFalse("no MarshallingMethodEndpointAdapter found", result.isEmpty());
+        Map<String, GenericMarshallingMethodEndpointAdapter> result =
+                applicationContext.getBeansOfType(GenericMarshallingMethodEndpointAdapter.class);
+        Assert.assertFalse("no MarshallingMethodEndpointAdapter found", result.isEmpty());
     }
 
+    @Test
     public void testXpathEndpoints() throws Exception {
-        Map result = applicationContext.getBeansOfType(XPathParamAnnotationMethodEndpointAdapter.class);
-        assertFalse("no XPathParamAnnotationMethodEndpointAdapter found", result.isEmpty());
+        Map<String, XPathParamAnnotationMethodEndpointAdapter> result =
+                applicationContext.getBeansOfType(XPathParamAnnotationMethodEndpointAdapter.class);
+        Assert.assertFalse("no XPathParamAnnotationMethodEndpointAdapter found", result.isEmpty());
     }
 }

core/src/test/java/org/springframework/ws/context/DefaultMessageContextTest.java

@@ -18,57 +18,61 @@ package org.springframework.ws.context;
 
 import java.util.Arrays;
 
-import junit.framework.TestCase;
-import org.easymock.MockControl;
 import org.springframework.ws.MockWebServiceMessage;
 import org.springframework.ws.WebServiceMessage;
 import org.springframework.ws.WebServiceMessageFactory;
 
-public class DefaultMessageContextTest extends TestCase {
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.easymock.EasyMock.*;
+
+public class DefaultMessageContextTest {
 
     private DefaultMessageContext context;
 
-    private MockControl factoryControl;
-
     private WebServiceMessageFactory factoryMock;
 
     private WebServiceMessage request;
 
-    @Override
-    protected void setUp() throws Exception {
-        factoryControl = MockControl.createControl(WebServiceMessageFactory.class);
-        factoryMock = (WebServiceMessageFactory) factoryControl.getMock();
+    @Before
+    public void setUp() throws Exception {
+        factoryMock = createMock(WebServiceMessageFactory.class);
         request = new MockWebServiceMessage();
         context = new DefaultMessageContext(request, factoryMock);
     }
 
+    @Test
     public void testRequest() throws Exception {
-        assertEquals("Invalid request returned", request, context.getRequest());
+        Assert.assertEquals("Invalid request returned", request, context.getRequest());
     }
 
+    @Test
     public void testResponse() throws Exception {
         WebServiceMessage response = new MockWebServiceMessage();
-        factoryControl.expectAndReturn(factoryMock.createWebServiceMessage(), response);
-        factoryControl.replay();
+        expect(factoryMock.createWebServiceMessage()).andReturn(response);
+        replay(factoryMock);
 
         WebServiceMessage result = context.getResponse();
-        assertEquals("Invalid response returned", response, result);
-        factoryControl.verify();
+        Assert.assertEquals("Invalid response returned", response, result);
+        verify(factoryMock);
     }
 
+    @Test
     public void testProperties() throws Exception {
-        assertEquals("Invalid property names returned", 0, context.getPropertyNames().length);
+        Assert.assertEquals("Invalid property names returned", 0, context.getPropertyNames().length);
         String name = "name";
-        assertFalse("Property set", context.containsProperty(name));
+        Assert.assertFalse("Property set", context.containsProperty(name));
         String value = "value";
         context.setProperty(name, value);
-        assertTrue("Property not set", context.containsProperty(name));
-        assertEquals("Invalid property names returned", Arrays.asList(new String[]{name}),
+        Assert.assertTrue("Property not set", context.containsProperty(name));
+        Assert.assertEquals("Invalid property names returned", Arrays.asList(name),
                 Arrays.asList(context.getPropertyNames()));
-        assertEquals("Invalid property value returned", value, context.getProperty(name));
+        Assert.assertEquals("Invalid property value returned", value, context.getProperty(name));
         context.removeProperty(name);
-        assertFalse("Property set", context.containsProperty(name));
-        assertEquals("Invalid property names returned", 0, context.getPropertyNames().length);
+        Assert.assertFalse("Property set", context.containsProperty(name));
+        Assert.assertEquals("Invalid property names returned", 0, context.getPropertyNames().length);
     }
 
 }

core/src/test/java/org/springframework/ws/pox/dom/DomPoxMessageTest.java

@@ -22,22 +22,23 @@ import javax.xml.parsers.DocumentBuilderFactory;
 import javax.xml.transform.Transformer;
 import javax.xml.transform.TransformerFactory;
 
-import org.custommonkey.xmlunit.XMLTestCase;
-import org.w3c.dom.Document;
-
 import org.springframework.xml.transform.StringResult;
 import org.springframework.xml.transform.StringSource;
 
-public class DomPoxMessageTest extends XMLTestCase {
+import org.junit.Before;
+import org.junit.Test;
+import org.w3c.dom.Document;
 
-    public static final String NAMESPACE = "http://www.springframework.org/spring-ws";
+import static org.custommonkey.xmlunit.XMLAssert.assertXMLEqual;
+
+public class DomPoxMessageTest {
 
     private DomPoxMessage message;
 
     private Transformer transformer;
 
-    @Override
-    protected void setUp() throws Exception {
+    @Before
+    public void setUp() throws Exception {
         DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
         DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
         Document document = documentBuilder.newDocument();
@@ -46,6 +47,7 @@ public class DomPoxMessageTest extends XMLTestCase {
         message = new DomPoxMessage(document, transformer, DomPoxMessageFactory.DEFAULT_CONTENT_TYPE);
     }
 
+    @Test
     public void testGetPayload() throws Exception {
         String content = "<root xmlns='http://www.springframework.org/spring-ws'>" + "<child/></root>";
         StringSource source = new StringSource(content);
@@ -55,6 +57,7 @@ public class DomPoxMessageTest extends XMLTestCase {
         assertXMLEqual(content, stringResult.toString());
     }
 
+    @Test
     public void testGetPayloadResultTwice() throws Exception {
         String content = "<element xmlns=\"http://www.springframework.org/spring-ws\" />";
         transformer.transform(new StringSource(content), message.getPayloadResult());
@@ -64,6 +67,7 @@ public class DomPoxMessageTest extends XMLTestCase {
         assertXMLEqual(content, stringResult.toString());
     }
 
+    @Test
     public void testWriteTo() throws Exception {
         String content = "<root xmlns='http://www.springframework.org/spring-ws'>" + "<child/></root>";
         StringSource source = new StringSource(content);

parent/pom.xml

@@ -746,7 +746,7 @@
                 <groupId>org.easymock</groupId>
                 <artifactId>easymock</artifactId>
                 <scope>test</scope>
-                <version>2.2</version>
+                <version>2.5.2</version>
             </dependency>
         </dependencies>
     </dependencyManagement>