Merge branch 'master' into java8DateTime

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/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
+    }
+}

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>

junit5/pom.xml

@@ -0,0 +1,83 @@
+<?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">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>com.baeldung</groupId>
+    <artifactId>junit5</artifactId>
+    <version>1.0-SNAPSHOT</version>
+
+    <name>junit5</name>
+    <description>Intro to JUnit 5</description>
+
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <java.version>1.8</java.version>
+        <!-- Due to a bug in surefire-junit5-5.0.0-ALPHA we use the latest snapshot instead -->
+        <junit.gen5.version>5.0.0-SNAPSHOT</junit.gen5.version>
+    </properties>
+
+    <repositories>
+        <repository>
+            <id>snapshots-repo</id>
+            <url>https://oss.sonatype.org/content/repositories/snapshots</url>
+            <releases>
+                <enabled>false</enabled>
+            </releases>
+            <snapshots>
+                <!-- Do NOT cache JUnit 5 snapshot JARs. -->
+                <updatePolicy>always</updatePolicy>
+                <enabled>true</enabled>
+            </snapshots>
+        </repository>
+    </repositories>
+
+    <pluginRepositories>
+        <pluginRepository>
+            <id>snapshots-repo</id>
+            <url>https://oss.sonatype.org/content/repositories/snapshots</url>
+            <releases>
+                <enabled>false</enabled>
+            </releases>
+            <snapshots>
+                <!-- Do NOT cache JUnit 5 snapshot JARs. -->
+                <updatePolicy>always</updatePolicy>
+                <enabled>true</enabled>
+            </snapshots>
+        </pluginRepository>
+    </pluginRepositories>
+
+    <build>
+        <plugins>
+            <plugin>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.1</version>
+                <configuration>
+                    <source>${java.version}</source>
+                    <target>${java.version}</target>
+                </configuration>
+            </plugin>
+            <plugin>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>2.19</version>
+                <dependencies>
+                    <dependency>
+                        <groupId>org.junit</groupId>
+                        <artifactId>surefire-junit5</artifactId>
+                        <version>${junit.gen5.version}</version>
+                    </dependency>
+                </dependencies>
+            </plugin>
+        </plugins>
+    </build>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.junit</groupId>
+            <artifactId>junit5-api</artifactId>
+            <version>${junit.gen5.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+</project>

junit5/src/test/java/com/baeldung/AssumptionTest.java

@@ -0,0 +1,30 @@
+package com.baeldung;
+
+import org.junit.gen5.api.Test;
+
+import static org.junit.gen5.api.Assertions.assertEquals;
+import static org.junit.gen5.api.Assumptions.*;
+
+public class AssumptionTest {
+
+    @Test
+    void trueAssumption() {
+        assumeTrue(5 > 1);
+        assertEquals(5 + 2, 7);
+    }
+
+    @Test
+    void falseAssumption() {
+        assumeFalse(5 < 1);
+        assertEquals(5 + 2, 7);
+    }
+
+    @Test
+    void assumptionThat() {
+        String someString = "Just a string";
+        assumingThat(
+                someString.equals("Just a string"),
+                () -> assertEquals(2 + 2, 4)
+        );
+    }
+}

junit5/src/test/java/com/baeldung/ExceptionTest.java

@@ -0,0 +1,18 @@
+package com.baeldung;
+
+import org.junit.gen5.api.Test;
+
+import static org.junit.gen5.api.Assertions.assertEquals;
+import static org.junit.gen5.api.Assertions.expectThrows;
+
+public class ExceptionTest {
+
+    @Test
+    void shouldThrowException() {
+        Throwable exception = expectThrows(UnsupportedOperationException.class,
+                () -> {
+                    throw new UnsupportedOperationException("Not supported");
+                });
+        assertEquals(exception.getMessage(), "Not supported");
+    }
+}

junit5/src/test/java/com/baeldung/FirstTest.java

@@ -0,0 +1,37 @@
+package com.baeldung;
+
+import org.junit.gen5.api.Disabled;
+import org.junit.gen5.api.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.gen5.api.Assertions.*;
+
+class FirstTest {
+
+    @Test
+    void lambdaExpressions() {
+        List<Integer> numbers = Arrays.asList(1, 2, 3);
+        assertTrue(numbers
+                .stream()
+                .mapToInt(i -> i)
+                .sum() > 5, "Sum should be greater than 5");
+    }
+
+    @Test
+    void groupAssertions() {
+        int[] numbers = {0, 1, 2, 3, 4};
+        assertAll("numbers",
+                () -> assertEquals(numbers[0], 1),
+                () -> assertEquals(numbers[3], 3),
+                () -> assertEquals(numbers[4], 1)
+        );
+    }
+
+    @Test
+    @Disabled
+    void disabledTest() {
+        assertTrue(false);
+    }
+}

junit5/src/test/java/com/baeldung/NestedTest.java

@@ -0,0 +1,77 @@
+package com.baeldung;
+
+import org.junit.gen5.api.*;
+
+import java.util.EmptyStackException;
+import java.util.Stack;
+
+public class NestedTest {
+    Stack<Object> stack;
+    boolean isRun = false;
+
+    @Test
+    @DisplayName("is instantiated with new Stack()")
+    void isInstantiatedWithNew() {
+        new Stack<Object>();
+    }
+
+    @Nested
+    @DisplayName("when new")
+    class WhenNew {
+
+        @BeforeEach
+        void init() {
+            stack = new Stack<Object>();
+        }
+
+        @Test
+        @DisplayName("is empty")
+        void isEmpty() {
+            Assertions.assertTrue(stack.isEmpty());
+        }
+
+        @Test
+        @DisplayName("throws EmptyStackException when popped")
+        void throwsExceptionWhenPopped() {
+            Assertions.expectThrows(EmptyStackException.class, () -> stack.pop());
+        }
+
+        @Test
+        @DisplayName("throws EmptyStackException when peeked")
+        void throwsExceptionWhenPeeked() {
+            Assertions.expectThrows(EmptyStackException.class, () -> stack.peek());
+        }
+
+        @Nested
+        @DisplayName("after pushing an element")
+        class AfterPushing {
+
+            String anElement = "an element";
+
+            @BeforeEach
+            void init() {
+                stack.push(anElement);
+            }
+
+            @Test
+            @DisplayName("it is no longer empty")
+            void isEmpty() {
+                Assertions.assertFalse(stack.isEmpty());
+            }
+
+            @Test
+            @DisplayName("returns the element when popped and is empty")
+            void returnElementWhenPopped() {
+                Assertions.assertEquals(anElement, stack.pop());
+                Assertions.assertTrue(stack.isEmpty());
+            }
+
+            @Test
+            @DisplayName("returns the element when peeked but remains not empty")
+            void returnElementWhenPeeked() {
+                Assertions.assertEquals(anElement, stack.peek());
+                Assertions.assertFalse(stack.isEmpty());
+            }
+        }
+    }
+}

junit5/src/test/java/com/baeldung/TaggedTest.java

@@ -0,0 +1,16 @@
+package com.baeldung;
+
+import org.junit.gen5.api.Tag;
+import org.junit.gen5.api.Test;
+
+import static org.junit.gen5.api.Assertions.assertEquals;
+
+@Tag("Test case")
+public class TaggedTest {
+
+    @Test
+    @Tag("Method")
+    void testMethod() {
+        assertEquals(2 + 2, 4);
+    }
+}

spring-autowire/pom.xml

@@ -0,0 +1,63 @@
+<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">
+  <modelVersion>4.0.0</modelVersion>
+
+  <groupId>com.baeldung</groupId>
+  <artifactId>spring-autowire</artifactId>
+  <version>0.0.1-SNAPSHOT</version>
+  <packaging>jar</packaging>
+
+  <name>spring-autowire</name>
+  <url>http://maven.apache.org</url>
+
+  <properties>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    <org.springframework.version>4.2.5.RELEASE</org.springframework.version>
+    <maven-compiler-plugin.version>3.5.1</maven-compiler-plugin.version>
+    <maven-surefire-plugin.version>2.19.1</maven-surefire-plugin.version>
+  </properties>
+
+  <dependencies>
+  	<dependency>
+	    <groupId>junit</groupId>
+	    <artifactId>junit</artifactId>
+	    <version>4.11</version>
+	</dependency>
+    <dependency>
+	  <groupId>org.springframework</groupId>
+	  <artifactId>spring-core</artifactId>
+	  <version>${org.springframework.version}</version>
+	</dependency>
+	<dependency>
+	  <groupId>org.springframework</groupId>
+	  <artifactId>spring-context</artifactId>
+	  <version>${org.springframework.version}</version>
+	</dependency>
+	<dependency>
+        <groupId>org.springframework</groupId>
+        <artifactId>spring-test</artifactId>
+        <version>${org.springframework.version}</version>
+        <scope>test</scope>
+    </dependency>
+  </dependencies>
+  
+  <build>
+        <finalName>spring-autowire</finalName>
+        <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-surefire-plugin</artifactId>
+                <version>${maven-surefire-plugin.version}</version>
+            </plugin>
+        </plugins>
+    </build>  
+</project>

spring-autowire/src/main/java/com/baeldung/autowire/sample/App.java

@@ -0,0 +1,11 @@
+package com.baeldung.autowire.sample;
+
+import org.springframework.context.annotation.AnnotationConfigApplicationContext;
+
+public class App {
+	public static void main(String[] args) {
+		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);
+		FooService fooService = ctx.getBean(FooService.class);
+		fooService.doStuff();
+	}
+}

