Merge branch 'master' into wiremock_intro

core-java-8/src/main/java/com/baeldung/enums/Pizza.java

@@ -0,0 +1,91 @@
+package com.baeldung.enums;
+
+import java.util.EnumMap;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class Pizza {
+
+    private static EnumSet<PizzaStatusEnum> deliveredPizzaStatuses =
+            EnumSet.of(PizzaStatusEnum.DELIVERED);
+
+    private PizzaStatusEnum status;
+
+    public enum PizzaStatusEnum {
+        ORDERED(5) {
+            @Override
+            public boolean isOrdered() {
+                return true;
+            }
+        },
+        READY(2) {
+            @Override
+            public boolean isReady() {
+                return true;
+            }
+        },
+        DELIVERED(0) {
+            @Override
+            public boolean isDelivered() {
+                return true;
+            }
+        };
+
+        private int timeToDelivery;
+
+        public boolean isOrdered() {
+            return false;
+        }
+
+        public boolean isReady() {
+            return false;
+        }
+
+        public boolean isDelivered() {
+            return false;
+        }
+
+        public int getTimeToDelivery() {
+            return timeToDelivery;
+        }
+
+        PizzaStatusEnum(int timeToDelivery) {
+            this.timeToDelivery = timeToDelivery;
+        }
+    }
+
+    public PizzaStatusEnum getStatus() {
+        return status;
+    }
+
+    public void setStatus(PizzaStatusEnum status) {
+        this.status = status;
+    }
+
+    public boolean isDeliverable() {
+        return this.status.isReady();
+    }
+
+    public void printTimeToDeliver() {
+        System.out.println("Time to delivery is " + this.getStatus().getTimeToDelivery() + " days");
+    }
+
+    public static List<Pizza> getAllUndeliveredPizzas(List<Pizza> input) {
+        return input.stream().filter((s) -> !deliveredPizzaStatuses.contains(s.getStatus())).collect(Collectors.toList());
+    }
+
+    public static EnumMap<PizzaStatusEnum, List<Pizza>> groupPizzaByStatus(List<Pizza> pzList) {
+        return pzList.stream().collect(
+                Collectors.groupingBy(Pizza::getStatus,
+                        () -> new EnumMap<>(PizzaStatusEnum.class), Collectors.toList()));
+    }
+
+    public void deliver() {
+        if (isDeliverable()) {
+            PizzaDeliverySystemConfiguration.getInstance().getDeliveryStrategy().deliver(this);
+            this.setStatus(PizzaStatusEnum.DELIVERED);
+        }
+    }
+
+}

core-java-8/src/main/java/com/baeldung/enums/PizzaDeliveryStrategy.java

@@ -0,0 +1,18 @@
+package com.baeldung.enums;
+
+public enum PizzaDeliveryStrategy {
+    EXPRESS {
+        @Override
+        public void deliver(Pizza pz) {
+            System.out.println("Pizza will be delivered in express mode");
+        }
+    },
+    NORMAL {
+        @Override
+        public void deliver(Pizza pz) {
+            System.out.println("Pizza will be delivered in normal mode");
+        }
+    };
+
+    public abstract void deliver(Pizza pz);
+}

core-java-8/src/main/java/com/baeldung/enums/PizzaDeliverySystemConfiguration.java

@@ -0,0 +1,22 @@
+package com.baeldung.enums;
+
+
+public enum PizzaDeliverySystemConfiguration {
+    INSTANCE;
+
+    PizzaDeliverySystemConfiguration() {
+        // Do the configuration initialization which
+        // involves overriding defaults like delivery strategy
+    }
+
+    private PizzaDeliveryStrategy deliveryStrategy = PizzaDeliveryStrategy.NORMAL;
+
+    public static PizzaDeliverySystemConfiguration getInstance() {
+        return INSTANCE;
+    }
+
+    public PizzaDeliveryStrategy getDeliveryStrategy() {
+        return deliveryStrategy;
+    }
+
+}

core-java-8/src/main/java/com/baeldung/java_8_features/Address.java

@@ -0,0 +1,14 @@
+package com.baeldung.java_8_features;
+
+public class Address {
+
+    private String street;
+
+    public String getStreet() {
+        return street;
+    }
+
+    public void setStreet(String street) {
+        this.street = street;
+    }
+}

core-java-8/src/main/java/com/baeldung/java_8_features/CustomException.java

@@ -0,0 +1,4 @@
+package com.baeldung.java_8_features;
+
+public class CustomException extends RuntimeException {
+}

core-java-8/src/main/java/com/baeldung/java_8_features/Detail.java

@@ -0,0 +1,13 @@
+package com.baeldung.java_8_features;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class Detail {
+
+    private static final List<String> PARTS = Arrays.asList("turbine", "pump");
+
+    public List<String> getParts() {
+        return PARTS;
+    }
+}

core-java-8/src/main/java/com/baeldung/java_8_features/OptionalAddress.java

@@ -0,0 +1,16 @@
+package com.baeldung.java_8_features;
+
+import java.util.Optional;
+
+public class OptionalAddress {
+
+    private String street;
+
+    public Optional<String> getStreet() {
+        return Optional.ofNullable(street);
+    }
+
+    public void setStreet(String street) {
+        this.street = street;
+    }
+}

