Update test class for Java 16 ...

- samples only for standard features
- markdown javadoc for JEPs
- organize classes related to Java 16
- improve code readability

Author: mperor

src/test/java/pl/mperor/lab/java/Java12.java

@@ -23,7 +23,7 @@ public void testSwitchExpression() {
         Assertions.assertThrows(IllegalStateException.class, () -> getTypeOfDayByNumber(0));
     }
 
-    private String getTypeOfDayByNumber(Integer dayOfWeek) {
+    private String getTypeOfDayByNumber(int dayOfWeek) {
         return switch (dayOfWeek) {
             case 1, 2, 3, 4, 5 -> "Working Day";
             case 6, 7 -> {
@@ -34,21 +34,6 @@ private String getTypeOfDayByNumber(Integer dayOfWeek) {
         };
     }
 
-    @Test
-    public void testPatternMatchingInstanceOfAkaSmartCasting() {
-        Object o = "Hello String!";
-        if (o instanceof String s) {
-            Assertions.assertNotNull(s);
-            Assertions.assertInstanceOf(String.class, s);
-        }
-        Assertions.assertTrue(nonEmptyString("Hello World!"));
-        Assertions.assertFalse(nonEmptyString(null));
-    }
-
-    private static boolean nonEmptyString(Object obj) {
-        return (obj instanceof String str) && !str.isEmpty();
-    }
-
     @Test
     public void testStringIndentAndTransformMethods() {
         String text = "Hello\nJava 12\n";

src/test/java/pl/mperor/lab/java/Java14.java

@@ -10,29 +10,6 @@
  */
 public class Java14 {
 
-    // POJOs
-    @Test
-    public void testPairRecord() {
-        var pair = Pair.of("Boy", "Girl");
-        Assertions.assertEquals("Boy", pair.left);
-        Assertions.assertEquals("Girl", pair.right);
-        Assertions.assertEquals("Pair[left=Boy, right=Girl]", pair.toString());
-        Assertions.assertEquals(Pair.of(1, 1), Pair.of(1, 1));
-        Assertions.assertNotEquals(Pair.of(0, 0), Pair.of(1, 1));
-        Assertions.assertThrows(NullPointerException.class, () -> Pair.of(0, null));
-    }
-
-    record Pair<L, R>(L left, R right) {
-        Pair {
-            Objects.requireNonNull(left);
-            Objects.requireNonNull(right);
-        }
-
-        public static <L, R> Pair<L, R> of(L left, R right) {
-            return new Pair<>(left, right);
-        }
-    }
-
     @Test
     public void testHelpfulNullPointerExceptions() {
         NullPointerException exception = Assertions.assertThrows(NullPointerException.class, () -> {

src/test/java/pl/mperor/lab/java/Java15.java

@@ -1,9 +1,5 @@
 package pl.mperor.lab.java;
 
-import org.junit.jupiter.api.Assertions;
-import org.junit.jupiter.api.Test;
-import pl.mperor.lab.java.sealed.*;
-
 /**
  * Java 15 (September 2020)
  */

src/test/java/pl/mperor/lab/java/Java16.java

@@ -3,20 +3,104 @@
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.EnabledOnOs;
+import org.junit.jupiter.api.condition.OS;
 import pl.mperor.lab.TestUtils;
 
 import java.io.IOException;
+import java.net.StandardProtocolFamily;
+import java.net.UnixDomainSocketAddress;
+import java.nio.channels.ServerSocketChannel;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
 import java.time.LocalTime;
 import java.time.format.DateTimeFormatter;
 import java.util.List;
 import java.util.Locale;
+import java.util.Objects;
 import java.util.stream.Collectors;
 
-/**
- * Java 16 (March 2021)
- */
+/// Java 16™ (March 2021)
+/// [JDK 16](https://openjdk.org/projects/jdk/16)
+///
+/// - STANDARD FEATURES:
+///     - 395:	Records
+///     - 394:	Pattern Matching for instanceof
+///     - 390:	Warnings for Value-Based Classes
+///     - 392:	Packaging Tool
+///     - 396:	Strongly Encapsulate JDK Internals by Default
+///     - 376:	ZGC: Concurrent Thread-Stack Processing
+///     - 380:	Unix-Domain Socket Channels
+///     - 387:	Elastic Metaspace
+///     - 347:	Enable C++14 Language Features
+///     - 386:	Alpine Linux Port
+///     - 388:	Windows/AArch64 Port
+///     - 357:	Migrate from Mercurial to Git
+///     - 369:	Migrate to GitHub
+///
+/// - PREVIEW & INCUBATOR:
+///     - 389:	Foreign Linker API (Incubator)
+///     - 397:	Sealed Classes (Second Preview)
+///     - 393:	Foreign-Memory Access API (Third Incubator)
+///     - 338:	Vector API (Incubator)
 public class Java16 {
 
+    // POJOs
+    @Test
+    public void testPairRecord() {
+        var pair = Pair.of("Boy", "Girl");
+        Assertions.assertEquals("Boy", pair.left);
+        Assertions.assertEquals("Girl", pair.right);
+        Assertions.assertEquals("Pair[left=Boy, right=Girl]", pair.toString());
+        Assertions.assertEquals(Pair.of(1, 1), Pair.of(1, 1));
+        Assertions.assertNotEquals(Pair.of(0, 0), Pair.of(1, 1));
+        Assertions.assertThrows(NullPointerException.class, () -> Pair.of(0, null));
+    }
+
+    record Pair<L, R>(L left, R right) {
+        Pair {
+            Objects.requireNonNull(left);
+            Objects.requireNonNull(right);
+        }
+
+        public static <L, R> Pair<L, R> of(L left, R right) {
+            return new Pair<>(left, right);
+        }
+    }
+
+    @Test
+    public void testPatternMatchingInstanceOfAkaSmartCasting() {
+        Object o = "Hello String!";
+        if (o instanceof String s) {
+            Assertions.assertNotNull(s);
+            Assertions.assertInstanceOf(String.class, s);
+        }
+        Assertions.assertTrue(nonEmptyString("Hello World!"));
+        Assertions.assertFalse(nonEmptyString(null));
+    }
+
+    private static boolean nonEmptyString(Object obj) {
+        return (obj instanceof String str) && !str.isEmpty();
+    }
+
+    @SuppressWarnings({"removal", "synchronization"})
+    @Test
+    public void testValueBasedClasses() {
+        // warning: [removal] Long(long) in Long has been deprecated and marked for removal
+        Long longByConstructor = new Long(13);
+
+        // warning: [synchronization] attempt to synchronize on an instance of a value-based class
+        synchronized (longByConstructor) {
+            System.out.println("From the synchronized block!");
+        }
+
+        Long longByFactoryMethod = Long.valueOf(13L);
+        Assertions.assertFalse(longByConstructor == longByFactoryMethod);
+        Assertions.assertTrue(longByConstructor.equals(longByFactoryMethod));
+        Assertions.assertTrue(Long.valueOf(13L) == longByFactoryMethod);
+    }
+
     @Test
     public void testPeriodSupport() {
         LocalTime date = LocalTime.parse("16:00:00");
@@ -70,23 +154,6 @@ public void call() {
         TestUtils.resetSystemOut();
     }
 
-    @SuppressWarnings({"removal", "synchronization"})
-    @Test
-    public void testValueBasedClasses() {
-        // warning: new Long(...) has been deprecated and marked for removal
-        Long longByConstructor = new Long(13);
-
-        // warning: attempt to synchronize on an instance of a value-based class
-        synchronized (longByConstructor) {
-            System.out.println("From the synchronized block!");
-        }
-
-        Long longByFactoryMethod = Long.valueOf(13L);
-        Assertions.assertFalse(longByConstructor == longByFactoryMethod);
-        Assertions.assertTrue(longByConstructor.equals(longByFactoryMethod));
-        Assertions.assertTrue(Long.valueOf(13L) == longByFactoryMethod);
-    }
-
     @Disabled("Dependent on the OS and additional libraries, besides having a long execution time.")
     @Test
     public void testJPackage() throws IOException, InterruptedException {
@@ -102,4 +169,18 @@ public void testJPackage() throws IOException, InterruptedException {
         process.destroy();
     }
 
+    @EnabledOnOs(OS.LINUX)
+    @Test
+    public void testUnixDomainSocketChannels() throws IOException {
+        Path socketPath = Paths.get("/tmp/unix_socket");
+        Files.deleteIfExists(socketPath);
+        UnixDomainSocketAddress socketAddress = UnixDomainSocketAddress.of(socketPath);
+
+        Assertions.assertNotNull(socketAddress);
+        Assertions.assertNotNull(StandardProtocolFamily.UNIX);
+        try (var server = ServerSocketChannel.open(StandardProtocolFamily.UNIX).bind(socketAddress)) {
+            Assertions.assertNotNull(server);
+        }
+    }
+
 }

src/test/java/pl/mperor/lab/java/Java17.java

@@ -133,7 +133,8 @@ public void testDeprecated() {
 
     @Test
     public void testRmiActivation() {
-        Assertions.assertFalse(ModuleLayer.boot().findModule("java.rmi").stream().map(Module::getPackages)
+        Assertions.assertFalse(ModuleLayer.boot().findModule("java.rmi").stream()
+                .map(Module::getPackages)
                 .flatMap(Set::stream)
                 .anyMatch("java.rmi.activation"::equals));
     }

src/test/java/pl/mperor/lab/java/Java18.java

@@ -83,7 +83,7 @@ private static String curlResponse(String url) throws IOException, InterruptedEx
     public void testFinalizeDeprecated() throws Throwable {
         var out = TestUtils.setTempSystemOut();
 
-        // warning: finalize() in Object has been deprecated and marked for removal
+        // warning: [removal] finalize() in Object has been deprecated and marked for removal
         var object = new Object() {
             @Override
             protected void finalize() throws Throwable {

src/test/java/pl/mperor/lab/java/Java4.java

@@ -5,11 +5,16 @@
 
 import javax.imageio.ImageIO;
 import java.awt.image.BufferedImage;
-import java.io.File;
-import java.io.IOException;
+import java.io.*;
+import java.net.InetSocketAddress;
+import java.net.ServerSocket;
+import java.nio.channels.ServerSocketChannel;
+import java.nio.channels.SocketChannel;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.Executors;
 import java.util.logging.Logger;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
@@ -85,5 +90,40 @@ public void testImageIO() throws IOException {
         BufferedImage image = ImageIO.read(new File("src/test/resources/imageio.png"));
         Assertions.assertTrue(ImageIO.write(image, "jpg", File.createTempFile("imageio", ".jpg")));
     }
+    @Test
+    public void testServerClientSocketChannel() throws IOException, InterruptedException {
+        int port = 8888;
+        CountDownLatch serverReadyLatch = new CountDownLatch(1);
+
+        var executorService = Executors.newSingleThreadExecutor();
+        executorService.submit(() -> {
+            try (ServerSocket serverSocket = ServerSocketChannel.open().bind(new InetSocketAddress(port)).socket()) {
+                serverReadyLatch.countDown();
+                handleConnectedClient(serverSocket);
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        });
+
+        serverReadyLatch.await();
+        try (var clientSocket = SocketChannel.open(new InetSocketAddress("localhost", port));
+             var reader = new BufferedReader(new InputStreamReader(clientSocket.socket().getInputStream()));
+             var writer = new PrintWriter(clientSocket.socket().getOutputStream(), true)) {
+            writer.println("Hello Server!");
+            Assertions.assertEquals("Hello Client!", reader.readLine());
+        }
+
+        executorService.close();
+    }
+
+    private void handleConnectedClient(ServerSocket serverSocket) throws IOException {
+        try (var clientSocket = serverSocket.accept();
+             BufferedReader reader = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
+             PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true)) {
+            Assertions.assertEquals("Hello Server!", reader.readLine());
+            out.println("Hello Client!");
+        }
+    }
+
 
 }