spring-autowire/src/main/java/com/baeldung/autowire/sample/AppConfig.java

@@ -0,0 +1,10 @@
+package com.baeldung.autowire.sample;
+
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+@ComponentScan("com.baeldung.autowire.sample")
+public class AppConfig {
+
+}

spring-autowire/src/main/java/com/baeldung/autowire/sample/Bar.java

@@ -0,0 +1,5 @@
+package com.baeldung.autowire.sample;
+
+public class Bar {
+
+}

spring-autowire/src/main/java/com/baeldung/autowire/sample/BarFormatter.java

@@ -0,0 +1,13 @@
+package com.baeldung.autowire.sample;
+
+import org.springframework.stereotype.Component;
+
+@FormatterType("Bar")
+@Component
+public class BarFormatter implements Formatter {
+
+    public String format() {
+        return "bar";
+    }
+    
+}

spring-autowire/src/main/java/com/baeldung/autowire/sample/Foo.java

@@ -0,0 +1,5 @@
+package com.baeldung.autowire.sample;
+
+public class Foo {
+
+}

spring-autowire/src/main/java/com/baeldung/autowire/sample/FooDAO.java

@@ -0,0 +1,5 @@
+package com.baeldung.autowire.sample;
+
+public class FooDAO {
+
+}

spring-autowire/src/main/java/com/baeldung/autowire/sample/FooFormatter.java

@@ -0,0 +1,13 @@
+package com.baeldung.autowire.sample;
+
+import org.springframework.stereotype.Component;
+
+@FormatterType("Foo")
+@Component
+public class FooFormatter implements Formatter {
+
+    public String format() {
+        return "foo";
+    }
+    
+}

spring-autowire/src/main/java/com/baeldung/autowire/sample/FooService.java

@@ -0,0 +1,17 @@
+package com.baeldung.autowire.sample;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Component
+public class FooService {
+    
+    @Autowired
+    @FormatterType("Foo")
+    private Formatter formatter;
+    
+    public String doStuff(){
+        return formatter.format();
+    }
+    
+}