core-java-8/src/main/java/com/baeldung/java_8_features/OptionalUser.java

@@ -0,0 +1,16 @@
+package com.baeldung.java_8_features;
+
+import java.util.Optional;
+
+public class OptionalUser {
+
+    private OptionalAddress address;
+
+    public Optional<OptionalAddress> getAddress() {
+        return Optional.of(address);
+    }
+
+    public void setAddress(OptionalAddress address) {
+        this.address = address;
+    }
+}

core-java-8/src/main/java/com/baeldung/java_8_features/User.java

@@ -0,0 +1,40 @@
+package com.baeldung.java_8_features;
+
+import java.util.Optional;
+
+public class User {
+
+    private String name;
+
+    private Address address;
+
+    public Address getAddress() {
+        return address;
+    }
+
+    public void setAddress(Address address) {
+        this.address = address;
+    }
+
+    public User() {
+    }
+
+    public User(String name) {
+        this.name = name;
+    }
+
+    public static boolean isRealUser(User user) {
+        return true;
+    }
+
+    public String getOrThrow() {
+        String value = null;
+        Optional<String> valueOpt = Optional.ofNullable(value);
+        String result = valueOpt.orElseThrow(CustomException::new).toUpperCase();
+        return result;
+    }
+
+    public boolean isLegalName(String name) {
+        return name.length() > 3 && name.length() < 16;
+    }
+}

core-java-8/src/main/java/com/baeldung/java_8_features/Vehicle.java

@@ -0,0 +1,18 @@
+package com.baeldung.java_8_features;
+
+public interface Vehicle {
+
+    void moveTo(long altitude, long longitude);
+
+    static String producer() {
+        return "N&F Vehicles";
+    }
+
+    default long[] startPosition() {
+        return new long[]{23, 15};
+    }
+
+    default String getOverview() {
+        return "ATV made by " + producer();
+    }
+}

core-java-8/src/main/java/com/baeldung/java_8_features/VehicleImpl.java

@@ -0,0 +1,9 @@
+package com.baeldung.java_8_features;
+
+public class VehicleImpl implements  Vehicle {
+
+    @Override
+    public void moveTo(long altitude, long longitude) {
+        //do nothing
+    }
+}

core-java-8/src/test/java/com/baeldung/enums/PizzaTest.java

@@ -0,0 +1,80 @@
+package com.baeldung.enums;
+
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.EnumMap;
+import java.util.List;
+
+import static junit.framework.TestCase.assertTrue;
+
+public class PizzaTest {
+
+    @Test
+    public void givenPizaOrder_whenReady_thenDeliverable() {
+        Pizza testPz = new Pizza();
+        testPz.setStatus(Pizza.PizzaStatusEnum.READY);
+        assertTrue(testPz.isDeliverable());
+    }
+
+    @Test
+    public void givenPizaOrders_whenRetrievingUnDeliveredPzs_thenCorrectlyRetrieved() {
+        List<Pizza> pzList = new ArrayList<>();
+        Pizza pz1 = new Pizza();
+        pz1.setStatus(Pizza.PizzaStatusEnum.DELIVERED);
+
+        Pizza pz2 = new Pizza();
+        pz2.setStatus(Pizza.PizzaStatusEnum.ORDERED);
+
+        Pizza pz3 = new Pizza();
+        pz3.setStatus(Pizza.PizzaStatusEnum.ORDERED);
+
+        Pizza pz4 = new Pizza();
+        pz4.setStatus(Pizza.PizzaStatusEnum.READY);
+
+        pzList.add(pz1);
+        pzList.add(pz2);
+        pzList.add(pz3);
+        pzList.add(pz4);
+
+        List<Pizza> undeliveredPzs = Pizza.getAllUndeliveredPizzas(pzList);
+        assertTrue(undeliveredPzs.size() == 3);
+    }
+
+    @Test
+    public void givenPizaOrders_whenGroupByStatusCalled_thenCorrectlyGrouped() {
+
+        List<Pizza> pzList = new ArrayList<>();
+        Pizza pz1 = new Pizza();
+        pz1.setStatus(Pizza.PizzaStatusEnum.DELIVERED);
+
+        Pizza pz2 = new Pizza();
+        pz2.setStatus(Pizza.PizzaStatusEnum.ORDERED);
+
+        Pizza pz3 = new Pizza();
+        pz3.setStatus(Pizza.PizzaStatusEnum.ORDERED);
+
+        Pizza pz4 = new Pizza();
+        pz4.setStatus(Pizza.PizzaStatusEnum.READY);
+
+        pzList.add(pz1);
+        pzList.add(pz2);
+        pzList.add(pz3);
+        pzList.add(pz4);
+
+        EnumMap<Pizza.PizzaStatusEnum, List<Pizza>> map = Pizza.groupPizzaByStatus(pzList);
+        assertTrue(map.get(Pizza.PizzaStatusEnum.DELIVERED).size() == 1);
+        assertTrue(map.get(Pizza.PizzaStatusEnum.ORDERED).size() == 2);
+        assertTrue(map.get(Pizza.PizzaStatusEnum.READY).size() == 1);
+    }
+
+    @Test
+    public void givenPizaOrder_whenDelivered_thenPizzaGetsDeliveredAndStatusChanges() {
+        Pizza pz = new Pizza();
+        pz.setStatus(Pizza.PizzaStatusEnum.READY);
+        pz.deliver();
+        assertTrue(pz.getStatus() == Pizza.PizzaStatusEnum.DELIVERED);
+    }
+
+}

