Merge remote-tracking branch 'upstream/master' into craedel-log4j2

2016-11-09 14:56:36 +01:00
parent e26d9ff8e4 f84ba52171
commit 1c0e0c6ec1
121 changed files with 2914 additions and 303 deletions
@@ -0,0 +1,119 @@
+package com.baeldung.java9.language.stream;
+
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static java.lang.Integer.*;
+import static org.junit.Assert.assertEquals;
+
+public class StreamFeaturesTest {
+
+    public static class TakeAndDropWhileTest {
+
+        public Stream<String> getStreamAfterTakeWhileOperation() {
+            return Stream
+                    .iterate("", s -> s + "s")
+                    .takeWhile(s -> s.length() < 10);
+        }
+
+        public Stream<String> getStreamAfterDropWhileOperation() {
+            return Stream
+                    .iterate("", s -> s + "s")
+                    .takeWhile(s -> s.length() < 10)
+                    .dropWhile(s -> !s.contains("sssss"));
+        }
+
+        @Test
+        public void testTakeWhileOperation() {
+            List<String> list = getStreamAfterTakeWhileOperation().collect(Collectors.toList());
+
+            assertEquals(10, list.size());
+
+            assertEquals("", list.get(0));
+            assertEquals("ss", list.get(2));
+            assertEquals("sssssssss", list.get(list.size() - 1));
+        }
+
+        @Test
+        public void testDropWhileOperation() {
+            List<String> list = getStreamAfterDropWhileOperation().collect(Collectors.toList());
+
+            assertEquals(5, list.size());
+
+            assertEquals("sssss", list.get(0));
+            assertEquals("sssssss", list.get(2));
+            assertEquals("sssssssss", list.get(list.size() - 1));
+        }
+
+    }
+
+    public static class IterateTest {
+
+        private Stream<Integer> getStream() {
+            return Stream.iterate(0, i -> i < 10, i -> i + 1);
+        }
+
+        @Test
+        public void testIterateOperation() {
+            List<Integer> list = getStream().collect(Collectors.toList());
+
+            assertEquals(10, list.size());
+
+            assertEquals(valueOf(0), list.get(0));
+            assertEquals(valueOf(5), list.get(5));
+            assertEquals(valueOf(9), list.get(list.size() - 1));
+        }
+
+    }
+
+    public  static class OfNullableTest {
+
+        private List<String> collection = Arrays.asList("A", "B", "C");
+        private Map<String, Integer> map = new HashMap<>() {{
+           put("A", 10);
+           put("C", 30);
+        }};
+
+        private Stream<Integer> getStreamWithOfNullable() {
+            return collection.stream()
+                    .flatMap(s -> Stream.ofNullable(map.get(s)));
+        }
+
+        private Stream<Integer> getStream() {
+            return collection.stream()
+                            .flatMap(s -> {
+                                Integer temp = map.get(s);
+                                return temp != null ? Stream.of(temp) : Stream.empty();
+                            });
+        }
+
+        private List<Integer> testOfNullableFrom(Stream<Integer> stream) {
+            List<Integer> list = stream.collect(Collectors.toList());
+
+            assertEquals(2, list.size());
+
+            assertEquals(valueOf(10), list.get(0));
+            assertEquals(valueOf(30), list.get(list.size() - 1));
+
+            return list;
+        }
+
+        @Test
+        public void testOfNullable() {
+
+            assertEquals(
+                    testOfNullableFrom(getStream()),
+                    testOfNullableFrom(getStreamWithOfNullable())
+            );
+
+        }
+
+    }
+
+}
@@ -1,4 +1,4 @@
-package org.baeldung.equalshashcode.entities;
+package com.baeldung.equalshashcode.entities;

 import java.util.List;
 import java.util.Set;
