Merge from sbrannen/SPR-8032

* SPR-8032:
  Introduce TCP & UDP server port scanning utility

spring-core/src/main/java/org/springframework/util/SocketUtils.java

+/*
+ * Copyright 2002-2013 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.util;
+
+import java.net.DatagramSocket;
+import java.net.ServerSocket;
+import java.util.Random;
+import java.util.SortedSet;
+import java.util.TreeSet;
+
+import javax.net.ServerSocketFactory;
+
+/**
+ * Simple utility methods for working with network sockets — for example,
+ * for finding available ports on {@code localhost}.
+ *
+ * <p>Within this class, a TCP port refers to a port for a {@link ServerSocket};
+ * whereas, a UDP port refers to a port for a {@link DatagramSocket}. 
+ *
+ * @author Sam Brannen
+ * @author Ben Hale
+ * @author Arjen Poutsma
+ * @author Gunnar Hillert
+ * @since 4.0
+ */
+public final class SocketUtils {
+
+	/**
+	 * The default minimum value for port ranges used when finding an available
+	 * socket port.
+	 */
+	public static final int PORT_RANGE_MIN = 1024;
+
+	/**
+	 * The default maximum value for port ranges used when finding an available
+	 * socket port.
+	 */
+	public static final int PORT_RANGE_MAX = 65535;
+
+	private static final Random random = new Random(System.currentTimeMillis());
+
+
+	/**
+	 * Although {@code SocketUtils} consists solely of static utility methods,
+	 * this constructor is intentionally {@code public}.
+	 * 
+	 * <h4>Rationale</h4>
+	 *
+	 * <p>Static methods from this class may be invoked from within XML
+	 * configuration files using the Spring Expression Language (SpEL) and the
+	 * following syntax.
+	 *
+	 * <pre><code>&lt;bean id="bean1" ... p:port="#{T(org.springframework.util.SocketUtils).findAvailableTcpPort(12000)}" /&gt;</code></pre>
+	 *
+	 * If this constructor were {@code private}, you would be required to supply
+	 * the fully qualified class name to SpEL's {@code T()} function for each usage.
+	 * Thus, the fact that this constructor is {@code public} allows you to reduce
+	 * boilerplate configuration with SpEL as can be seen in the following example.
+	 *
+	 * <pre><code>&lt;bean id="socketUtils" class="org.springframework.util.SocketUtils" /&gt;
+	 *
+	 *&lt;bean id="bean1" ... p:port="#{socketUtils.findAvailableTcpPort(12000)}" /&gt;
+	 *
+	 *&lt;bean id="bean2" ... p:port="#{socketUtils.findAvailableTcpPort(30000)}" /&gt;</code></pre>
+	 */
+	public SocketUtils() {
+		/* no-op */
+	}
+
+	/**
+	 * Find an available TCP port randomly selected from the range
+	 * [{@value #PORT_RANGE_MIN}, {@value #PORT_RANGE_MAX}].
+	 *
+	 * @return an available TCP port number
+	 * @throws IllegalStateException if no available port could be found
+	 */
+	public static int findAvailableTcpPort() {
+		return findAvailableTcpPort(PORT_RANGE_MIN);
+	}
+
+	/**
+	 * Find an available TCP port randomly selected from the range
+	 * [{@code minPort}, {@value #PORT_RANGE_MAX}].
+	 *
+	 * @param minPort the minimum port number
+	 * @return an available TCP port number
+	 * @throws IllegalStateException if no available port could be found
+	 */
+	public static int findAvailableTcpPort(int minPort) {
+		return findAvailableTcpPort(minPort, PORT_RANGE_MAX);
+	}
+
+	/**
+	 * Find an available TCP port randomly selected from the range
+	 * [{@code minPort}, {@code maxPort}].
+	 *
+	 * @param minPort the minimum port number
+	 * @param maxPort the maximum port number
+	 * @return an available TCP port number
+	 * @throws IllegalStateException if no available port could be found
+	 */
+	public static int findAvailableTcpPort(int minPort, int maxPort) {
+		return SocketType.TCP.findAvailablePort(minPort, maxPort);
+	}
+
+	/**
+	 * Find the requested number of available TCP ports, each randomly selected
+	 * from the range [{@value #PORT_RANGE_MIN}, {@value #PORT_RANGE_MAX}].
+	 *
+	 * @param numRequested the number of available ports to find
+	 * @return a sorted set of available TCP port numbers
+	 * @throws IllegalStateException if the requested number of available ports could not be found
+	 */
+	public static SortedSet<Integer> findAvailableTcpPorts(int numRequested) {
+		return findAvailableTcpPorts(numRequested, PORT_RANGE_MIN, PORT_RANGE_MAX);
+	}
+
+	/**
+	 * Find the requested number of available TCP ports, each randomly selected
+	 * from the range [{@code minPort}, {@code maxPort}].
+	 *
+	 * @param numRequested the number of available ports to find
+	 * @param minPort the minimum port number
+	 * @param maxPort the maximum port number
+	 * @return a sorted set of available TCP port numbers
+	 * @throws IllegalStateException if the requested number of available ports could not be found
+	 */
+	public static SortedSet<Integer> findAvailableTcpPorts(int numRequested, int minPort, int maxPort) {
+		return SocketType.TCP.findAvailablePorts(numRequested, minPort, maxPort);
+	}
+
+	/**
+	 * Find an available UDP port randomly selected from the range
+	 * [{@value #PORT_RANGE_MIN}, {@value #PORT_RANGE_MAX}].
+	 *
+	 * @return an available UDP port number
+	 * @throws IllegalStateException if no available port could be found
+	 */
+	public static int findAvailableUdpPort() {
+		return findAvailableUdpPort(PORT_RANGE_MIN);
+	}
+
+	/**
+	 * Find an available UDP port randomly selected from the range
+	 * [{@code minPort}, {@value #PORT_RANGE_MAX}].
+	 *
+	 * @param minPort the minimum port number
+	 * @return an available UDP port number
+	 * @throws IllegalStateException if no available port could be found
+	 */
+	public static int findAvailableUdpPort(int minPort) {
+		return findAvailableUdpPort(minPort, PORT_RANGE_MAX);
+	}
+
+	/**
+	 * Find an available UDP port randomly selected from the range
+	 * [{@code minPort}, {@code maxPort}].
+	 *
+	 * @param minPort the minimum port number
+	 * @param maxPort the maximum port number
+	 * @return an available UDP port number
+	 * @throws IllegalStateException if no available port could be found
+	 */
+	public static int findAvailableUdpPort(int minPort, int maxPort) {
+		return SocketType.UDP.findAvailablePort(minPort, maxPort);
+	}
+
+	/**
+	 * Find the requested number of available UDP ports, each randomly selected
+	 * from the range [{@value #PORT_RANGE_MIN}, {@value #PORT_RANGE_MAX}].
+	 *
+	 * @param numRequested the number of available ports to find
+	 * @return a sorted set of available UDP port numbers
+	 * @throws IllegalStateException if the requested number of available ports could not be found
+	 */
+	public static SortedSet<Integer> findAvailableUdpPorts(int numRequested) {
+		return findAvailableUdpPorts(numRequested, PORT_RANGE_MIN, PORT_RANGE_MAX);
+	}
+
+	/**
+	 * Find the requested number of available UDP ports, each randomly selected
+	 * from the range [{@code minPort}, {@code maxPort}].
+	 *
+	 * @param numRequested the number of available ports to find
+	 * @param minPort the minimum port number
+	 * @param maxPort the maximum port number
+	 * @return a sorted set of available UDP port numbers
+	 * @throws IllegalStateException if the requested number of available ports could not be found
+	 */
+	public static SortedSet<Integer> findAvailableUdpPorts(int numRequested, int minPort, int maxPort) {
+		return SocketType.UDP.findAvailablePorts(numRequested, minPort, maxPort);
+	}
+
+
+	private static enum SocketType {
+
+		TCP {
+
+			@Override
+			protected boolean isPortAvailable(int port) {
+				try {
+					ServerSocket serverSocket = ServerSocketFactory.getDefault().createServerSocket(port);
+					serverSocket.close();
+					return true;
+				}
+				catch (Exception ex) {
+					return false;
+				}
+			}
+		},
+
+		UDP {
+
+			@Override
+			protected boolean isPortAvailable(int port) {
+				try {
+					DatagramSocket socket = new DatagramSocket(port);
+					socket.close();
+					return true;
+				}
+				catch (Exception ex) {
+					return false;
+				}
+			}
+		};
+
+		/**
+		 * Determine if the specified port for this {@code SocketType} is
+		 * currently available on {@code localhost}.
+		 */
+		protected abstract boolean isPortAvailable(int port);
+
+		/**
+		 * Find a pseudo-random port number within the range
+		 * [{@code minPort}, {@code maxPort}].
+		 *
+		 * @param minPort the minimum port number
+		 * @param maxPort the maximum port number
+		 * @return a random port number within the specified range
+		 */
+		private int findRandomPort(int minPort, int maxPort) {
+			int portRange = maxPort - minPort;
+			return minPort + random.nextInt(portRange);
+		}
+
+		/**
+		 * Find an available port for this {@code SocketType}, randomly selected
+		 * from the range [{@code minPort}, {@code maxPort}].
+		 *
+		 * @param minPort the minimum port number
+		 * @param maxPort the maximum port number
+		 * @return an available port number for this socket type
+		 * @throws IllegalStateException if no available port could be found
+		 */
+		int findAvailablePort(int minPort, int maxPort) {
+			Assert.isTrue(minPort > 0, "'minPort' must be greater than 0");
+			Assert.isTrue(maxPort > minPort, "'maxPort' must be greater than 'minPort'");
+			Assert.isTrue(maxPort <= PORT_RANGE_MAX, "'maxPort' must be less than or equal to " + PORT_RANGE_MAX);
+
+			int portRange = maxPort - minPort;
+			int candidatePort;
+			int searchCounter = 0;
+			do {
+				if (++searchCounter > portRange) {
+					throw new IllegalStateException(String.format(
+						"Could not find an available %s port in the range [%d, %d] after %d attempts", name(), minPort,
+						maxPort, searchCounter));
+				}
+				candidatePort = findRandomPort(minPort, maxPort);
+			} while (!isPortAvailable(candidatePort));
+
+			return candidatePort;
+		}
+
+		/**
+		 * Find the requested number of available ports for this {@code SocketType},
+		 * each randomly selected from the range [{@code minPort}, {@code maxPort}].
+		 *
+		 * @param numRequested the number of available ports to find
+		 * @param minPort the minimum port number
+		 * @param maxPort the maximum port number
+		 * @return a sorted set of available port numbers for this socket type
+		 * @throws IllegalStateException if the requested number of available ports could not be found
+		 */
+		SortedSet<Integer> findAvailablePorts(int numRequested, int minPort, int maxPort) {
+			Assert.isTrue(minPort > 0, "'minPort' must be greater than 0");
+			Assert.isTrue(maxPort > minPort, "'maxPort' must be greater than 'minPort'");
+			Assert.isTrue(maxPort <= PORT_RANGE_MAX, "'maxPort' must be less than or equal to " + PORT_RANGE_MAX);
+			Assert.isTrue(numRequested > 0, "'numRequested' must be greater than 0");
+			Assert.isTrue((maxPort - minPort) >= numRequested,
+				"'numRequested' must not be greater than 'maxPort' - 'minPort'");
+
+			final SortedSet<Integer> availablePorts = new TreeSet<Integer>();
+			int attemptCount = 0;
+			while ((++attemptCount <= numRequested + 100) && (availablePorts.size() < numRequested)) {
+				availablePorts.add(findAvailablePort(minPort, maxPort));
+			}
+
+			if (availablePorts.size() != numRequested) {
+				throw new IllegalStateException(String.format(
+					"Could not find %d available %s ports in the range [%d, %d]", numRequested, name(), minPort,
+					maxPort));
+			}
+
+			return availablePorts;
+		}
+	}
+
+}