core-java-8/src/test/java/com/baeldung/java8/Java8DefaultStaticIntefaceMethodsTest.java

@@ -0,0 +1,27 @@
+package com.baeldung.java8;
+
+import com.baeldung.java_8_features.Vehicle;
+import com.baeldung.java_8_features.VehicleImpl;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class Java8DefaultStaticIntefaceMethodsTest {
+
+    @Test
+    public void callStaticInterfaceMethdosMethods_whenExpectedResults_thenCorrect() {
+        Vehicle vehicle = new VehicleImpl();
+        String overview = vehicle.getOverview();
+        long[] startPosition = vehicle.startPosition();
+
+        assertEquals(overview, "ATV made by N&F Vehicles");
+        assertEquals(startPosition[0], 23);
+        assertEquals(startPosition[1], 15);
+    }
+
+    @Test
+    public void callDefaultInterfaceMethods_whenExpectedResults_thenCorrect() {
+        String producer = Vehicle.producer();
+        assertEquals(producer, "N&F Vehicles");
+    }
+}

core-java-8/src/test/java/com/baeldung/java8/Java8MethodReferenceTest.java

@@ -0,0 +1,67 @@
+package com.baeldung.java8;
+
+import com.baeldung.java_8_features.User;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class Java8MethodReferenceTest {
+
+    private List<String> list;
+
+    @Before
+    public void init() {
+        list = new ArrayList<>();
+        list.add("One");
+        list.add("OneAndOnly");
+        list.add("Derek");
+        list.add("Change");
+        list.add("factory");
+        list.add("justBefore");
+        list.add("Italy");
+        list.add("Italy");
+        list.add("Thursday");
+        list.add("");
+        list.add("");
+    }
+
+    @Test
+    public void checkStaticMethodReferences_whenWork_thenCorrect() {
+
+        List<User> users = new ArrayList<>();
+        users.add(new User());
+        users.add(new User());
+        boolean isReal = users.stream().anyMatch(u -> User.isRealUser(u));
+        boolean isRealRef = users.stream().anyMatch(User::isRealUser);
+        assertTrue(isReal);
+        assertTrue(isRealRef);
+    }
+
+    @Test
+    public void checkInstanceMethodReferences_whenWork_thenCorrect() {
+        User user = new User();
+        boolean isLegalName = list.stream().anyMatch(user::isLegalName);
+        assertTrue(isLegalName);
+    }
+
+    @Test
+    public void checkParticularTypeReferences_whenWork_thenCorrect() {
+        long count = list.stream().filter(String::isEmpty).count();
+        assertEquals(count, 2);
+    }
+
+    @Test
+    public void checkConstructorReferences_whenWork_thenCorrect() {
+        Stream<User> stream = list.stream().map(User::new);
+        List<User> userList = stream.collect(Collectors.toList());
+        assertEquals(userList.size(), list.size());
+        assertTrue(userList.get(0) instanceof User);
+    }
+}

core-java-8/src/test/java/com/baeldung/java8/Java8OptionalTest.java

