[BAEL-11401] - Moved articles out of core-java (part 2)

core-java-networking/README.md

@@ -11,3 +11,6 @@
 - [A Guide To HTTP Cookies In Java](http://www.baeldung.com/cookies-java)
 - [A Guide to the Java URL](http://www.baeldung.com/java-url)
 - [Working with Network Interfaces in Java](http://www.baeldung.com/java-network-interfaces)
+- [A Guide to Java Sockets](http://www.baeldung.com/a-guide-to-java-sockets)
+- [URL Encoding and Decoding in Java](http://www.baeldung.com/java-url-encoding-decoding)
+- [How to Perform a Simple HTTP Request in Java](http://www.baeldung.com/java-http-request)

core-java-networking/pom.xml

@@ -24,6 +24,16 @@
             <artifactId>commons-io</artifactId>
             <version>${commons-io.version}</version>
         </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-web</artifactId>
+            <version>${springframework.spring-web.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>${commons-lang3.version}</version>
+        </dependency>
     </dependencies>
 
     <build>
@@ -33,5 +43,7 @@
     <properties>
         <javax.mail.version>1.5.0-b01</javax.mail.version>
         <commons-io.version>2.5</commons-io.version>
+        <commons-lang3.version>3.5</commons-lang3.version>
+        <springframework.spring-web.version>4.3.4.RELEASE</springframework.spring-web.version>
     </properties>	
 </project>

core-java-networking/src/main/java/com/baeldung/http/FullResponseBuilder.java

@@ -0,0 +1,65 @@
+package com.baeldung.http;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.Reader;
+import java.net.HttpURLConnection;
+import java.util.Iterator;
+import java.util.List;
+
+public class FullResponseBuilder {
+    public static String getFullResponse(HttpURLConnection con) throws IOException {
+        StringBuilder fullResponseBuilder = new StringBuilder();
+
+        fullResponseBuilder.append(con.getResponseCode())
+            .append(" ")
+            .append(con.getResponseMessage())
+            .append("\n");
+
+        con.getHeaderFields()
+            .entrySet()
+            .stream()
+            .filter(entry -> entry.getKey() != null)
+            .forEach(entry -> {
+
+                fullResponseBuilder.append(entry.getKey())
+                    .append(": ");
+
+                List<String> headerValues = entry.getValue();
+                Iterator<String> it = headerValues.iterator();
+                if (it.hasNext()) {
+                    fullResponseBuilder.append(it.next());
+
+                    while (it.hasNext()) {
+                        fullResponseBuilder.append(", ")
+                            .append(it.next());
+                    }
+                }
+
+                fullResponseBuilder.append("\n");
+            });
+
+        Reader streamReader = null;
+
+        if (con.getResponseCode() > 299) {
+            streamReader = new InputStreamReader(con.getErrorStream());
+        } else {
+            streamReader = new InputStreamReader(con.getInputStream());
+        }
+
+        BufferedReader in = new BufferedReader(streamReader);
+        String inputLine;
+        StringBuilder content = new StringBuilder();
+        while ((inputLine = in.readLine()) != null) {
+            content.append(inputLine);
+        }
+
+        in.close();
+
+        fullResponseBuilder.append("Response: ")
+            .append(content);
+
+        return fullResponseBuilder.toString();
+    }
+}

core-java-networking/src/main/java/com/baeldung/http/ParameterStringBuilder.java

@@ -0,0 +1,21 @@
+package com.baeldung.http;
+
+import java.io.UnsupportedEncodingException;
+import java.net.URLEncoder;
+import java.util.Map;
+
+public class ParameterStringBuilder {
+    public static String getParamsString(Map<String, String> params) throws UnsupportedEncodingException {
+        StringBuilder result = new StringBuilder();
+
+        for (Map.Entry<String, String> entry : params.entrySet()) {
+            result.append(URLEncoder.encode(entry.getKey(), "UTF-8"));
+            result.append("=");
+            result.append(URLEncoder.encode(entry.getValue(), "UTF-8"));
+            result.append("&");
+        }
+
+        String resultString = result.toString();
+        return resultString.length() > 0 ? resultString.substring(0, resultString.length() - 1) : resultString;
+    }
+}

core-java-networking/src/main/java/com/baeldung/socket/EchoClient.java

@@ -0,0 +1,47 @@
+package com.baeldung.socket;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.*;
+import java.net.*;
+
+public class EchoClient {
+
+    private static final Logger LOG = LoggerFactory.getLogger(EchoClient.class);
+
+    private Socket clientSocket;
+    private PrintWriter out;
+    private BufferedReader in;
+
+    public void startConnection(String ip, int port) {
+        try {
+            clientSocket = new Socket(ip, port);
+            out = new PrintWriter(clientSocket.getOutputStream(), true);
+            in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
+        } catch (IOException e) {
+            LOG.debug("Error when initializing connection", e);
+        }
+
+    }
+
+    public String sendMessage(String msg) {
+        try {
+            out.println(msg);
+            return in.readLine();
+        } catch (Exception e) {
+            return null;
+        }
+    }
+
+    public void stopConnection() {
+        try {
+            in.close();
+            out.close();
+            clientSocket.close();
+        } catch (IOException e) {
+            LOG.debug("error when closing", e);
+        }
+
+    }
+}

core-java-networking/src/main/java/com/baeldung/socket/EchoMultiServer.java

@@ -0,0 +1,76 @@
+package com.baeldung.socket;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.net.*;
+import java.io.*;
+
+public class EchoMultiServer {
+
+    private static final Logger LOG = LoggerFactory.getLogger(EchoMultiServer.class);
+
+    private ServerSocket serverSocket;
+
+    public void start(int port) {
+        try {
+            serverSocket = new ServerSocket(port);
+            while (true)
+                new EchoClientHandler(serverSocket.accept()).start();
+
+        } catch (IOException e) {
+            e.printStackTrace();
+        } finally {
+            stop();
+        }
+
+    }
+
+    public void stop() {
+        try {
+
+            serverSocket.close();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+    }
+
+    private static class EchoClientHandler extends Thread {
+        private Socket clientSocket;
+        private PrintWriter out;
+        private BufferedReader in;
+
+        public EchoClientHandler(Socket socket) {
+            this.clientSocket = socket;
+        }
+
+        public void run() {
+            try {
+                out = new PrintWriter(clientSocket.getOutputStream(), true);
+                in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
+                String inputLine;
+                while ((inputLine = in.readLine()) != null) {
+                    if (".".equals(inputLine)) {
+                        out.println("bye");
+                        break;
+                    }
+                    out.println(inputLine);
+                }
+
+                in.close();
+                out.close();
+                clientSocket.close();
+
+            } catch (IOException e) {
+                LOG.debug(e.getMessage());
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        EchoMultiServer server = new EchoMultiServer();
+        server.start(5555);
+    }
+
+}

core-java-networking/src/main/java/com/baeldung/socket/EchoServer.java

@@ -0,0 +1,55 @@
+package com.baeldung.socket;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.net.*;
+import java.io.*;
+
+public class EchoServer {
+
+    private static final Logger LOG = LoggerFactory.getLogger(EchoServer.class);
+
+    private ServerSocket serverSocket;
+    private Socket clientSocket;
+    private PrintWriter out;
+    private BufferedReader in;
+
+    public void start(int port) {
+        try {
+            serverSocket = new ServerSocket(port);
+            clientSocket = serverSocket.accept();
+            out = new PrintWriter(clientSocket.getOutputStream(), true);
+            in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
+            String inputLine;
+            while ((inputLine = in.readLine()) != null) {
+                if (".".equals(inputLine)) {
+                    out.println("good bye");
+                    break;
+                }
+                out.println(inputLine);
+            }
+        } catch (IOException e) {
+            LOG.debug(e.getMessage());
+        }
+
+    }
+
+    public void stop() {
+        try {
+            in.close();
+            out.close();
+            clientSocket.close();
+            serverSocket.close();
+        } catch (IOException e) {
+            LOG.debug(e.getMessage());
+        }
+
+    }
+
+    public static void main(String[] args) {
+        EchoServer server = new EchoServer();
+        server.start(4444);
+    }
+
+}

core-java-networking/src/main/java/com/baeldung/socket/GreetClient.java

@@ -0,0 +1,50 @@
+package com.baeldung.socket;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.net.Socket;
+
+public class GreetClient {
+
+    private static final Logger LOG = LoggerFactory.getLogger(EchoMultiServer.class);
+
+    private Socket clientSocket;
+    private PrintWriter out;
+    private BufferedReader in;
+
+    public void startConnection(String ip, int port) {
+        try {
+            clientSocket = new Socket(ip, port);
+            out = new PrintWriter(clientSocket.getOutputStream(), true);
+            in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
+        } catch (IOException e) {
+            LOG.debug(e.getMessage());
+        }
+
+    }
+
+    public String sendMessage(String msg) {
+        try {
+            out.println(msg);
+            return in.readLine();
+        } catch (Exception e) {
+            return null;
+        }
+    }
+
+    public void stopConnection() {
+        try {
+            in.close();
+            out.close();
+            clientSocket.close();
+        } catch (IOException e) {
+            LOG.debug(e.getMessage());
+        }
+    }
+
+}

core-java-networking/src/main/java/com/baeldung/socket/GreetServer.java

@@ -0,0 +1,52 @@
+package com.baeldung.socket;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.net.*;
+import java.io.*;
+
+public class GreetServer {
+
+    private static final Logger LOG = LoggerFactory.getLogger(GreetServer.class);
+
+    private ServerSocket serverSocket;
+    private Socket clientSocket;
+    private PrintWriter out;
+    private BufferedReader in;
+
+    public void start(int port) {
+        try {
+            serverSocket = new ServerSocket(port);
+            clientSocket = serverSocket.accept();
+            out = new PrintWriter(clientSocket.getOutputStream(), true);
+            in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
+            String greeting = in.readLine();
+            if ("hello server".equals(greeting))
+                out.println("hello client");
+            else
+                out.println("unrecognised greeting");
+        } catch (IOException e) {
+            LOG.debug(e.getMessage());
+        }
+
+    }
+
+    public void stop() {
+        try {
+            in.close();
+            out.close();
+            clientSocket.close();
+            serverSocket.close();
+        } catch (IOException e) {
+            LOG.debug(e.getMessage());
+        }
+
+    }
+
+    public static void main(String[] args) {
+        GreetServer server = new GreetServer();
+        server.start(6666);
+    }
+
+}

core-java-networking/src/test/java/com/baeldung/encoderdecoder/EncoderDecoderUnitTest.java

@@ -0,0 +1,112 @@
+package com.baeldung.encoderdecoder;
+
+import static java.util.stream.Collectors.joining;
+import static org.hamcrest.CoreMatchers.is;
+
+import java.io.UnsupportedEncodingException;
+import java.net.URL;
+import java.net.URLDecoder;
+import java.net.URLEncoder;
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.hamcrest.CoreMatchers;
+import org.junit.Assert;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.web.util.UriUtils;
+
+public class EncoderDecoderUnitTest {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(EncoderDecoderUnitTest.class);
+    private static final String testUrl = "http://www.baeldung.com?key1=value+1&key2=value%40%21%242&key3=value%253";
+    private static final String testUrlWithPath = "http://www.baeldung.com/path+1?key1=value+1&key2=value%40%21%242&key3=value%253";
+
+    private String encodeValue(String value) {
+        String encoded = null;
+        try {
+            encoded = URLEncoder.encode(value, StandardCharsets.UTF_8.toString());
+        } catch (UnsupportedEncodingException e) {
+            LOGGER.error("Error encoding parameter {}", e.getMessage(), e);
+        }
+        return encoded;
+    }
+
+    private String decode(String value) {
+        String decoded = null;
+        try {
+            decoded = URLDecoder.decode(value, StandardCharsets.UTF_8.toString());
+        } catch (UnsupportedEncodingException e) {
+            LOGGER.error("Error encoding parameter {}", e.getMessage(), e);
+        }
+        return decoded;
+    }
+
+    @Test
+    public void givenURL_whenAnalyze_thenCorrect() throws Exception {
+        URL url = new URL(testUrl);
+
+        Assert.assertThat(url.getProtocol(), is("http"));
+        Assert.assertThat(url.getHost(), is("www.baeldung.com"));
+        Assert.assertThat(url.getQuery(), is("key1=value+1&key2=value%40%21%242&key3=value%253"));
+    }
+
+    @Test
+    public void givenRequestParam_whenUTF8Scheme_thenEncode() throws Exception {
+        Map<String, String> requestParams = new HashMap<>();
+        requestParams.put("key1", "value 1");
+        requestParams.put("key2", "value@!$2");
+        requestParams.put("key3", "value%3");
+
+        String encodedURL = requestParams.keySet().stream().map(key -> key + "=" + encodeValue(requestParams.get(key))).collect(joining("&", "http://www.baeldung.com?", ""));
+
+        Assert.assertThat(testUrl, is(encodedURL));
+    }
+
+    @Test
+    public void givenRequestParam_whenUTF8Scheme_thenDecodeRequestParams() throws Exception {
+        URL url = new URL(testUrl);
+
+        String query = url.getQuery();
+
+        String decodedQuery = Arrays.stream(query.split("&")).map(param -> param.split("=")[0] + "=" + decode(param.split("=")[1])).collect(joining("&"));
+
+        Assert.assertEquals("http://www.baeldung.com?key1=value 1&key2=value@!$2&key3=value%3", url.getProtocol() + "://" + url.getHost() + "?" + decodedQuery);
+    }
+
+    private String encodePath(String path) {
+        try {
+            path = UriUtils.encodePath(path, "UTF-8");
+        } catch (UnsupportedEncodingException e) {
+            LOGGER.error("Error encoding parameter {}", e.getMessage(), e);
+        }
+        return path;
+    }
+
+    @Test
+    public void givenPathSegment_thenEncodeDecode() throws UnsupportedEncodingException {
+        String pathSegment = "/Path 1/Path+2";
+        String encodedPathSegment = encodePath(pathSegment);
+        String decodedPathSegment = UriUtils.decode(encodedPathSegment, "UTF-8");
+        Assert.assertEquals("/Path%201/Path+2", encodedPathSegment);
+        Assert.assertEquals("/Path 1/Path+2", decodedPathSegment);
+    }
+
+    @Test
+    public void givenPathAndRequestParam_whenUTF8Scheme_thenEncode() throws Exception {
+        Map<String, String> requestParams = new HashMap<>();
+        requestParams.put("key1", "value 1");
+        requestParams.put("key2", "value@!$2");
+        requestParams.put("key3", "value%3");
+
+        String path = "path+1";
+
+        String encodedURL = requestParams.keySet().stream().map(key -> key + "=" + encodeValue(requestParams.get(key))).collect(joining("&", "http://www.baeldung.com/" + encodePath(path) + "?", ""));
+
+        Assert.assertThat(testUrlWithPath, is(encodedURL));
+    }
+
+}

core-java-networking/src/test/java/com/baeldung/http/HttpRequestLiveTest.java

@@ -0,0 +1,188 @@
+package com.baeldung.http;
+
+import org.apache.commons.lang3.StringUtils;
+import org.junit.Test;
+
+import java.io.BufferedReader;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.Reader;
+import java.net.CookieManager;
+import java.net.HttpCookie;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class HttpRequestLiveTest {
+
+    @Test
+    public void whenGetRequest_thenOk() throws IOException {
+        URL url = new URL("http://example.com");
+        HttpURLConnection con = (HttpURLConnection) url.openConnection();
+        con.setRequestMethod("GET");
+
+        Map<String, String> parameters = new HashMap<>();
+        parameters.put("param1", "val");
+        con.setDoOutput(true);
+        DataOutputStream out = new DataOutputStream(con.getOutputStream());
+        out.writeBytes(ParameterStringBuilder.getParamsString(parameters));
+        out.flush();
+        out.close();
+
+        con.setConnectTimeout(5000);
+        con.setReadTimeout(5000);
+
+        int status = con.getResponseCode();
+        BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream()));
+        String inputLine;
+        StringBuilder content = new StringBuilder();
+        while ((inputLine = in.readLine()) != null) {
+            content.append(inputLine);
+        }
+        in.close();
+
+        assertEquals("status code incorrect", status, 200);
+        assertTrue("content incorrect", content.toString()
+            .contains("Example Domain"));
+    }
+
+    @Test
+    public void whenPostRequest_thenOk() throws IOException {
+        URL url = new URL("http://example.com");
+        HttpURLConnection con = (HttpURLConnection) url.openConnection();
+        con.setRequestMethod("POST");
+        con.setRequestProperty("Content-Type", "application/json");
+
+        Map<String, String> parameters = new HashMap<>();
+        parameters.put("param1", "val");
+        con.setDoOutput(true);
+        DataOutputStream out = new DataOutputStream(con.getOutputStream());
+        out.writeBytes(ParameterStringBuilder.getParamsString(parameters));
+        out.flush();
+        out.close();
+
+        int status = con.getResponseCode();
+        BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream()));
+        String inputLine;
+        StringBuilder content = new StringBuilder();
+        while ((inputLine = in.readLine()) != null) {
+            content.append(inputLine);
+        }
+        in.close();
+
+        assertEquals("status code incorrect", status, 200);
+    }
+
+    @Test
+    public void whenGetCookies_thenOk() throws IOException {
+        URL url = new URL("http://example.com");
+        HttpURLConnection con = (HttpURLConnection) url.openConnection();
+        con.setRequestMethod("GET");
+
+        CookieManager cookieManager = new CookieManager();
+        String cookiesHeader = con.getHeaderField("Set-Cookie");
+        Optional<HttpCookie> usernameCookie = null;
+        if (cookiesHeader != null) {
+            List<HttpCookie> cookies = HttpCookie.parse(cookiesHeader);
+            cookies.forEach(cookie -> cookieManager.getCookieStore()
+                .add(null, cookie));
+            usernameCookie = cookies.stream()
+                .findAny()
+                .filter(cookie -> cookie.getName()
+                    .equals("username"));
+        }
+
+        if (usernameCookie == null) {
+            cookieManager.getCookieStore()
+                .add(null, new HttpCookie("username", "john"));
+        }
+
+        con.disconnect();
+
+        con = (HttpURLConnection) url.openConnection();
+        con.setRequestProperty("Cookie", StringUtils.join(cookieManager.getCookieStore()
+            .getCookies(), ";"));
+
+        int status = con.getResponseCode();
+
+        assertEquals("status code incorrect", status, 200);
+    }
+
+    @Test
+    public void whenRedirect_thenOk() throws IOException {
+        URL url = new URL("http://example.com");
+        HttpURLConnection con = (HttpURLConnection) url.openConnection();
+        con.setRequestMethod("GET");
+
+        con.setInstanceFollowRedirects(true);
+        int status = con.getResponseCode();
+
+        if (status == HttpURLConnection.HTTP_MOVED_TEMP || status == HttpURLConnection.HTTP_MOVED_PERM) {
+            String location = con.getHeaderField("Location");
+            URL newUrl = new URL(location);
+            con = (HttpURLConnection) newUrl.openConnection();
+        }
+
+        assertEquals("status code incorrect", con.getResponseCode(), 200);
+    }
+
+    @Test
+    public void whenFailedRequest_thenOk() throws IOException {
+        URL url = new URL("http://example.com");
+        HttpURLConnection con = (HttpURLConnection) url.openConnection();
+        con.setRequestMethod("POST");
+
+        con.setConnectTimeout(5000);
+        con.setReadTimeout(5000);
+
+        int status = con.getResponseCode();
+
+        Reader streamReader = null;
+
+        if (status > 299) {
+            streamReader = new InputStreamReader(con.getErrorStream());
+        } else {
+            streamReader = new InputStreamReader(con.getInputStream());
+        }
+
+        BufferedReader in = new BufferedReader(streamReader);
+        String inputLine;
+        StringBuilder content = new StringBuilder();
+        while ((inputLine = in.readLine()) != null) {
+            content.append(inputLine);
+        }
+        in.close();
+
+        con.disconnect();
+
+        assertEquals("status code incorrect", status, 411);
+        assertTrue("error content", content.toString()
+            .contains("411 - Length Required"));
+    }
+
+    @Test
+    public void whenGetRequestFullResponse_thenOk() throws IOException {
+        URL url = new URL("http://example.com");
+        HttpURLConnection con = (HttpURLConnection) url.openConnection();
+        con.setRequestMethod("GET");
+
+        con.setConnectTimeout(5000);
+        con.setReadTimeout(5000);
+
+        String fullResponse = FullResponseBuilder.getFullResponse(con);
+
+        con.disconnect();
+
+        assertEquals("status code incorrect", con.getResponseCode(), 200);
+        assertTrue("header incorrect", fullResponse.contains("Content-Type: text/html; charset=UTF-8"));
+        assertTrue("response incorrect", fullResponse.contains("<!doctype html><html><head>"));
+    }
+
+}

core-java-networking/src/test/java/com/baeldung/socket/EchoIntegrationTest.java

@@ -0,0 +1,56 @@
+package com.baeldung.socket;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.IOException;
+import java.net.ServerSocket;
+import java.util.concurrent.Executors;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class EchoIntegrationTest {
+    private static int port;
+
+    @BeforeClass
+    public static void start() throws InterruptedException, IOException {
+        
+        // Take an available port
+        ServerSocket s = new ServerSocket(0);
+        port = s.getLocalPort();
+        s.close();
+
+        Executors.newSingleThreadExecutor()
+            .submit(() -> new EchoServer().start(port));
+        Thread.sleep(500);
+    }
+
+    private EchoClient client = new EchoClient();
+
+    @Before
+    public void init() {
+        client.startConnection("127.0.0.1", port);
+    }
+
+    @After
+    public void tearDown() {
+        client.stopConnection();
+    }
+
+    //
+
+    @Test
+    public void givenClient_whenServerEchosMessage_thenCorrect() {
+        String resp1 = client.sendMessage("hello");
+        String resp2 = client.sendMessage("world");
+        String resp3 = client.sendMessage("!");
+        String resp4 = client.sendMessage(".");
+        assertEquals("hello", resp1);
+        assertEquals("world", resp2);
+        assertEquals("!", resp3);
+        assertEquals("good bye", resp4);
+    }
+
+}

core-java-networking/src/test/java/com/baeldung/socket/GreetServerIntegrationTest.java

@@ -0,0 +1,50 @@
+package com.baeldung.socket;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.IOException;
+import java.net.ServerSocket;
+import java.util.concurrent.Executors;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class GreetServerIntegrationTest {
+
+    private GreetClient client;
+
+    private static int port;
+
+    @BeforeClass
+    public static void start() throws InterruptedException, IOException {
+        
+        // Take an available port
+        ServerSocket s = new ServerSocket(0);
+        port = s.getLocalPort();
+        s.close();
+        
+        Executors.newSingleThreadExecutor()
+            .submit(() -> new GreetServer().start(port));
+        Thread.sleep(500);
+    }
+
+    @Before
+    public void init() {
+        client = new GreetClient();
+        client.startConnection("127.0.0.1", port);
+
+    }
+
+    @Test
+    public void givenGreetingClient_whenServerRespondsWhenStarted_thenCorrect() {
+        String response = client.sendMessage("hello server");
+        assertEquals("hello client", response);
+    }
+
+    @After
+    public void finish() {
+        client.stopConnection();
+    }
+}

core-java-networking/src/test/java/com/baeldung/socket/SocketEchoMultiIntegrationTest.java

@@ -0,0 +1,68 @@
+package com.baeldung.socket;
+
+import org.junit.BeforeClass;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.net.ServerSocket;
+import java.util.concurrent.Executors;
+
+import static org.junit.Assert.assertEquals;
+
+public class SocketEchoMultiIntegrationTest {
+
+    private static int port;
+
+    @BeforeClass
+    public static void start() throws InterruptedException, IOException {
+
+        // Take an available port
+        ServerSocket s = new ServerSocket(0);
+        port = s.getLocalPort();
+        s.close();
+
+        Executors.newSingleThreadExecutor().submit(() -> new EchoMultiServer().start(port));
+        Thread.sleep(500);
+    }
+
+    @Test
+    public void givenClient1_whenServerResponds_thenCorrect() {
+        EchoClient client = new EchoClient();
+        client.startConnection("127.0.0.1", port);
+        String msg1 = client.sendMessage("hello");
+        String msg2 = client.sendMessage("world");
+        String terminate = client.sendMessage(".");
+
+        assertEquals(msg1, "hello");
+        assertEquals(msg2, "world");
+        assertEquals(terminate, "bye");
+        client.stopConnection();
+    }
+
+    @Test
+    public void givenClient2_whenServerResponds_thenCorrect() {
+        EchoClient client = new EchoClient();
+        client.startConnection("127.0.0.1", port);
+        String msg1 = client.sendMessage("hello");
+        String msg2 = client.sendMessage("world");
+        String terminate = client.sendMessage(".");
+        assertEquals(msg1, "hello");
+        assertEquals(msg2, "world");
+        assertEquals(terminate, "bye");
+        client.stopConnection();
+    }
+
+    @Test
+    public void givenClient3_whenServerResponds_thenCorrect() {
+        EchoClient client = new EchoClient();
+        client.startConnection("127.0.0.1", port);
+        String msg1 = client.sendMessage("hello");
+        String msg2 = client.sendMessage("world");
+        String terminate = client.sendMessage(".");
+        assertEquals(msg1, "hello");
+        assertEquals(msg2, "world");
+        assertEquals(terminate, "bye");
+        client.stopConnection();
+    }
+}