spring-core/src/test/java/org/springframework/util/SocketUtilsTests.java

+/*
+ * Copyright 2002-2013 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.util;
+
+import java.util.SortedSet;
+
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+import static org.springframework.util.SocketUtils.*;
+
+/**
+ * Unit tests for {@link SocketUtils}.
+ *
+ * @author Sam Brannen
+ * @since 4.0
+ */
+public class SocketUtilsTests {
+
+	private void assertPortInRange(int port, int minPort, int maxPort) {
+		assertTrue("port [" + port + "] >= " + minPort, port >= minPort);
+		assertTrue("port [" + port + "] <= " + maxPort, port <= maxPort);
+	}
+
+	private void assertAvailablePorts(SortedSet<Integer> ports, int numRequested, int minPort, int maxPort) {
+		assertEquals("number of ports requested", numRequested, ports.size());
+		for (int port : ports) {
+			assertPortInRange(port, minPort, maxPort);
+		}
+	}
+
+	// --- TCP -----------------------------------------------------------------
+
+	@Test(expected = IllegalArgumentException.class)
+	public void findAvailableTcpPortWithZeroMinPort() {
+		SocketUtils.findAvailableTcpPort(0);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void findAvailableTcpPortWithNegativeMinPort() {
+		SocketUtils.findAvailableTcpPort(-500);
+	}
+
+	@Test
+	public void findAvailableTcpPort() {
+		int port = SocketUtils.findAvailableTcpPort();
+		assertPortInRange(port, PORT_RANGE_MIN, PORT_RANGE_MAX);
+	}
+
+	@Test
+	public void findAvailableTcpPortWithMin() {
+		int port = SocketUtils.findAvailableTcpPort(50000);
+		assertPortInRange(port, 50000, PORT_RANGE_MAX);
+	}
+
+	@Test
+	public void findAvailableTcpPortInRange() {
+		int minPort = 20000;
+		int maxPort = minPort + 1000;
+		int port = SocketUtils.findAvailableTcpPort(minPort, maxPort);
+		assertPortInRange(port, minPort, maxPort);
+	}
+
+	@Test
+	public void find4AvailableTcpPorts() {
+		findAvailableTcpPorts(4);
+	}
+
+	@Test
+	public void find50AvailableTcpPorts() {
+		findAvailableTcpPorts(50);
+	}
+
+	@Test
+	public void find4AvailableTcpPortsInRange() {
+		findAvailableTcpPorts(4, 30000, 35000);
+	}
+
+	@Test
+	public void find50AvailableTcpPortsInRange() {
+		findAvailableTcpPorts(50, 40000, 45000);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void findAvailableTcpPortsWithRequestedNumberGreaterThanSizeOfRange() {
+		findAvailableTcpPorts(50, 45000, 45010);
+	}
+
+	private void findAvailableTcpPorts(int numRequested) {
+		SortedSet<Integer> ports = SocketUtils.findAvailableTcpPorts(numRequested);
+		assertAvailablePorts(ports, numRequested, PORT_RANGE_MIN, PORT_RANGE_MAX);
+	}
+
+	private void findAvailableTcpPorts(int numRequested, int minPort, int maxPort) {
+		SortedSet<Integer> ports = SocketUtils.findAvailableTcpPorts(numRequested, minPort, maxPort);
+		assertAvailablePorts(ports, numRequested, minPort, maxPort);
+	}
+
+	// --- UDP -----------------------------------------------------------------
+
+	@Test(expected = IllegalArgumentException.class)
+	public void findAvailableUdpPortWithZeroMinPort() {
+		SocketUtils.findAvailableUdpPort(0);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void findAvailableUdpPortWithNegativeMinPort() {
+		SocketUtils.findAvailableUdpPort(-500);
+	}
+
+	@Test
+	public void findAvailableUdpPort() {
+		int port = SocketUtils.findAvailableUdpPort();
+		assertPortInRange(port, PORT_RANGE_MIN, PORT_RANGE_MAX);
+	}
+
+	@Test
+	public void findAvailableUdpPortWithMin() {
+		int port = SocketUtils.findAvailableUdpPort(50000);
+		assertPortInRange(port, 50000, PORT_RANGE_MAX);
+	}
+
+	@Test
+	public void findAvailableUdpPortInRange() {
+		int minPort = 20000;
+		int maxPort = minPort + 1000;
+		int port = SocketUtils.findAvailableUdpPort(minPort, maxPort);
+		assertPortInRange(port, minPort, maxPort);
+	}
+
+	@Test
+	public void find4AvailableUdpPorts() {
+		findAvailableUdpPorts(4);
+	}
+
+	@Test
+	public void find50AvailableUdpPorts() {
+		findAvailableUdpPorts(50);
+	}
+
+	@Test
+	public void find4AvailableUdpPortsInRange() {
+		findAvailableUdpPorts(4, 30000, 35000);
+	}
+
+	@Test
+	public void find50AvailableUdpPortsInRange() {
+		findAvailableUdpPorts(50, 40000, 45000);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void findAvailableUdpPortsWithRequestedNumberGreaterThanSizeOfRange() {
+		findAvailableUdpPorts(50, 45000, 45010);
+	}
+
+	private void findAvailableUdpPorts(int numRequested) {
+		SortedSet<Integer> ports = SocketUtils.findAvailableUdpPorts(numRequested);
+		assertAvailablePorts(ports, numRequested, PORT_RANGE_MIN, PORT_RANGE_MAX);
+	}
+
+	private void findAvailableUdpPorts(int numRequested, int minPort, int maxPort) {
+		SortedSet<Integer> ports = SocketUtils.findAvailableUdpPorts(numRequested, minPort, maxPort);
+		assertAvailablePorts(ports, numRequested, minPort, maxPort);
+	}
+
+}

spring-web/src/test/java/org/springframework/http/client/AbstractHttpRequestFactoryTestCase.java

@@ -16,9 +16,6 @@
 
 package org.springframework.http.client;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-
 import java.io.IOException;
 import java.io.InputStream;
 import java.net.URI;
@@ -43,8 +40,10 @@ import org.junit.BeforeClass;
 import org.junit.Test;
 import org.springframework.http.HttpMethod;
 import org.springframework.http.HttpStatus;
-import org.springframework.tests.web.FreePortScanner;
 import org.springframework.util.FileCopyUtils;
+import org.springframework.util.SocketUtils;
+
+import static org.junit.Assert.*;
 
 public abstract class AbstractHttpRequestFactoryTestCase {
 
@@ -56,7 +55,7 @@ public abstract class AbstractHttpRequestFactoryTestCase {
 
 	@BeforeClass
 	public static void startJettyServer() throws Exception {
-		int port = FreePortScanner.getFreePort();
+		int port = SocketUtils.findAvailableTcpPort();
 		jettyServer = new Server(port);
 		baseUrl = "http://localhost:" + port;
 

spring-web/src/test/java/org/springframework/tests/web/FreePortScanner.java

-/*
- * Copyright 2002-2012 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.tests.web;
-
-import java.io.IOException;
-import java.net.InetSocketAddress;
-import java.net.ServerSocket;
-import java.util.Random;
-
-import org.springframework.util.Assert;
-
-/**
- * Utility class that finds free BSD ports for use in testing scenario's.
- *
- * @author Ben Hale
- * @author Arjen Poutsma
- */
-public abstract class FreePortScanner {
-
-	private static final int MIN_SAFE_PORT = 1024;
-
-	private static final int MAX_PORT = 65535;
-
-	private static final Random random = new Random();
-
-	/**
-	 * Returns the number of a free port in the default range.
-	 */
-	public static int getFreePort() {
-		return getFreePort(MIN_SAFE_PORT, MAX_PORT);
-	}
-
-	/**
-	 * Returns the number of a free port in the given range.
-	 */
-	public static int getFreePort(int minPort, int maxPort) {
-		Assert.isTrue(minPort > 0, "'minPort' must be larger than 0");
-		Assert.isTrue(maxPort > minPort, "'maxPort' must be larger than minPort");
-		int portRange = maxPort - minPort;
-		int candidatePort;
-		int searchCounter = 0;
-		do {
-			if (++searchCounter > portRange) {
-				throw new IllegalStateException(
-						String.format("There were no ports available in the range %d to %d", minPort, maxPort));
-			}
-			candidatePort = getRandomPort(minPort, portRange);
-		}
-		while (!isPortAvailable(candidatePort));
-
-		return candidatePort;
-	}
-
-	private static int getRandomPort(int minPort, int portRange) {
-		return minPort + random.nextInt(portRange);
-	}
-
-	private static boolean isPortAvailable(int port) {
-		ServerSocket serverSocket;
-		try {
-			serverSocket = new ServerSocket();
-		}
-		catch (IOException ex) {
-			throw new IllegalStateException("Unable to create ServerSocket.", ex);
-		}
-
-		try {
-			InetSocketAddress sa = new InetSocketAddress(port);
-			serverSocket.bind(sa);
-			return true;
-		}
-		catch (IOException ex) {
-			return false;
-		}
-		finally {
-			try {
-				serverSocket.close();
-			}
-			catch (IOException ex) {
-				// ignore
-			}
-		}
-	}
-
-}

spring-web/src/test/java/org/springframework/web/client/RestTemplateIntegrationTests.java

@@ -16,14 +16,6 @@
 
 package org.springframework.web.client;
 
-import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-
 import java.io.IOException;
 import java.io.UnsupportedEncodingException;
 import java.net.URI;
@@ -63,10 +55,12 @@ import org.springframework.http.HttpStatus;
 import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
 import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
-import org.springframework.tests.web.FreePortScanner;
 import org.springframework.util.FileCopyUtils;
 import org.springframework.util.LinkedMultiValueMap;
 import org.springframework.util.MultiValueMap;
+import org.springframework.util.SocketUtils;
+
+import static org.junit.Assert.*;
 
 /** @author Arjen Poutsma */
 public class RestTemplateIntegrationTests {
@@ -83,7 +77,7 @@ public class RestTemplateIntegrationTests {
 
 	@BeforeClass
 	public static void startJettyServer() throws Exception {
-		int port = FreePortScanner.getFreePort();
+		int port = SocketUtils.findAvailableTcpPort();
 		jettyServer = new Server(port);
 		baseUrl = "http://localhost:" + port;
 		ServletContextHandler handler = new ServletContextHandler();
@@ -243,6 +237,7 @@ public class RestTemplateIntegrationTests {
 	}
 
 	@Test
+	@SuppressWarnings("unchecked")
 	public void exchangeGet() throws Exception {
 		HttpHeaders requestHeaders = new HttpHeaders();
 		requestHeaders.set("MyHeader", "MyValue");

spring-webmvc/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestPartIntegrationTests.java

@@ -16,8 +16,6 @@
 
 package org.springframework.web.servlet.mvc.method.annotation;
 
-import static org.junit.Assert.assertEquals;
-
 import java.net.URI;
 import java.util.Arrays;
 
@@ -42,9 +40,9 @@ import org.springframework.http.converter.ResourceHttpMessageConverter;
 import org.springframework.http.converter.json.MappingJacksonHttpMessageConverter;
 import org.springframework.http.converter.support.AllEncompassingFormHttpMessageConverter;
 import org.springframework.stereotype.Controller;
-import org.springframework.tests.web.FreePortScanner;
 import org.springframework.util.LinkedMultiValueMap;
 import org.springframework.util.MultiValueMap;
+import org.springframework.util.SocketUtils;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestMethod;
 import org.springframework.web.bind.annotation.RequestPart;
@@ -58,6 +56,8 @@ import org.springframework.web.servlet.DispatcherServlet;
 import org.springframework.web.servlet.config.annotation.EnableWebMvc;
 import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
 
+import static org.junit.Assert.*;
+
 /**
  * Test access to parts of a multipart request with {@link RequestPart}.
  *
@@ -74,8 +74,7 @@ public class RequestPartIntegrationTests {
 
 	@BeforeClass
 	public static void startServer() throws Exception {
-
-		int port = FreePortScanner.getFreePort();
+		int port = SocketUtils.findAvailableTcpPort();
 		baseUrl = "http://localhost:" + port;
 
 		server = new Server(port);