@@ -0,0 +1,118 @@
+package com.baeldung.java8;
+
+import com.baeldung.java_8_features.*;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+import static org.junit.Assert.*;
+
+public class Java8OptionalTest {
+
+    private List<String> list;
+
+    @Before
+    public void init() {
+        list = new ArrayList<>();
+        list.add("One");
+        list.add("OneAndOnly");
+        list.add("Derek");
+        list.add("Change");
+        list.add("factory");
+        list.add("justBefore");
+        list.add("Italy");
+        list.add("Italy");
+        list.add("Thursday");
+        list.add("");
+        list.add("");
+    }
+
+    @Test
+    public void checkOptional_whenAsExpected_thenCorrect() {
+
+        Optional<String> optionalEmpty = Optional.empty();
+        assertFalse(optionalEmpty.isPresent());
+
+        String str = "value";
+        Optional<String> optional = Optional.of(str);
+        assertEquals(optional.get(), "value");
+
+        Optional<String> optionalNullable = Optional.ofNullable(str);
+        Optional<String> optionalNull = Optional.ofNullable(null);
+        assertEquals(optionalNullable.get(), "value");
+        assertFalse(optionalNull.isPresent());
+
+        List<String> listOpt = Optional.of(list).orElse(new ArrayList<>());
+        List<String> listNull = null;
+        List<String> listOptNull = Optional.ofNullable(listNull).orElse(new ArrayList<>());
+        assertTrue(listOpt == list);
+        assertTrue(listOptNull.isEmpty());
+
+        Optional<User> user = Optional.ofNullable(getUser());
+        String result = user.map(User::getAddress)
+                .map(Address::getStreet)
+                .orElse("not specified");
+        assertEquals(result, "1st Avenue");
+
+        Optional<OptionalUser> optionalUser = Optional.ofNullable(getOptionalUser());
+        String resultOpt = optionalUser.flatMap(OptionalUser::getAddress)
+                .flatMap(OptionalAddress::getStreet)
+                .orElse("not specified");
+        assertEquals(resultOpt, "1st Avenue");
+
+        Optional<User> userNull = Optional.ofNullable(getUserNull());
+        String resultNull = userNull.map(User::getAddress)
+                .map(Address::getStreet)
+                .orElse("not specified");
+        assertEquals(resultNull, "not specified");
+
+        Optional<OptionalUser> optionalUserNull = Optional.ofNullable(getOptionalUserNull());
+        String resultOptNull = optionalUserNull.flatMap(OptionalUser::getAddress)
+                .flatMap(OptionalAddress::getStreet)
+                .orElse("not specified");
+        assertEquals(resultOptNull, "not specified");
+
+    }
+
+    @Test(expected = CustomException.class)
+    public void callMethod_whenCustomException_thenCorrect() {
+        User user = new User();
+        String result = user.getOrThrow();
+    }
+
+    private User getUser() {
+        User user = new User();
+        Address address = new Address();
+        address.setStreet("1st Avenue");
+        user.setAddress(address);
+        return user;
+    }
+
+    private OptionalUser getOptionalUser() {
+        OptionalUser user = new OptionalUser();
+        OptionalAddress address = new OptionalAddress();
+        address.setStreet("1st Avenue");
+        user.setAddress(address);
+        return user;
+    }
+
+    private OptionalUser getOptionalUserNull() {
+        OptionalUser user = new OptionalUser();
+        OptionalAddress address = new OptionalAddress();
+        address.setStreet(null);
+        user.setAddress(address);
+        return user;
+    }
+
+    private User getUserNull() {
+        User user = new User();
+        Address address = new Address();
+        address.setStreet(null);
+        user.setAddress(address);
+        return user;
+    }
+
+}

core-java-8/src/test/java/com/baeldung/java8/Java8StreamsTest.java

@@ -0,0 +1,113 @@
+package com.baeldung.java8;
+
+import com.baeldung.java_8_features.Detail;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.junit.Assert.*;
+
+public class Java8StreamsTest {
+
+    private List<String> list;
+
+    @Before
+    public void init() {
+        list = new ArrayList<>();
+        list.add("One");
+        list.add("OneAndOnly");
+        list.add("Derek");
+        list.add("Change");
+        list.add("factory");
+        list.add("justBefore");
+        list.add("Italy");
+        list.add("Italy");
+        list.add("Thursday");
+        list.add("");
+        list.add("");
+    }
+
+    @Test
+    public void checkStreamCount_whenCreating_givenDifferentSources() {
+        String[] arr = new String[]{"a", "b", "c"};
+        Stream<String> streamArr = Arrays.stream(arr);
+        assertEquals(streamArr.count(), 3);
+
+        Stream<String> streamOf = Stream.of("a", "b", "c");
+        assertEquals(streamOf.count(), 3);
+
+        long count = list.stream().distinct().count();
+        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<>();
+        uris.add("C:\\My.txt");
+        Stream<Path> streamMap = uris.stream().map(uri -> Paths.get(uri));
+        assertEquals(streamMap.count(), 1);
+
+        List<Detail> details = new ArrayList<>();
+        details.add(new Detail());
+        details.add(new Detail());
+        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"));
+        boolean isValidOne = list.stream().allMatch(element -> element.contains("h"));
+        boolean isValidTwo = list.stream().noneMatch(element -> element.contains("h"));
+        assertTrue(isValid);
+        assertFalse(isValidOne);
+        assertFalse(isValidTwo);
+    }
+
+
+    @Test
+    public void checkStreamReducedValue_whenOperationReduce_thenCorrect() {
+        List<Integer> integers = new ArrayList<>();
+        integers.add(1);
+        integers.add(1);
+        integers.add(1);
+        Integer reduced = integers.stream().reduce(23, (a, b) -> a + b);
+        assertTrue(reduced == 26);
+    }
+
+    @Test
+    public void checkStreamContains_whenOperationCollect_thenCorrect() {
+        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
+    }
+}

core-java/pom.xml

@@ -9,7 +9,11 @@
     <dependencies>
 
         <!-- utils -->
-
+        <dependency>
+            <groupId>net.sourceforge.collections</groupId>
+            <artifactId>collections-generic</artifactId>
+            <version>4.01</version>
+        </dependency>
         <dependency>
             <groupId>com.google.guava</groupId>
             <artifactId>guava</artifactId>

core-java/src/main/java/com/baeldung/enums/Pizza.java