@@ -1,4 +1,4 @@
-package org.baeldung.equalshashcode.entities;
+package com.baeldung.equalshashcode.entities;

 public class PrimitiveClass {

@@ -1,4 +1,4 @@
-package org.baeldung.equalshashcode.entities;
+package com.baeldung.equalshashcode.entities;

 public class Rectangle extends Shape {
    private double width;
@@ -1,4 +1,4 @@
-package org.baeldung.equalshashcode.entities;
+package com.baeldung.equalshashcode.entities;

 public abstract class Shape {
    public abstract double area();
@@ -1,4 +1,4 @@
-package org.baeldung.equalshashcode.entities;
+package com.baeldung.equalshashcode.entities;

 import java.awt.Color;

@@ -1,4 +1,4 @@
-package org.baeldung.executable;
+package com.baeldung.executable;

 import javax.swing.JOptionPane;

@@ -0,0 +1,60 @@
+package com.baeldung.java.conversion;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.time.LocalDateTime;
+import java.util.Date;
+
+import com.baeldung.datetime.UseLocalDateTime;
+
+public class StringConversion {
+
+    public static int getInt(String str) {
+        return Integer.parseInt(str);
+    }
+
+    public static int getInteger(String str) {
+        return Integer.valueOf(str);
+    }
+
+    public static long getLongPrimitive(String str) {
+        return Long.parseLong(str);
+    }
+
+    public static Long getLong(String str) {
+        return Long.valueOf(str);
+    }
+
+    public static double getDouble(String str) {
+        return Double.parseDouble(str);
+    }
+
+    public static double getDoublePrimitive(String str) {
+        return Double.valueOf(str);
+    }
+
+    public static byte[] getByteArray(String str) {
+        return str.getBytes();
+    }
+
+    public static char[] getCharArray(String str) {
+        return str.toCharArray();
+    }
+
+    public static boolean getBooleanPrimitive(String str) {
+        return Boolean.parseBoolean(str);
+    }
+
+    public static boolean getBoolean(String str) {
+        return Boolean.valueOf(str);
+    }
+
+    public static Date getJava6Date(String str, String format) throws ParseException {
+        SimpleDateFormat formatter = new SimpleDateFormat(format);
+        return formatter.parse(str);
+    }
+
+    public static LocalDateTime getJava8Date(String str) throws ParseException {
+        return new UseLocalDateTime().getLocalDateTimeUsingParseMethod(str);
+    }
+}
@@ -24,7 +24,7 @@ public class EchoClient {
    public String sendEcho(String msg) {
        DatagramPacket packet = null;
        try {
-            buf=msg.getBytes();
+            buf = msg.getBytes();
            packet = new DatagramPacket(buf, buf.length, address, 4445);
            socket.send(packet);
            packet = new DatagramPacket(buf, buf.length);
@@ -17,6 +17,11 @@ public class EchoClient {
        return instance;
    }

+    public static void stop() throws IOException {
+        client.close();
+        buffer = null;
+    }
+
    private EchoClient() {
        try {
            client = SocketChannel.open(new InetSocketAddress("localhost", 5454));
@@ -42,5 +47,4 @@ public class EchoClient {
        return response;

    }
-
 }
@@ -1,21 +1,19 @@
 package com.baeldung.java.nio.selector;

+import java.io.File;
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.nio.ByteBuffer;
+import java.nio.channels.SelectionKey;
+import java.nio.channels.Selector;
 import java.nio.channels.ServerSocketChannel;
 import java.nio.channels.SocketChannel;
-import java.nio.channels.Selector;
-import java.nio.channels.SelectionKey;
-import java.nio.ByteBuffer;
-import java.io.IOException;
-import java.util.Set;
 import java.util.Iterator;
-import java.net.InetSocketAddress;
-import java.io.File;
+import java.util.Set;

 public class EchoServer {

-    public static void main(String[] args)
-
-            throws IOException {
+    public static void main(String[] args) throws IOException {
        Selector selector = Selector.open();
        ServerSocketChannel serverSocket = ServerSocketChannel.open();
        serverSocket.bind(new InetSocketAddress("localhost", 5454));
@@ -49,7 +47,6 @@ public class EchoServer {
        }
    }

-
    public static Process start() throws IOException, InterruptedException {
        String javaHome = System.getProperty("java.home");
        String javaBin = javaHome + File.separator + "bin" + File.separator + "java";
@@ -8,12 +8,12 @@ import org.junit.Assert;
 import org.junit.Test;

 public class UseLocalDateTimeUnitTest {
-    
+
    UseLocalDateTime useLocalDateTime = new UseLocalDateTime();
-    
+
    @Test
-    public void givenString_whenUsingParse_thenLocalDateTime(){
-        Assert.assertEquals(LocalDate.of(2016, Month.MAY, 10),useLocalDateTime.getLocalDateTimeUsingParseMethod("2016-05-10T06:30").toLocalDate());
-        Assert.assertEquals(LocalTime.of(6,30),useLocalDateTime.getLocalDateTimeUsingParseMethod("2016-05-10T06:30").toLocalTime());
+    public void givenString_whenUsingParse_thenLocalDateTime() {
+        Assert.assertEquals(LocalDate.of(2016, Month.MAY, 10), useLocalDateTime.getLocalDateTimeUsingParseMethod("2016-05-10T06:30").toLocalDate());
+        Assert.assertEquals(LocalTime.of(6, 30), useLocalDateTime.getLocalDateTimeUsingParseMethod("2016-05-10T06:30").toLocalTime());
    }
 }
@@ -8,47 +8,47 @@ import org.junit.Assert;
 import org.junit.Test;

 public class UseLocalDateUnitTest {
-    
+
    UseLocalDate useLocalDate = new UseLocalDate();
-    
+
    @Test
-    public void givenValues_whenUsingFactoryOf_thenLocalDate(){
-        Assert.assertEquals("2016-05-10",useLocalDate.getLocalDateUsingFactoryOfMethod(2016,5,10).toString());
+    public void givenValues_whenUsingFactoryOf_thenLocalDate() {
+        Assert.assertEquals("2016-05-10", useLocalDate.getLocalDateUsingFactoryOfMethod(2016, 5, 10).toString());
    }
-    
+
    @Test
-    public void givenString_whenUsingParse_thenLocalDate(){
-        Assert.assertEquals("2016-05-10",useLocalDate.getLocalDateUsingParseMethod("2016-05-10").toString());
+    public void givenString_whenUsingParse_thenLocalDate() {
+        Assert.assertEquals("2016-05-10", useLocalDate.getLocalDateUsingParseMethod("2016-05-10").toString());
    }
-    
+
    @Test
-    public void whenUsingClock_thenLocalDate(){
-        Assert.assertEquals(LocalDate.now(),useLocalDate.getLocalDateFromClock());
+    public void whenUsingClock_thenLocalDate() {
+        Assert.assertEquals(LocalDate.now(), useLocalDate.getLocalDateFromClock());
    }
-    
+
    @Test
-    public void givenDate_whenUsingPlus_thenNextDay(){
-        Assert.assertEquals(LocalDate.now().plusDays(1),useLocalDate.getNextDay(LocalDate.now()));
+    public void givenDate_whenUsingPlus_thenNextDay() {
+        Assert.assertEquals(LocalDate.now().plusDays(1), useLocalDate.getNextDay(LocalDate.now()));
    }
-    
+
    @Test
-    public void givenDate_whenUsingMinus_thenPreviousDay(){
-        Assert.assertEquals(LocalDate.now().minusDays(1),useLocalDate.getPreviousDay(LocalDate.now()));
+    public void givenDate_whenUsingMinus_thenPreviousDay() {
+        Assert.assertEquals(LocalDate.now().minusDays(1), useLocalDate.getPreviousDay(LocalDate.now()));
    }
-    
+
    @Test
-    public void givenToday_whenUsingGetDayOfWeek_thenDayOfWeek(){
-        Assert.assertEquals(DayOfWeek.SUNDAY,useLocalDate.getDayOfWeek(LocalDate.parse("2016-05-22")));
+    public void givenToday_whenUsingGetDayOfWeek_thenDayOfWeek() {
+        Assert.assertEquals(DayOfWeek.SUNDAY, useLocalDate.getDayOfWeek(LocalDate.parse("2016-05-22")));
    }
-    
+
    @Test
-    public void givenToday_whenUsingWithTemporalAdjuster_thenFirstDayOfMonth(){
-        Assert.assertEquals(1,useLocalDate.getFirstDayOfMonth().getDayOfMonth());
+    public void givenToday_whenUsingWithTemporalAdjuster_thenFirstDayOfMonth() {
+        Assert.assertEquals(1, useLocalDate.getFirstDayOfMonth().getDayOfMonth());
    }
-    
+
    @Test
-    public void givenLocalDate_whenUsingAtStartOfDay_thenReturnMidnight(){
-        Assert.assertEquals(LocalDateTime.parse("2016-05-22T00:00:00"),useLocalDate.getStartOfDay(LocalDate.parse("2016-05-22")));
+    public void givenLocalDate_whenUsingAtStartOfDay_thenReturnMidnight() {
+        Assert.assertEquals(LocalDateTime.parse("2016-05-22T00:00:00"), useLocalDate.getStartOfDay(LocalDate.parse("2016-05-22")));
    }

 }
@@ -6,31 +6,31 @@ import org.junit.Assert;
 import org.junit.Test;

 public class UseLocalTimeUnitTest {
-    
+
    UseLocalTime useLocalTime = new UseLocalTime();
-    
+
    @Test
-    public void givenValues_whenUsingFactoryOf_thenLocalTime(){
-        Assert.assertEquals("07:07:07",useLocalTime.getLocalTimeUsingFactoryOfMethod(7,7,7).toString());
+    public void givenValues_whenUsingFactoryOf_thenLocalTime() {
+        Assert.assertEquals("07:07:07", useLocalTime.getLocalTimeUsingFactoryOfMethod(7, 7, 7).toString());
    }
-    
+
    @Test
-    public void givenString_whenUsingParse_thenLocalTime(){
-        Assert.assertEquals("06:30",useLocalTime.getLocalTimeUsingParseMethod("06:30").toString());
+    public void givenString_whenUsingParse_thenLocalTime() {
+        Assert.assertEquals("06:30", useLocalTime.getLocalTimeUsingParseMethod("06:30").toString());
    }
-    
+
    @Test
-    public void givenTime_whenAddHour_thenLocalTime(){
-        Assert.assertEquals("07:30",useLocalTime.addAnHour(LocalTime.of(6,30)).toString());
+    public void givenTime_whenAddHour_thenLocalTime() {
+        Assert.assertEquals("07:30", useLocalTime.addAnHour(LocalTime.of(6, 30)).toString());
    }
-    
+
    @Test
-    public void getHourFromLocalTime(){
-        Assert.assertEquals(1, useLocalTime.getHourFromLocalTime(LocalTime.of(1,1)));
+    public void getHourFromLocalTime() {
+        Assert.assertEquals(1, useLocalTime.getHourFromLocalTime(LocalTime.of(1, 1)));
    }
-    
+
    @Test
-    public void getLocalTimeWithMinuteSetToValue(){
-        Assert.assertEquals(LocalTime.of(10, 20), useLocalTime.getLocalTimeWithMinuteSetToValue(LocalTime.of(10,10), 20));
+    public void getLocalTimeWithMinuteSetToValue() {
+        Assert.assertEquals(LocalTime.of(10, 20), useLocalTime.getLocalTimeWithMinuteSetToValue(LocalTime.of(10, 10), 20));
    }
 }
@@ -7,20 +7,20 @@ import org.junit.Assert;
 import org.junit.Test;

 public class UsePeriodUnitTest {
-    UsePeriod usingPeriod=new UsePeriod();
-    
+    UsePeriod usingPeriod = new UsePeriod();
+
    @Test
-    public void givenPeriodAndLocalDate_thenCalculateModifiedDate(){
+    public void givenPeriodAndLocalDate_thenCalculateModifiedDate() {
        Period period = Period.ofDays(1);
        LocalDate localDate = LocalDate.parse("2007-05-10");
-        Assert.assertEquals(localDate.plusDays(1),usingPeriod.modifyDates(localDate, period));
+        Assert.assertEquals(localDate.plusDays(1), usingPeriod.modifyDates(localDate, period));
    }
-    
+
    @Test
-    public void givenDates_thenGetPeriod(){
+    public void givenDates_thenGetPeriod() {
        LocalDate localDate1 = LocalDate.parse("2007-05-10");
        LocalDate localDate2 = LocalDate.parse("2007-05-15");
-        
+
        Assert.assertEquals(Period.ofDays(5), usingPeriod.getDifferenceBetweenDates(localDate1, localDate2));
    }
 }
@@ -8,13 +8,13 @@ import org.junit.Assert;
 import org.junit.Test;

 public class UseZonedDateTimeUnitTest {
-    
-    UseZonedDateTime zonedDateTime=new UseZonedDateTime();
-    
+
+    UseZonedDateTime zonedDateTime = new UseZonedDateTime();
+
    @Test
-    public void givenZoneId_thenZonedDateTime(){
-        ZoneId zoneId=ZoneId.of("Europe/Paris");
-        ZonedDateTime zonedDatetime=zonedDateTime.getZonedDateTime(LocalDateTime.parse("2016-05-20T06:30"), zoneId);
-        Assert.assertEquals(zoneId,ZoneId.from(zonedDatetime));
+    public void givenZoneId_thenZonedDateTime() {
+        ZoneId zoneId = ZoneId.of("Europe/Paris");
+        ZonedDateTime zonedDatetime = zonedDateTime.getZonedDateTime(LocalDateTime.parse("2016-05-20T06:30"), zoneId);
+        Assert.assertEquals(zoneId, ZoneId.from(zonedDatetime));
    }
 }
@@ -32,7 +32,6 @@ public class EncoderDecoderUnitTest {
        return encoded;
    }

-
    private String decode(String value) {
        String decoded = null;
        try {
@@ -59,9 +58,7 @@ public class EncoderDecoderUnitTest {
        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?", ""));
+        String encodedURL = requestParams.keySet().stream().map(key -> key + "=" + encodeValue(requestParams.get(key))).collect(joining("&", "http://www.baeldung.com?", ""));

        Assert.assertThat(testUrl, CoreMatchers.is(encodedURL));
    }
@@ -72,12 +69,9 @@ public class EncoderDecoderUnitTest {

        String query = url.getQuery();

-        String decodedQuery = Arrays.stream(query.split("&"))
-          .map(param -> param.split("=")[0] + "=" + decode(param.split("=")[1]))
-          .collect(joining("&"));
+        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);
+        Assert.assertEquals("http://www.baeldung.com?key1=value 1&key2=value@!$2&key3=value%3", url.getProtocol() + "://" + url.getHost() + "?" + decodedQuery);
    }

 }
@@ -1,6 +1,5 @@
 package com.baeldung.enums;

-
 import org.junit.Test;

 import java.util.ArrayList;
@@ -0,0 +1,46 @@
+package com.baeldung.hexToAscii;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+public class HexToAscii {
+
+    @Test
+    public static void whenHexToAscii() {
+        String asciiString = "http://www.baeldung.com/jackson-serialize-dates";
+        String hexEquivalent = "687474703a2f2f7777772e6261656c64756e672e636f6d2f6a61636b736f6e2d73657269616c697a652d6461746573";
+
+        assertEquals(asciiString, hexToAscii(hexEquivalent));
+    }
+
+    @Test
+    public static void whenAsciiToHex() {
+        String asciiString = "http://www.baeldung.com/jackson-serialize-dates";
+        String hexEquivalent = "687474703a2f2f7777772e6261656c64756e672e636f6d2f6a61636b736f6e2d73657269616c697a652d6461746573";
+
+        assertEquals(hexEquivalent, asciiToHex(asciiString));
+    }
+
+    //
+
+    private static String asciiToHex(String asciiStr) {
+        char[] chars = asciiStr.toCharArray();
+        StringBuilder hex = new StringBuilder();
+        for (char ch : chars) {
+            hex.append(Integer.toHexString((int) ch));
+        }
+
+        return hex.toString();
+    }
+
+    private static String hexToAscii(String hexStr) {
+        StringBuilder output = new StringBuilder("");
+        for (int i = 0; i < hexStr.length(); i += 2) {
+            String str = hexStr.substring(i, i + 2);
+            output.append((char) Integer.parseInt(str, 16));
+        }
+        return output.toString();
+    }
+
+}
@@ -0,0 +1,118 @@
+package com.baeldung.java.networking.interfaces;
+
+import org.junit.Test;
+
+import java.net.*;
+import java.util.Enumeration;
+import java.util.List;
+
+import static org.junit.Assert.*;
+
+public class NetworkInterfaceManualTest {
+    @Test
+    public void givenName_whenReturnsNetworkInterface_thenCorrect() throws SocketException {
+        NetworkInterface nif = NetworkInterface.getByName("lo");
+        assertNotNull(nif);
+    }
+
+    @Test
+    public void givenInExistentName_whenReturnsNull_thenCorrect() throws SocketException {
+        NetworkInterface nif = NetworkInterface.getByName("inexistent_name");
+        assertNull(nif);
+    }
+
+    @Test
+    public void givenIP_whenReturnsNetworkInterface_thenCorrect() throws SocketException, UnknownHostException {
+        byte[] ip = new byte[] { 127, 0, 0, 1 };
+        NetworkInterface nif = NetworkInterface.getByInetAddress(InetAddress.getByAddress(ip));
+        assertNotNull(nif);
+    }
+
+    @Test
+    public void givenHostName_whenReturnsNetworkInterface_thenCorrect() throws SocketException, UnknownHostException {
+        NetworkInterface nif = NetworkInterface.getByInetAddress(InetAddress.getByName("localhost"));
+        assertNotNull(nif);
+    }
+
+    @Test
+    public void givenLocalHost_whenReturnsNetworkInterface_thenCorrect() throws SocketException, UnknownHostException {
+        NetworkInterface nif = NetworkInterface.getByInetAddress(InetAddress.getLocalHost());
+        assertNotNull(nif);
+    }
+
+    @Test
+    public void givenLoopBack_whenReturnsNetworkInterface_thenCorrect() throws SocketException, UnknownHostException {
+        NetworkInterface nif = NetworkInterface.getByInetAddress(InetAddress.getLoopbackAddress());
+        assertNotNull(nif);
+    }
+
+    @Test
+    public void givenIndex_whenReturnsNetworkInterface_thenCorrect() throws SocketException, UnknownHostException {
+        NetworkInterface nif = NetworkInterface.getByIndex(0);
+        assertNotNull(nif);
+    }
+
+    @Test
+    public void givenInterface_whenReturnsInetAddresses_thenCorrect() throws SocketException, UnknownHostException {
+        NetworkInterface nif = NetworkInterface.getByName("lo");
+        Enumeration<InetAddress> addressEnum = nif.getInetAddresses();
+        InetAddress address = addressEnum.nextElement();
+        assertEquals("127.0.0.1", address.getHostAddress());
+    }
+
+    @Test
+    public void givenInterface_whenReturnsInterfaceAddresses_thenCorrect() throws SocketException, UnknownHostException {
+        NetworkInterface nif = NetworkInterface.getByName("lo");
+
+        List<InterfaceAddress> addressEnum = nif.getInterfaceAddresses();
+        InterfaceAddress address = addressEnum.get(0);
+        InetAddress localAddress = address.getAddress();
+        InetAddress broadCastAddress = address.getBroadcast();
+        assertEquals("127.0.0.1", localAddress.getHostAddress());
+        assertEquals("127.255.255.255", broadCastAddress.getHostAddress());
+    }
+
+    @Test
+    public void givenInterface_whenChecksIfLoopback_thenCorrect() throws SocketException, UnknownHostException {
+        NetworkInterface nif = NetworkInterface.getByName("lo");
+        assertTrue(nif.isLoopback());
+    }
+
+    @Test
+    public void givenInterface_whenChecksIfUp_thenCorrect() throws SocketException, UnknownHostException {
+        NetworkInterface nif = NetworkInterface.getByName("lo");
+        assertTrue(nif.isUp());
+    }
+
+    @Test
+    public void givenInterface_whenChecksIfPointToPoint_thenCorrect() throws SocketException, UnknownHostException {
+        NetworkInterface nif = NetworkInterface.getByName("lo");
+        assertFalse(nif.isPointToPoint());
+    }
+
+    @Test
+    public void givenInterface_whenChecksIfVirtual_thenCorrect() throws SocketException, UnknownHostException {
+        NetworkInterface nif = NetworkInterface.getByName("lo");
+        assertFalse(nif.isVirtual());
+    }
+
+    @Test
+    public void givenInterface_whenChecksMulticastSupport_thenCorrect() throws SocketException, UnknownHostException {
+        NetworkInterface nif = NetworkInterface.getByName("lo");
+        assertTrue(nif.supportsMulticast());
+    }
+
+    @Test
+    public void givenInterface_whenGetsMacAddress_thenCorrect() throws SocketException, UnknownHostException {
+        NetworkInterface nif = NetworkInterface.getByName("lo");
+        byte[] bytes = nif.getHardwareAddress();
+        assertNotNull(bytes);
+    }
+
+    @Test
+    public void givenInterface_whenGetsMTU_thenCorrect() throws SocketException, UnknownHostException {
+        NetworkInterface nif = NetworkInterface.getByName("net0");
+        int mtu = nif.getMTU();
+        assertEquals(1500, mtu);
+    }
+}
@@ -1,6 +1,5 @@
 package com.baeldung.java.networking.udp;

-
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
@@ -4,19 +4,32 @@ import static org.junit.Assert.assertEquals;

 import java.io.IOException;

+import org.junit.After;
+import org.junit.Before;
 import org.junit.Test;

 public class NioEchoIntegrationTest {

+    Process server;
+    EchoClient client;
+
+    @Before
+    public void setup() throws IOException, InterruptedException {
+        server = EchoServer.start();
+        client = EchoClient.start();
+    }
+
    @Test
-    public void givenClient_whenServerEchosMessage_thenCorrect() throws IOException, InterruptedException {
-        Process process = EchoServer.start();
-        EchoClient client = EchoClient.start();
+    public void givenServerClient_whenServerEchosMessage_thenCorrect() {
        String resp1 = client.sendMessage("hello");
        String resp2 = client.sendMessage("world");
        assertEquals("hello", resp1);
        assertEquals("world", resp2);
+    }

-        process.destroy();
+    @After
+    public void teardown() throws IOException {
+        server.destroy();
+        EchoClient.stop();
    }
 }
@@ -4,7 +4,6 @@ import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;

 import java.io.IOException;
-import java.nio.file.CopyOption;
 import java.nio.file.DirectoryNotEmptyException;
 import java.nio.file.FileAlreadyExistsException;
 import java.nio.file.Files;
@@ -12,7 +11,7 @@ import java.nio.file.NoSuchFileException;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.nio.file.StandardCopyOption;
-import java.util.Date;
+import java.util.UUID;

 import org.junit.Test;

@@ -33,7 +32,7 @@ public class FileTest {
    }

    @Test
-    public void givenExistentDirPath_whenConfirmsNotRegularFile_thenCorrect() {
+    public void givenDirPath_whenConfirmsNotRegularFile_thenCorrect() {
        Path p = Paths.get(HOME);
        assertFalse(Files.isRegularFile(p));
    }
@@ -67,7 +66,7 @@ public class FileTest {
    // creating file
    @Test
    public void givenFilePath_whenCreatesNewFile_thenCorrect() throws IOException {
-        String fileName = "myfile_" + new Date().getTime() + ".txt";
+        String fileName = "myfile_" + UUID.randomUUID().toString() + ".txt";
        Path p = Paths.get(HOME + "/" + fileName);
        assertFalse(Files.exists(p));
        Files.createFile(p);
@@ -77,7 +76,7 @@ public class FileTest {

    @Test
    public void givenDirPath_whenCreatesNewDir_thenCorrect() throws IOException {
-        String dirName = "myDir_" + new Date().getTime();
+        String dirName = "myDir_" + UUID.randomUUID().toString();
        Path p = Paths.get(HOME + "/" + dirName);
        assertFalse(Files.exists(p));
        Files.createDirectory(p);
@@ -89,7 +88,7 @@ public class FileTest {

    @Test(expected = NoSuchFileException.class)
    public void givenDirPath_whenFailsToCreateRecursively_thenCorrect() throws IOException {
-        String dirName = "myDir_" + new Date().getTime() + "/subdir";
+        String dirName = "myDir_" + UUID.randomUUID().toString() + "/subdir";
        Path p = Paths.get(HOME + "/" + dirName);
        assertFalse(Files.exists(p));
        Files.createDirectory(p);
@@ -98,7 +97,7 @@ public class FileTest {

    @Test
    public void givenDirPath_whenCreatesRecursively_thenCorrect() throws IOException {
-        Path dir = Paths.get(HOME + "/myDir_" + new Date().getTime());
+        Path dir = Paths.get(HOME + "/myDir_" + UUID.randomUUID().toString());
        Path subdir = dir.resolve("subdir");
        assertFalse(Files.exists(dir));
        assertFalse(Files.exists(subdir));
@@ -119,7 +118,7 @@ public class FileTest {
    }

    @Test
-    public void givenFilePath_whenCreatesTempFileWithDefaultsNaming_thenCorrect() throws IOException {
+    public void givenPath_whenCreatesTempFileWithDefaults_thenCorrect() throws IOException {
        Path p = Paths.get(HOME + "/");
        p = Files.createTempFile(p, null, null);
        // like 8600179353689423985.tmp
@@ -148,7 +147,7 @@ public class FileTest {

    @Test(expected = DirectoryNotEmptyException.class)
    public void givenPath_whenFailsToDeleteNonEmptyDir_thenCorrect() throws IOException {
-        Path dir = Paths.get(HOME + "/emptyDir" + new Date().getTime());
+        Path dir = Paths.get(HOME + "/emptyDir" + UUID.randomUUID().toString());
        Files.createDirectory(dir);
        assertTrue(Files.exists(dir));
        Path file = dir.resolve("file.txt");
@@ -159,15 +158,11 @@ public class FileTest {

    }

-    @Test
+    @Test(expected = NoSuchFileException.class)
    public void givenInexistentFile_whenDeleteFails_thenCorrect() throws IOException {
        Path p = Paths.get(HOME + "/inexistentFile.txt");
        assertFalse(Files.exists(p));
-        try {
-            Files.delete(p);
-        } catch (IOException e) {
-            assertTrue(e instanceof NoSuchFileException);
-        }
+        Files.delete(p);

    }

@@ -182,8 +177,8 @@ public class FileTest {
    // copy file
    @Test
    public void givenFilePath_whenCopiesToNewLocation_thenCorrect() throws IOException {
-        Path dir1 = Paths.get(HOME + "/firstdir_" + new Date().getTime());
-        Path dir2 = Paths.get(HOME + "/otherdir_" + new Date().getTime());
+        Path dir1 = Paths.get(HOME + "/firstdir_" + UUID.randomUUID().toString());
+        Path dir2 = Paths.get(HOME + "/otherdir_" + UUID.randomUUID().toString());
        Files.createDirectory(dir1);
        Files.createDirectory(dir2);
        Path file1 = dir1.resolve("filetocopy.txt");
@@ -198,8 +193,8 @@ public class FileTest {

    @Test(expected = FileAlreadyExistsException.class)
    public void givenPath_whenCopyFailsDueToExistingFile_thenCorrect() throws IOException {
-        Path dir1 = Paths.get(HOME + "/firstdir_" + new Date().getTime());
-        Path dir2 = Paths.get(HOME + "/otherdir_" + new Date().getTime());
+        Path dir1 = Paths.get(HOME + "/firstdir_" + UUID.randomUUID().toString());
+        Path dir2 = Paths.get(HOME + "/otherdir_" + UUID.randomUUID().toString());
        Files.createDirectory(dir1);
        Files.createDirectory(dir2);
        Path file1 = dir1.resolve("filetocopy.txt");
@@ -215,8 +210,8 @@ public class FileTest {
    // moving files
    @Test
    public void givenFilePath_whenMovesToNewLocation_thenCorrect() throws IOException {
-        Path dir1 = Paths.get(HOME + "/firstdir_" + new Date().getTime());
-        Path dir2 = Paths.get(HOME + "/otherdir_" + new Date().getTime());
+        Path dir1 = Paths.get(HOME + "/firstdir_" + UUID.randomUUID().toString());
+        Path dir2 = Paths.get(HOME + "/otherdir_" + UUID.randomUUID().toString());
        Files.createDirectory(dir1);
        Files.createDirectory(dir2);
        Path file1 = dir1.resolve("filetocopy.txt");
@@ -232,8 +227,8 @@ public class FileTest {

    @Test(expected = FileAlreadyExistsException.class)
    public void givenFilePath_whenMoveFailsDueToExistingFile_thenCorrect() throws IOException {
-        Path dir1 = Paths.get(HOME + "/firstdir_" + new Date().getTime());
-        Path dir2 = Paths.get(HOME + "/otherdir_" + new Date().getTime());
+        Path dir1 = Paths.get(HOME + "/firstdir_" + UUID.randomUUID().toString());
+        Path dir2 = Paths.get(HOME + "/otherdir_" + UUID.randomUUID().toString());
        Files.createDirectory(dir1);
        Files.createDirectory(dir2);
        Path file1 = dir1.resolve("filetocopy.txt");
@@ -247,4 +242,5 @@ public class FileTest {
        assertTrue(Files.exists(file2));
        assertFalse(Files.exists(file1));
    }
+
 }
@@ -13,7 +13,7 @@ import java.util.Date;

 import org.junit.Test;

-public class PathTest {
+public class PathManualTest {

    private static final String HOME = System.getProperty("user.home");

@@ -0,0 +1,52 @@
+package com.baeldung.java8;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Consumer;
+
+import org.junit.Test;
+
+public class Java8ForEachTest {
+
+    @Test
+    public void compareForEachMethods_thenPrintResults() {
+
+        List<String> names = new ArrayList<>();
+        names.add("Larry");
+        names.add("Steve");
+        names.add("James");
+        names.add("Conan");
+        names.add("Ellen");
+
+        // Java 5 - for-loop
+        System.out.println("--- Enhanced for-loop ---");
+        for (String name : names) {
+            System.out.println(name);
+        }
+
+        // Java 8 - forEach
+        System.out.println("--- forEach method ---");
+        names.forEach(name -> System.out.println(name));
+
+        // Anonymous inner class that implements Consumer interface
+        System.out.println("--- Anonymous inner class ---");
+        names.forEach(new Consumer<String>() {
+            public void accept(String name) {
+                System.out.println(name);
+            }
+        });
+
+        // Create a Consumer implementation to then use in a forEach method
+        Consumer<String> consumerNames = name -> {
+            System.out.println(name);
+        };
+        System.out.println("--- Implementation of Consumer interface ---");
+        names.forEach(consumerNames);
+
+        // Print elements using a Method Reference
+        System.out.println("--- Method Reference ---");
+        names.forEach(System.out::println);
+
+    }
+
+}
@@ -27,18 +27,14 @@ public class Java8StreamApiUnitTest {

    @Before
    public void init() {
-        productList = Arrays.asList(
-                new Product(23, "potatoes"), new Product(14, "orange"),
-                new Product(13, "lemon"), new Product(23, "bread"),
-                new Product(13, "sugar"));
+        productList = Arrays.asList(new Product(23, "potatoes"), new Product(14, "orange"), new Product(13, "lemon"), new Product(23, "bread"), new Product(13, "sugar"));
    }

    @Test
    public void checkPipeline_whenStreamOneElementShorter_thenCorrect() {

        List<String> list = Arrays.asList("abc1", "abc2", "abc3");
-        long size = list.stream().skip(1)
-                .map(element -> element.substring(0, 3)).count();
+        long size = list.stream().skip(1).map(element -> element.substring(0, 3)).count();
        assertEquals(list.size() - 1, size);
    }

@@ -48,11 +44,10 @@ public class Java8StreamApiUnitTest {
        List<String> list = Arrays.asList("abc1", "abc2", "abc3");

        counter = 0;
-        long sizeFirst = list.stream()
-                .skip(2).map(element -> {
-                    wasCalled();
-                    return element.substring(0, 3);
-                }).count();
+        long sizeFirst = list.stream().skip(2).map(element -> {
+            wasCalled();
+            return element.substring(0, 3);
+        }).count();
        assertEquals(1, counter);

        counter = 0;
@@ -84,7 +79,7 @@ public class Java8StreamApiUnitTest {
        Stream<String> streamOfArray = Stream.of("a", "b", "c");
        assertEquals(3, streamOfArray.count());

-        String[] arr = new String[]{"a", "b", "c"};
+        String[] arr = new String[] { "a", "b", "c" };
        Stream<String> streamOfArrayPart = Arrays.stream(arr, 1, 3);
        assertEquals(2, streamOfArrayPart.count());

@@ -112,7 +107,7 @@ public class Java8StreamApiUnitTest {
        }
        assertEquals("a", streamOfStrings.findFirst().get());

-        Stream<String> streamBuilder = Stream.<String>builder().add("a").add("b").add("c").build();
+        Stream<String> streamBuilder = Stream.<String> builder().add("a").add("b").add("c").build();
        assertEquals(3, streamBuilder.count());

        Stream<String> streamGenerated = Stream.generate(() -> "element").limit(10);
@@ -126,14 +121,13 @@ public class Java8StreamApiUnitTest {
    public void runStreamPipeline_whenOrderIsRight_thenCorrect() {

        List<String> list = Arrays.asList("abc1", "abc2", "abc3");
-        Optional<String> stream = list.stream()
-                .filter(element -> {
-                    log.info("filter() was called");
-                    return element.contains("2");
-                }).map(element -> {
-                    log.info("map() was called");
-                    return element.toUpperCase();
-                }).findFirst();
+        Optional<String> stream = list.stream().filter(element -> {
+            log.info("filter() was called");
+            return element.contains("2");
+        }).map(element -> {
+            log.info("map() was called");
+            return element.toUpperCase();
+        }).findFirst();
    }

    @Test
@@ -145,32 +139,28 @@ public class Java8StreamApiUnitTest {
        int reducedTwoParams = IntStream.range(1, 4).reduce(10, (a, b) -> a + b);
        assertEquals(16, reducedTwoParams);

-        int reducedThreeParams = Stream.of(1, 2, 3)
-                .reduce(10, (a, b) -> a + b, (a, b) -> {
-                    log.info("combiner was called");
-                    return a + b;
-                });
+        int reducedThreeParams = Stream.of(1, 2, 3).reduce(10, (a, b) -> a + b, (a, b) -> {
+            log.info("combiner was called");
+            return a + b;
+        });
        assertEquals(16, reducedThreeParams);

-        int reducedThreeParamsParallel = Arrays.asList(1, 2, 3).parallelStream()
-                .reduce(10, (a, b) -> a + b, (a, b) -> {
-                    log.info("combiner was called");
-                    return a + b;
-                });
+        int reducedThreeParamsParallel = Arrays.asList(1, 2, 3).parallelStream().reduce(10, (a, b) -> a + b, (a, b) -> {
+            log.info("combiner was called");
+            return a + b;
+        });
        assertEquals(36, reducedThreeParamsParallel);
    }

    @Test
    public void collecting_whenAsExpected_thenCorrect() {

-        List<String> collectorCollection = productList.stream()
-                .map(Product::getName).collect(Collectors.toList());
+        List<String> collectorCollection = productList.stream().map(Product::getName).collect(Collectors.toList());

        assertTrue(collectorCollection instanceof List);
        assertEquals(5, collectorCollection.size());

-        String listToString = productList.stream().map(Product::getName)
-                .collect(Collectors.joining(", ", "[", "]"));
+        String listToString = productList.stream().map(Product::getName).collect(Collectors.joining(", ", "[", "]"));

        assertTrue(listToString.contains(",") && listToString.contains("[") && listToString.contains("]"));

@@ -180,36 +170,29 @@ public class Java8StreamApiUnitTest {
        int summingPrice = productList.stream().collect(Collectors.summingInt(Product::getPrice));
        assertEquals(86, summingPrice);

-        IntSummaryStatistics statistics = productList.stream()
-                .collect(Collectors.summarizingInt(Product::getPrice));
+        IntSummaryStatistics statistics = productList.stream().collect(Collectors.summarizingInt(Product::getPrice));
        assertEquals(23, statistics.getMax());

-        Map<Integer, List<Product>> collectorMapOfLists = productList.stream()
-                .collect(Collectors.groupingBy(Product::getPrice));
+        Map<Integer, List<Product>> collectorMapOfLists = productList.stream().collect(Collectors.groupingBy(Product::getPrice));
        assertEquals(3, collectorMapOfLists.keySet().size());

-        Map<Boolean, List<Product>> mapPartioned = productList.stream()
-                .collect(Collectors.partitioningBy(element -> element.getPrice() > 15));
+        Map<Boolean, List<Product>> mapPartioned = productList.stream().collect(Collectors.partitioningBy(element -> element.getPrice() > 15));
        assertEquals(2, mapPartioned.keySet().size());

    }

    @Test(expected = UnsupportedOperationException.class)
    public void collect_whenThrows_thenCorrect() {
-        Set<Product> unmodifiableSet = productList.stream()
-                .collect(Collectors.collectingAndThen(Collectors.toSet(),
-                        Collections::unmodifiableSet));
+        Set<Product> unmodifiableSet = productList.stream().collect(Collectors.collectingAndThen(Collectors.toSet(), Collections::unmodifiableSet));
        unmodifiableSet.add(new Product(4, "tea"));
    }

    @Test
    public void customCollector_whenResultContainsAllElementsFrSource_thenCorrect() {
-        Collector<Product, ?, LinkedList<Product>> toLinkedList =
-                Collector.of(LinkedList::new, LinkedList::add,
-                        (first, second) -> {
-                            first.addAll(second);
-                            return first;
-                        });
+        Collector<Product, ?, LinkedList<Product>> toLinkedList = Collector.of(LinkedList::new, LinkedList::add, (first, second) -> {
+            first.addAll(second);
+            return first;
+        });

        LinkedList<Product> linkedListOfPersons = productList.stream().collect(toLinkedList);
        assertTrue(linkedListOfPersons.containsAll(productList));
@@ -219,23 +202,20 @@ public class Java8StreamApiUnitTest {
    public void parallelStream_whenWorks_thenCorrect() {
        Stream<Product> streamOfCollection = productList.parallelStream();
        boolean isParallel = streamOfCollection.isParallel();
-        boolean haveBigPrice = streamOfCollection.map(product -> product.getPrice() * 12)
-                .anyMatch(price -> price > 200);
+        boolean haveBigPrice = streamOfCollection.map(product -> product.getPrice() * 12).anyMatch(price -> price > 200);
        assertTrue(isParallel && haveBigPrice);
    }

    @Test
    public void parallel_whenIsParallel_thenCorrect() {
-        IntStream intStreamParallel =
-                IntStream.range(1, 150).parallel().map(element -> element * 34);
+        IntStream intStreamParallel = IntStream.range(1, 150).parallel().map(element -> element * 34);
        boolean isParallel = intStreamParallel.isParallel();
        assertTrue(isParallel);
    }

    @Test
    public void parallel_whenIsSequential_thenCorrect() {
-        IntStream intStreamParallel =
-                IntStream.range(1, 150).parallel().map(element -> element * 34);
+        IntStream intStreamParallel = IntStream.range(1, 150).parallel().map(element -> element * 34);
        IntStream intStreamSequential = intStreamParallel.sequential();
        boolean isParallel = intStreamParallel.isParallel();
        assertFalse(isParallel);
@@ -36,7 +36,7 @@ public class Java8StreamsUnitTest {

    @Test
    public void checkStreamCount_whenCreating_givenDifferentSources() {
-        String[] arr = new String[]{"a", "b", "c"};
+        String[] arr = new String[] { "a", "b", "c" };
        Stream<String> streamArr = Arrays.stream(arr);
        assertEquals(streamArr.count(), 3);

@@ -47,14 +47,12 @@ public class Java8StreamsUnitTest {
        assertEquals(count, 9);
    }

-
    @Test
    public void checkStreamCount_whenOperationFilter_thanCorrect() {
        Stream<String> streamFilter = list.stream().filter(element -> element.isEmpty());
        assertEquals(streamFilter.count(), 2);
    }

-
    @Test
    public void checkStreamCount_whenOperationMap_thanCorrect() {
        List<String> uris = new ArrayList<>();
@@ -65,12 +63,10 @@ public class Java8StreamsUnitTest {
        List<Detail> details = new ArrayList<>();
        details.add(new Detail());
        details.add(new Detail());
-        Stream<String> streamFlatMap = details.stream()
-                .flatMap(detail -> detail.getParts().stream());
+        Stream<String> streamFlatMap = details.stream().flatMap(detail -> detail.getParts().stream());
        assertEquals(streamFlatMap.count(), 4);
    }

-
    @Test
    public void checkStreamCount_whenOperationMatch_thenCorrect() {
        boolean isValid = list.stream().anyMatch(element -> element.contains("h"));
@@ -81,7 +77,6 @@ public class Java8StreamsUnitTest {
        assertFalse(isValidTwo);
    }

-
    @Test
    public void checkStreamReducedValue_whenOperationReduce_thenCorrect() {
        List<Integer> integers = new ArrayList<>();
@@ -94,20 +89,17 @@ public class Java8StreamsUnitTest {

    @Test
    public void checkStreamContains_whenOperationCollect_thenCorrect() {
-        List<String> resultList = list.stream()
-                .map(element -> element.toUpperCase())
-                .collect(Collectors.toList());
+        List<String> resultList = list.stream().map(element -> element.toUpperCase()).collect(Collectors.toList());
        assertEquals(resultList.size(), list.size());
        assertTrue(resultList.contains(""));
    }

-
    @Test
    public void checkParallelStream_whenDoWork() {
        list.parallelStream().forEach(element -> doWork(element));
    }

    private void doWork(String string) {
-        assertTrue(true); //just imitate an amount of work
+        assertTrue(true); // just imitate an amount of work
    }
 }
@@ -46,9 +46,7 @@ public class GuavaThreadPoolIntegrationTest {
        ListenableFuture<String> future1 = listeningExecutorService.submit(() -> "Hello");
        ListenableFuture<String> future2 = listeningExecutorService.submit(() -> "World");

-        String greeting = Futures.allAsList(future1, future2).get()
-                .stream()
-                .collect(Collectors.joining(" "));
+        String greeting = Futures.allAsList(future1, future2).get().stream().collect(Collectors.joining(" "));
        assertEquals("Hello World", greeting);

    }
@@ -7,6 +7,8 @@ import java.util.List;
 import org.junit.Assert;
 import org.junit.Test;

+import com.baeldung.equalshashcode.entities.ComplexClass;
+
 public class ComplexClassUnitTest {

    @Test
--- a/Show More
+++ b/Show More