@@ -0,0 +1,117 @@
+package com.baeldung.enums;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.apache.commons.collections15.CollectionUtils;
+import org.apache.commons.collections15.Predicate;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.EnumMap;
+import java.util.EnumSet;
+import java.util.List;
+
+public class Pizza {
+
+    private static EnumSet<PizzaStatusEnum> undeliveredPizzaStatuses =
+      EnumSet.of(PizzaStatusEnum.ORDERED, PizzaStatusEnum.READY);
+
+    private PizzaStatusEnum status;
+
+    @JsonFormat(shape = JsonFormat.Shape.OBJECT)
+    public enum PizzaStatusEnum {
+        ORDERED (5){
+            @Override
+            public boolean isOrdered() {
+                return true;
+            }
+        },
+        READY (2){
+            @Override
+            public boolean isReady() {
+                return true;
+            }
+        },
+        DELIVERED (0){
+            @Override
+            public boolean isDelivered() {
+                return true;
+            }
+        };
+
+        private int timeToDelivery;
+
+        public boolean isOrdered() {return false;}
+
+        public boolean isReady() {return false;}
+
+        public boolean isDelivered(){return  false;}
+        @JsonProperty("timeToDelivery")
+        public int getTimeToDelivery() {
+            return timeToDelivery;
+        }
+
+        private PizzaStatusEnum (int timeToDelivery) {
+            this.timeToDelivery = timeToDelivery;
+        }
+    }
+
+    public PizzaStatusEnum getStatus() {
+        return status;
+    }
+
+    public void setStatus(PizzaStatusEnum status) {
+        this.status = status;
+    }
+
+    public boolean isDeliverable() {
+        return this.status.isReady();
+    }
+
+    public void printTimeToDeliver() {
+        System.out.println("Time to delivery is " + this.getStatus().getTimeToDelivery() + " days");
+    }
+
+    public static List<Pizza> getAllUndeliveredPizza(List<Pizza> input) {
+        List<Pizza> undelivered = input;
+        CollectionUtils.filter(undelivered, thatAreNotDelivered());
+        return undelivered;
+    }
+
+    public static EnumMap<PizzaStatusEnum, List<Pizza>> groupPizzaByStatus(List<Pizza> pizzaList) {
+        EnumMap<PizzaStatusEnum, List<Pizza>> pzByStatus = new EnumMap<PizzaStatusEnum, List<Pizza>>(PizzaStatusEnum.class);
+        for (Pizza pz : pizzaList) {
+            PizzaStatusEnum status = pz.getStatus();
+
+            if (pzByStatus.containsKey(status)) {
+                pzByStatus.get(status).add(pz);
+            } else {
+                List<Pizza> newPzList = new ArrayList<Pizza>();
+                newPzList.add(pz);
+                pzByStatus.put(status, newPzList);
+            }
+        }
+        return pzByStatus;
+    }
+
+    public void deliver() {
+        if (isDeliverable()) {
+            PizzaDeliverySystemConfiguration.getInstance().getDeliveryStrategy().deliver(this);
+            this.setStatus(PizzaStatusEnum.DELIVERED);
+        }
+    }
+
+    public static String getJsonString(Pizza pz) throws IOException {
+        ObjectMapper mapper = new ObjectMapper();
+        return mapper.writerWithDefaultPrettyPrinter().writeValueAsString(pz);
+    }
+
+    private static Predicate<Pizza> thatAreNotDelivered() {
+        return new Predicate<Pizza>() {
+            public boolean evaluate(Pizza entry) {
+                return undeliveredPizzaStatuses.contains(entry.getStatus());
+            }
+        };
+    }
+}

core-java/src/main/java/com/baeldung/enums/PizzaDeliveryStrategy.java

@@ -0,0 +1,18 @@
+package com.baeldung.enums;
+
+public enum PizzaDeliveryStrategy {
+    EXPRESS {
+        @Override
+        public void deliver(Pizza pz) {
+            System.out.println("Pizza will be delivered in express mode");
+        }
+    },
+    NORMAL {
+        @Override
+        public void deliver(Pizza pz) {
+            System.out.println("Pizza will be delivered in normal mode");
+        }
+    };
+
+    public abstract void deliver(Pizza pz);
+}

core-java/src/main/java/com/baeldung/enums/PizzaDeliverySystemConfiguration.java

@@ -0,0 +1,20 @@
+package com.baeldung.enums;
+
+public enum PizzaDeliverySystemConfiguration {
+    INSTANCE ;
+    private PizzaDeliverySystemConfiguration() {
+        //Do the configuration initialization which
+        // involves overriding defaults like delivery strategy
+    }
+
+    private PizzaDeliveryStrategy deliveryStrategy = PizzaDeliveryStrategy.NORMAL;
+
+    public static PizzaDeliverySystemConfiguration getInstance() {
+        return INSTANCE;
+    }
+
+    public PizzaDeliveryStrategy getDeliveryStrategy() {
+        return deliveryStrategy;
+    }
+
+}

core-java/src/test/java/org/baeldung/java/enums/PizzaTest.java

@@ -0,0 +1,80 @@
+package org.baeldung.java.enums;
+
+
+import com.baeldung.enums.Pizza;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.EnumMap;
+import java.util.List;
+
+import static junit.framework.TestCase.assertTrue;
+
+
+public class PizzaTest {
+    @Test
+    public void givenPizaOrder_whenReady_thenDeliverable() {
+        Pizza testPz = new Pizza();
+        testPz.setStatus(Pizza.PizzaStatusEnum.READY);
+        assertTrue(testPz.isDeliverable());
+    }
+
+    @Test
+    public void givenPizaOrders_whenRetrievingUnDeliveredPzs_thenCorrectlyRetrieved() {
+        List<Pizza> pzList = new ArrayList<Pizza>();
+        Pizza pz1 = new Pizza();
+        pz1.setStatus(Pizza.PizzaStatusEnum.DELIVERED);
+
+        Pizza pz2 = new Pizza();
+        pz2.setStatus(Pizza.PizzaStatusEnum.ORDERED);
+
+        Pizza pz3 = new Pizza();
+        pz3.setStatus(Pizza.PizzaStatusEnum.ORDERED);
+
+        Pizza pz4 = new Pizza();
+        pz4.setStatus(Pizza.PizzaStatusEnum.READY);
+
+        pzList.add(pz1);
+        pzList.add(pz2);
+        pzList.add(pz3);
+        pzList.add(pz4);
+
+        List<Pizza> undeliveredPzs = Pizza.getAllUndeliveredPizza(pzList);
+        assertTrue(undeliveredPzs.size() == 3);
+    }
+
+    @Test
+    public void givenPizaOrders_whenGroupByStatusCalled_thenCorrectlyGrouped() {
+
+        List<Pizza> pzList = new ArrayList<Pizza>();
+        Pizza pz1 = new Pizza();
+        pz1.setStatus(Pizza.PizzaStatusEnum.DELIVERED);
+
+        Pizza pz2 = new Pizza();
+        pz2.setStatus(Pizza.PizzaStatusEnum.ORDERED);
+
+        Pizza pz3 = new Pizza();
+        pz3.setStatus(Pizza.PizzaStatusEnum.ORDERED);
+
+        Pizza pz4 = new Pizza();
+        pz4.setStatus(Pizza.PizzaStatusEnum.READY);
+
+        pzList.add(pz1);
+        pzList.add(pz2);
+        pzList.add(pz3);
+        pzList.add(pz4);
+
+        EnumMap<Pizza.PizzaStatusEnum, List<Pizza>> map = Pizza.groupPizzaByStatus(pzList);
+        assertTrue(map.get(Pizza.PizzaStatusEnum.DELIVERED).size() == 1);
+        assertTrue(map.get(Pizza.PizzaStatusEnum.ORDERED).size() == 2);
+        assertTrue(map.get(Pizza.PizzaStatusEnum.READY).size() == 1);
+    }
+
+    @Test
+    public void givenPizaOrder_whenDelivered_thenPizzaGetsDeliveredAndStatusChanges() {
+        Pizza pz = new Pizza();
+        pz.setStatus(Pizza.PizzaStatusEnum.READY);
+        pz.deliver();
+        assertTrue(pz.getStatus() == Pizza.PizzaStatusEnum.DELIVERED);
+    }
+}

httpclient/src/test/java/org/baeldung/httpclient/HttpClientMultipartTest.java

@@ -79,18 +79,22 @@ public class HttpClientMultipartTest {
     @Test
     public final void givenFileandMultipleTextParts_whenUploadwithAddPart_thenNoExceptions() throws IOException {
         final URL url = Thread.currentThread().getContextClassLoader().getResource("uploads/" + TEXTFILENAME);
+
         final File file = new File(url.getPath());
         final FileBody fileBody = new FileBody(file, ContentType.DEFAULT_BINARY);
         final StringBody stringBody1 = new StringBody("This is message 1", ContentType.MULTIPART_FORM_DATA);
         final StringBody stringBody2 = new StringBody("This is message 2", ContentType.MULTIPART_FORM_DATA);
+        //
         final MultipartEntityBuilder builder = MultipartEntityBuilder.create();
         builder.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);
         builder.addPart("upfile", fileBody);
         builder.addPart("text1", stringBody1);
         builder.addPart("text2", stringBody2);
         final HttpEntity entity = builder.build();
+        //
         post.setEntity(entity);
         response = client.execute(post);
+
         final int statusCode = response.getStatusLine().getStatusCode();
         final String responseString = getContent();
         final String contentTypeInHeader = getContentTypeHeader();
@@ -124,7 +128,7 @@ public class HttpClientMultipartTest {
     }
 
     @Test
-    public final void givenFileandInputStreamandText_whenUploadwithAddBinaryBodyandAddTextBody_ThenNoException() throws ClientProtocolException, IOException {
+    public final void givenFileAndInputStreamandText_whenUploadwithAddBinaryBodyandAddTextBody_ThenNoException() throws ClientProtocolException, IOException {
         final URL url = Thread.currentThread().getContextClassLoader().getResource("uploads/" + ZIPFILENAME);
         final URL url2 = Thread.currentThread().getContextClassLoader().getResource("uploads/" + IMAGEFILENAME);
         final InputStream inputStream = new FileInputStream(url.getPath());

jackson/pom.xml

@@ -1,5 +1,5 @@
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <groupId>com.baeldung</groupId>
     <artifactId>jackson</artifactId>
@@ -22,6 +22,12 @@
             <artifactId>commons-io</artifactId>
             <version>2.4</version>
         </dependency>
+        <!--jackson for xml-->
+        <dependency>
+            <groupId>com.fasterxml.jackson.dataformat</groupId>
+            <artifactId>jackson-dataformat-xml</artifactId>
+            <version>2.7.4</version>
+        </dependency>
 
         <dependency>
             <groupId>org.apache.commons</groupId>
@@ -55,12 +61,12 @@
             <groupId>com.fasterxml.jackson.datatype</groupId>
             <artifactId>jackson-datatype-joda</artifactId>
             <version>${jackson.version}</version>
-		</dependency>
+        </dependency>
 
-		<dependency>
-			<groupId>com.fasterxml.jackson.module</groupId>
-			<artifactId>jackson-module-jsonSchema</artifactId>
-			<version>2.7.2</version>
+        <dependency>
+            <groupId>com.fasterxml.jackson.module</groupId>
+            <artifactId>jackson-module-jsonSchema</artifactId>
+            <version>2.7.2</version>
         </dependency>
 
         <dependency>

jackson/src/test/java/com/baeldung/jackson/xml/TestXMLSerializeDeserialize.java

@@ -0,0 +1,86 @@
+package com.baeldung.jackson.xml;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+
+import org.junit.Test;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.dataformat.xml.XmlMapper;
+
+public class TestXMLSerializeDeserialize {
+
+    @Test
+    public void whenJavaSerializedToXmlStr_thenCorrect() throws JsonProcessingException {
+        XmlMapper xmlMapper = new XmlMapper();
+        String xml = xmlMapper.writeValueAsString(new SimpleBean());
+        assertNotNull(xml);
+    }
+
+    @Test
+    public void whenJavaSerializedToXmlFile_thenCorrect() throws IOException {
+        XmlMapper xmlMapper = new XmlMapper();
+        xmlMapper.writeValue(new File("target/simple_bean.xml"), new SimpleBean());
+        File file = new File("target/simple_bean.xml");
+        assertNotNull(file);
+    }
+
+    @Test
+    public void whenJavaGotFromXmlStr_thenCorrect() throws IOException {
+        XmlMapper xmlMapper = new XmlMapper();
+        SimpleBean value = xmlMapper.readValue(
+                "<SimpleBean><x>1</x><y>2</y></SimpleBean>", SimpleBean.class);
+        assertTrue(value.getX() == 1 && value.getY() == 2);
+    }
+
+    @Test
+    public void whenJavaGotFromXmlFile_thenCorrect() throws IOException {
+        File file = new File("src/test/resources/simple_bean.xml");
+        XmlMapper xmlMapper = new XmlMapper();
+        String xml = inputStreamToString(new FileInputStream(file));
+        SimpleBean value = xmlMapper.readValue(xml, SimpleBean.class);
+        assertTrue(value.getX() == 1 && value.getY() == 2);
+    }
+
+    private static String inputStreamToString(InputStream is) throws IOException {
+        BufferedReader br;
+        StringBuilder sb = new StringBuilder();
+
+        String line;
+        br = new BufferedReader(new InputStreamReader(is));
+        while ((line = br.readLine()) != null) {
+            sb.append(line);
+        }
+        br.close();
+        return sb.toString();
+    }
+}
+
+class SimpleBean {
+    private int x = 1;
+    private int y = 2;
+
+    public int getX() {
+        return x;
+    }
+
+    public void setX(int x) {
+        this.x = x;
+    }
+
+    public int getY() {
+        return y;
+    }
+
+    public void setY(int y) {
+        this.y = y;
+    }
+
+}

jackson/src/test/resources/simple_bean.xml

@@ -0,0 +1,4 @@
+<SimpleBean>
+ <x>1</x>
+ <y>2</y>
+</SimpleBean>

jsf/.gitignore

@@ -0,0 +1,2 @@
+/target
+*.iml

jsf/pom.xml

@@ -0,0 +1,130 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>parent-modules</artifactId>
+        <groupId>com.baeldung</groupId>
+        <version>1.0.0-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>jsf</artifactId>
+    <version>0.1-SNAPSHOT</version>
+    <packaging>war</packaging>
+    <dependencies>
+        <!-- JSF -->
+
+        <dependency>
+            <groupId>com.sun.faces</groupId>
+            <artifactId>jsf-api</artifactId>
+            <version>${com.sun.faces.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.sun.faces</groupId>
+            <artifactId>jsf-impl</artifactId>
+            <version>${com.sun.faces.version}</version>
+        </dependency>
+
+        <!-- Spring -->
+
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-web</artifactId>
+            <version>${org.springframework.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-webmvc</artifactId>
+            <version>${org.springframework.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-websocket</artifactId>
+            <version>${org.springframework.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-messaging</artifactId>
+            <version>${org.springframework.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-web</artifactId>
+            <version>${org.springframework.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>javax.servlet</groupId>
+            <artifactId>javax.servlet-api</artifactId>
+            <scope>provided</scope>
+            <version>${javax.servlet.version}</version>
+        </dependency>
+
+        <!-- logging -->
+
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-api</artifactId>
+            <version>${org.slf4j.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>ch.qos.logback</groupId>
+            <artifactId>logback-classic</artifactId>
+            <version>${logback.version}</version>
+            <!-- <scope>runtime</scope> -->
+        </dependency>
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>jcl-over-slf4j</artifactId>
+            <version>${org.slf4j.version}</version>
+            <!-- <scope>runtime</scope> --> <!-- some spring dependencies need to compile against jcl -->
+        </dependency>
+        <dependency> <!-- needed to bridge to slf4j for projects that use the log4j APIs directly -->
+            <groupId>org.slf4j</groupId>
+            <artifactId>log4j-over-slf4j</artifactId>
+            <version>${org.slf4j.version}</version>
+        </dependency>
+    </dependencies>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>${maven-compiler-plugin.version}</version>
+                <configuration>
+                    <source>1.8</source>
+                    <target>1.8</target>
+                </configuration>
+            </plugin>
+
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-war-plugin</artifactId>
+                <version>${maven-war-plugin.version}</version>
+                <configuration>
+                    <failOnMissingWebXml>false</failOnMissingWebXml>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+    <properties>
+        <!-- Spring -->
+        <org.springframework.version>4.2.5.RELEASE</org.springframework.version>
+
+        <!-- JSF -->
+        <com.sun.faces.version>2.1.7</com.sun.faces.version>
+
+        <!-- logging -->
+        <org.slf4j.version>1.7.13</org.slf4j.version>
+        <logback.version>1.1.3</logback.version>
+
+        <!--Tomcat-->
+        <javax.servlet.version>3.1.0</javax.servlet.version>
+
+        <!-- maven plugins -->
+        <maven-compiler-plugin.version>3.5.1</maven-compiler-plugin.version>
+        <maven-war-plugin.version>2.6</maven-war-plugin.version>
+
+    </properties>
+</project>

jsf/src/main/java/com/baeldung/springintegration/config/MainWebAppInitializer.java

@@ -0,0 +1,36 @@
+package com.baeldung.springintegration.config;
+
+import com.sun.faces.config.FacesInitializer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.web.WebApplicationInitializer;
+import org.springframework.web.context.ContextLoaderListener;
+import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
+
+import javax.servlet.ServletContext;
+import javax.servlet.ServletException;
+import java.util.Set;
+
+public class MainWebAppInitializer extends FacesInitializer implements WebApplicationInitializer {
+    private static final Logger LOGGER = LoggerFactory.getLogger(MainWebAppInitializer.class);
+
+    @Override
+    public void onStartup(Set<Class<?>> classes, ServletContext servletContext) throws ServletException {
+        super.onStartup(classes, servletContext);
+    }
+
+    /**
+     * Register and configure all Servlet container components necessary to power the web application.
+     */
+    @Override
+    public void onStartup(final ServletContext sc) throws ServletException {
+        LOGGER.info("MainWebAppInitializer.onStartup()");
+        sc.setInitParameter("javax.faces.FACELETS_SKIP_COMMENTS", "true");
+
+        // Create the 'root' Spring application context
+        final AnnotationConfigWebApplicationContext root = new AnnotationConfigWebApplicationContext();
+        root.register(SpringCoreConfig.class);
+        sc.addListener(new ContextLoaderListener(root));
+    }
+
+}

jsf/src/main/java/com/baeldung/springintegration/config/SpringCoreConfig.java

@@ -0,0 +1,15 @@
+package com.baeldung.springintegration.config;
+
+import com.baeldung.springintegration.dao.UserManagementDAO;
+import com.baeldung.springintegration.dao.UserManagementDAOImpl;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class SpringCoreConfig {
+
+    @Bean
+    public UserManagementDAO userManagementDAO() {
+        return new UserManagementDAOImpl();
+    }
+}

jsf/src/main/java/com/baeldung/springintegration/controllers/RegistrationBean.java

@@ -0,0 +1,62 @@
+package com.baeldung.springintegration.controllers;
+
+import com.baeldung.springintegration.dao.UserManagementDAO;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.faces.bean.ManagedBean;
+import javax.faces.bean.ManagedProperty;
+import javax.faces.bean.ViewScoped;
+import javax.faces.context.FacesContext;
+import java.io.Serializable;
+
+@ManagedBean(name = "registration")
+@ViewScoped
+public class RegistrationBean implements Serializable {
+    private static final Logger LOGGER = LoggerFactory.getLogger(RegistrationBean.class);
+
+    @ManagedProperty(value = "#{userManagementDAO}")
+    transient private UserManagementDAO userDao;
+    private String userName;
+    private String operationMessage;
+
+    public void createNewUser() {
+        try {
+            LOGGER.info("Creating new user");
+            FacesContext context = FacesContext.getCurrentInstance();
+            boolean operationStatus = userDao.createUser(userName);
+            context.isValidationFailed();
+            if (operationStatus) {
+                operationMessage = "User " + userName + " created";
+            }
+        } catch (Exception ex) {
+            LOGGER.error("Error registering new user ");
+            ex.printStackTrace();
+            operationMessage = "Error " + userName + " not created";
+        }
+    }
+
+    public String getUserName() {
+        return userName;
+    }
+
+    public void setUserName(String userName) {
+        this.userName = userName;
+    }
+
+    public void setUserDao(UserManagementDAO userDao) {
+        this.userDao = userDao;
+    }
+
+    public UserManagementDAO getUserDao() {
+        return this.userDao;
+    }
+
+    public String getOperationMessage() {
+        return operationMessage;
+    }
+
+    public void setOperationMessage(String operationMessage) {
+        this.operationMessage = operationMessage;
+    }
+}