Merge remote-tracking branch 'upstream/master'

algorithms/README.md

@@ -14,3 +14,4 @@
 - [Bubble Sort in Java](http://www.baeldung.com/java-bubble-sort)
 - [Introduction to JGraphT](http://www.baeldung.com/jgrapht)
 - [Introduction to Minimax Algorithm](http://www.baeldung.com/java-minimax-algorithm)
+- [How to Calculate Levenshtein Distance in Java?](http://www.baeldung.com/java-levenshtein-distance)

apache-spark/README.md

@@ -0,0 +1,3 @@
+### Relevant articles
+
+- [Introduction to Apache Spark](http://www.baeldung.com/apache-spark)

cas/cas-secured-app/pom.xml

@@ -65,6 +65,24 @@
 				<groupId>org.springframework.boot</groupId>
 				<artifactId>spring-boot-maven-plugin</artifactId>
 			</plugin>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-surefire-plugin</artifactId>
+				<version>${maven-surefire-plugin.version}</version>
+				<configuration>
+					<forkCount>3</forkCount>
+					<reuseForks>true</reuseForks>
+					<excludes>
+						<exclude>**/*IntegrationTest.java</exclude>
+						<exclude>**/*LongRunningUnitTest.java</exclude>
+						<exclude>**/*ManualTest.java</exclude>
+						<exclude>**/JdbcTest.java</exclude>
+						<exclude>**/*LiveTest.java</exclude>
+					</excludes>
+
+				</configuration>
+			</plugin>
+
 		</plugins>
 	</build>
 
@@ -107,4 +125,5 @@
 	</pluginRepositories>
 
 
+
 </project>

cas/cas-secured-app/src/test/java/com/baeldung/cassecuredapp/CasSecuredAppApplicationIntegrationTest.java

@@ -7,7 +7,7 @@ import org.springframework.test.context.junit4.SpringRunner;
 
 @RunWith(SpringRunner.class)
 @SpringBootTest
-public class CasSecuredAppApplicationTests {
+public class CasSecuredAppApplicationIntegrationTest {
 
 	@Test
 	public void contextLoads() {

core-java-8/src/main/java/com/baeldung/annotations/ClassWithAnnotation.java

@@ -0,0 +1,5 @@
+package com.baeldung.annotations;
+
+@Deprecated
+class ClassWithAnnotation {
+}

core-java-8/src/main/java/com/baeldung/annotations/ClassWithDeprecatedMethod.java

@@ -0,0 +1,9 @@
+package com.baeldung.annotations;
+
+class ClassWithDeprecatedMethod {
+
+    @Deprecated
+    static void deprecatedMethod() {
+
+    }
+}

core-java-8/src/main/java/com/baeldung/annotations/ClassWithSafeVarargs.java

@@ -0,0 +1,11 @@
+package com.baeldung.annotations;
+
+class ClassWithSafeVarargs<T> {
+
+    @SafeVarargs
+    final void iterateOverVarargs(T... args) {
+        for (T x : args) {
+            // do stuff with x
+        }
+    }
+}

core-java-8/src/main/java/com/baeldung/annotations/ClassWithSuppressWarnings.java

@@ -0,0 +1,9 @@
+package com.baeldung.annotations;
+
+class ClassWithSuppressWarnings {
+
+    @SuppressWarnings("deprecation")
+    void useDeprecatedMethod() {
+        ClassWithDeprecatedMethod.deprecatedMethod(); // no warning is generated here
+    }
+}

core-java-8/src/main/java/com/baeldung/annotations/IntConsumer.java

@@ -0,0 +1,8 @@
+package com.baeldung.annotations;
+
+@FunctionalInterface
+interface IntConsumer {
+
+    void accept(Integer number);
+
+}

core-java-8/src/main/java/com/baeldung/annotations/Interval.java

@@ -0,0 +1,8 @@
+package com.baeldung.annotations;
+
+import java.lang.annotation.Repeatable;
+
+@Repeatable(Intervals.class)
+@interface Interval {
+    int hour() default 1;
+}

core-java-8/src/main/java/com/baeldung/annotations/IntervalUsage.java

@@ -0,0 +1,9 @@
+package com.baeldung.annotations;
+
+public class IntervalUsage {
+
+    @Interval(hour = 17)
+    @Interval(hour = 13)
+    void doPeriodicCleanup() {
+    }
+}

core-java-8/src/main/java/com/baeldung/annotations/Intervals.java

@@ -0,0 +1,5 @@
+package com.baeldung.annotations;
+
+@interface Intervals {
+    Interval[] value();
+}

core-java-8/src/main/java/com/baeldung/annotations/MyAnnotation.java

@@ -0,0 +1,11 @@
+package com.baeldung.annotations;
+
+import java.lang.annotation.*;
+
+@Inherited
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.LOCAL_VARIABLE, ElementType.FIELD})
+@interface MyAnnotation {
+
+}

core-java-8/src/main/java/com/baeldung/annotations/MyAnnotationTarget.java

@@ -0,0 +1,16 @@
+package com.baeldung.annotations;
+
+class MyAnnotationTarget {
+
+    // this is OK
+    @MyAnnotation
+    String someField;
+
+    // @MyAnnotation <- this is invalid usage!
+    void doSomething() {
+
+        // this also works
+        @MyAnnotation
+        String localVariable;
+    }
+}

core-java-8/src/main/java/com/baeldung/annotations/MyOperation.java

@@ -0,0 +1,6 @@
+package com.baeldung.annotations;
+
+interface MyOperation {
+
+    void perform();
+}

core-java-8/src/main/java/com/baeldung/annotations/MyOperationImpl.java

@@ -0,0 +1,9 @@
+package com.baeldung.annotations;
+
+class MyOperationImpl implements MyOperation {
+
+    @Override
+    public void perform() {
+
+    }
+}

core-java-8/src/main/java/com/baeldung/datetime/DateToLocalDateConverter.java

@@ -0,0 +1,35 @@
+/**
+ * 
+ */
+package com.baeldung.datetime;
+
+import java.time.Instant;
+import java.time.LocalDate;
+import java.time.ZoneId;
+import java.util.Date;
+
+/**
+ * Class which shows different ways of converting java.util.Date into java.time.LocalDate.
+ * 
+ * @author abialas
+ *
+ */
+public class DateToLocalDateConverter {
+
+    public static LocalDate convertToLocalDateViaInstant(Date dateToConvert) {
+        return dateToConvert.toInstant()
+            .atZone(ZoneId.systemDefault())
+            .toLocalDate();
+    }
+
+    public static LocalDate convertToLocalDateViaSqlDate(Date dateToConvert) {
+        return new java.sql.Date(dateToConvert.getTime()).toLocalDate();
+    }
+
+    public static LocalDate convertToLocalDateViaMilisecond(Date dateToConvert) {
+        return Instant.ofEpochMilli(dateToConvert.getTime())
+            .atZone(ZoneId.systemDefault())
+            .toLocalDate();
+    }
+
+}

core-java-8/src/main/java/com/baeldung/datetime/DateToLocalDateTimeConverter.java

@@ -0,0 +1,35 @@
+/**
+ * 
+ */
+package com.baeldung.datetime;
+
+import java.time.Instant;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.util.Date;
+
+/**
+ * Class which shows different ways of converting java.util.Date into java.time.LocalDateTime. 
+ * 
+ * @author abialas
+ *
+ */
+public class DateToLocalDateTimeConverter {
+
+    public static LocalDateTime convertToLocalDateTimeViaInstant(Date dateToConvert) {
+        return dateToConvert.toInstant()
+            .atZone(ZoneId.systemDefault())
+            .toLocalDateTime();
+    }
+
+    public static LocalDateTime convertToLocalDateTimeViaSqlTimestamp(Date dateToConvert) {
+        return new java.sql.Timestamp(dateToConvert.getTime()).toLocalDateTime();
+    }
+
+    public static LocalDateTime convertToLocalDateTimeViaMilisecond(Date dateToConvert) {
+        return Instant.ofEpochMilli(dateToConvert.getTime())
+            .atZone(ZoneId.systemDefault())
+            .toLocalDateTime();
+    }
+
+}

core-java-8/src/main/java/com/baeldung/datetime/LocalDateTimeToDateConverter.java

@@ -0,0 +1,27 @@
+/**
+ * 
+ */
+package com.baeldung.datetime;
+
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.util.Date;
+
+/**
+ * Class which shows different ways of converting java.time.LocalDateTime into java.util.Date. 
+ *  
+ * @author abialas
+ *
+ */
+public class LocalDateTimeToDateConverter {
+
+    public static Date convertToDateViaSqlTimestamp(LocalDateTime dateToConvert) {
+        return java.sql.Timestamp.valueOf(dateToConvert);
+    }
+
+    public static Date convertToDateViaInstant(LocalDateTime dateToConvert) {
+        return java.util.Date.from(dateToConvert.atZone(ZoneId.systemDefault())
+            .toInstant());
+    }
+
+}

core-java-8/src/main/java/com/baeldung/datetime/LocalDateToDateConverter.java

@@ -0,0 +1,28 @@
+/**
+ * 
+ */
+package com.baeldung.datetime;
+
+import java.time.LocalDate;
+import java.time.ZoneId;
+import java.util.Date;
+
+/**
+ * Class which shows different ways of converting java.time.LocalDate into java.util.Date. 
+ *  
+ * @author abialas
+ *
+ */
+public class LocalDateToDateConverter {
+
+    public static Date convertToDateViaSqlDate(LocalDate dateToConvert) {
+        return java.sql.Date.valueOf(dateToConvert);
+    }
+
+    public static Date convertToDateViaInstant(LocalDate dateToConvert) {
+        return java.util.Date.from(dateToConvert.atStartOfDay()
+            .atZone(ZoneId.systemDefault())
+            .toInstant());
+    }
+
+}

core-java-8/src/main/java/com/baeldung/timezonedisplay/TimezoneDisplay.java

@@ -0,0 +1,55 @@
+package com.baeldung.timezonedisplay;
+
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.ZoneOffset;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class TimezoneDisplay {
+
+    public enum OffsetBase {
+        GMT, UTC
+    }
+
+    public List<String> getTimeZoneList(OffsetBase base) {
+        Set<String> availableZoneIds = ZoneId.getAvailableZoneIds();
+
+        LocalDateTime now = LocalDateTime.now();
+        return availableZoneIds
+          .stream()
+          .map(ZoneId::of)
+          .sorted(new ZoneComparator())
+          .map(id -> String.format("(%s%s) %s", base, getOffset(now, id), id.getId()))
+          .collect(Collectors.toList());
+    }
+
+    private String getOffset(LocalDateTime dateTime, ZoneId id) {
+        return dateTime
+          .atZone(id)
+          .getOffset()
+          .getId()
+          .replace("Z", "+00:00");
+    }
+
+    private class ZoneComparator implements Comparator<ZoneId> {
+
+        @Override
+        public int compare(ZoneId zoneId1, ZoneId zoneId2) {
+            LocalDateTime now = LocalDateTime.now();
+
+            ZoneOffset offset1 = now
+              .atZone(zoneId1)
+              .getOffset();
+
+            ZoneOffset offset2 = now
+              .atZone(zoneId2)
+              .getOffset();
+
+            return offset1.compareTo(offset2);
+        }
+    }
+
+}

core-java-8/src/main/java/com/baeldung/timezonedisplay/TimezoneDisplayApp.java

@@ -0,0 +1,18 @@
+package com.baeldung.timezonedisplay;
+
+import java.util.List;
+
+public class TimezoneDisplayApp {
+
+    public static void main(String... args) {
+        TimezoneDisplay display = new TimezoneDisplay();
+
+        System.out.println("Time zones in UTC:");
+        List<String> utc = display.getTimeZoneList(TimezoneDisplay.OffsetBase.UTC);
+        utc.forEach(System.out::println);
+
+        System.out.println("Time zones in GMT:");
+        List<String> gmt = display.getTimeZoneList(TimezoneDisplay.OffsetBase.GMT);
+        gmt.forEach(System.out::println);
+    }
+}

core-java-8/src/test/java/com/baeldung/datetime/DateToLocalDateConverterTest.java

@@ -0,0 +1,72 @@
+/**
+ * 
+ */
+package com.baeldung.datetime;
+
+import static org.junit.Assert.assertEquals;
+
+import java.time.LocalDate;
+import java.time.temporal.ChronoField;
+import java.util.Calendar;
+import java.util.Date;
+
+import org.junit.Test;
+
+/**
+ * 
+ * JUnits for {@link DateToLocalDateConverter} class.
+ * 
+ * @author abialas
+ *
+ */
+public class DateToLocalDateConverterTest {
+
+    @Test
+    public void shouldReturn10thNovember2010WhenConvertViaInstant() {
+        // given
+        Calendar calendar = Calendar.getInstance();
+        calendar.set(2010, 10, 10);
+        Date dateToConvert = calendar.getTime();
+
+        // when
+        LocalDate localDate = DateToLocalDateConverter.convertToLocalDateViaInstant(dateToConvert);
+
+        // then
+        assertEquals(2010, localDate.get(ChronoField.YEAR));
+        assertEquals(11, localDate.get(ChronoField.MONTH_OF_YEAR));
+        assertEquals(10, localDate.get(ChronoField.DAY_OF_MONTH));
+    }
+
+    @Test
+    public void shouldReturn10thNovember2010WhenConvertViaMiliseconds() {
+        // given
+        Calendar calendar = Calendar.getInstance();
+        calendar.set(2010, 10, 10);
+        Date dateToConvert = calendar.getTime();
+
+        // when
+        LocalDate localDate = DateToLocalDateConverter.convertToLocalDateViaMilisecond(dateToConvert);
+
+        // then
+        assertEquals(2010, localDate.get(ChronoField.YEAR));
+        assertEquals(11, localDate.get(ChronoField.MONTH_OF_YEAR));
+        assertEquals(10, localDate.get(ChronoField.DAY_OF_MONTH));
+    }
+
+    @Test
+    public void shouldReturn10thNovember2010WhenConvertViaSqlDate() {
+        // given
+        Calendar calendar = Calendar.getInstance();
+        calendar.set(2010, 10, 10);
+        Date dateToConvert = calendar.getTime();
+
+        // when
+        LocalDate localDate = DateToLocalDateConverter.convertToLocalDateViaSqlDate(dateToConvert);
+
+        // then
+        assertEquals(2010, localDate.get(ChronoField.YEAR));
+        assertEquals(11, localDate.get(ChronoField.MONTH_OF_YEAR));
+        assertEquals(10, localDate.get(ChronoField.DAY_OF_MONTH));
+    }
+
+}

core-java-8/src/test/java/com/baeldung/datetime/DateToLocalDateTimeConverterTest.java

@@ -0,0 +1,78 @@
+/**
+ * 
+ */
+package com.baeldung.datetime;
+
+import static org.junit.Assert.assertEquals;
+
+import java.time.LocalDateTime;
+import java.time.temporal.ChronoField;
+import java.util.Calendar;
+import java.util.Date;
+
+import org.junit.Test;
+
+/**
+ * 
+ * JUnits for {@link DateToLocalDateTimeConverter} class.
+ * 
+ * @author abialas
+ *
+ */
+public class DateToLocalDateTimeConverterTest {
+
+    @Test
+    public void shouldReturn10thNovember2010time8hour20minWhenConvertViaInstant() {
+        // given
+        Calendar calendar = Calendar.getInstance();
+        calendar.set(2010, 10, 10, 8, 20);
+        Date dateToConvert = calendar.getTime();
+
+        // when
+        LocalDateTime localDateTime = DateToLocalDateTimeConverter.convertToLocalDateTimeViaInstant(dateToConvert);
+
+        // then
+        assertEquals(2010, localDateTime.get(ChronoField.YEAR));
+        assertEquals(11, localDateTime.get(ChronoField.MONTH_OF_YEAR));
+        assertEquals(10, localDateTime.get(ChronoField.DAY_OF_MONTH));
+        assertEquals(8, localDateTime.get(ChronoField.HOUR_OF_DAY));
+        assertEquals(20, localDateTime.get(ChronoField.MINUTE_OF_HOUR));
+    }
+
+    @Test
+    public void shouldReturn10thNovember2010time8hour20minWhenConvertViaMiliseconds() {
+        // given
+        Calendar calendar = Calendar.getInstance();
+        calendar.set(2010, 10, 10, 8, 20);
+        Date dateToConvert = calendar.getTime();
+
+        // when
+        LocalDateTime localDateTime = DateToLocalDateTimeConverter.convertToLocalDateTimeViaMilisecond(dateToConvert);
+
+        // then
+        assertEquals(2010, localDateTime.get(ChronoField.YEAR));
+        assertEquals(11, localDateTime.get(ChronoField.MONTH_OF_YEAR));
+        assertEquals(10, localDateTime.get(ChronoField.DAY_OF_MONTH));
+        assertEquals(8, localDateTime.get(ChronoField.HOUR_OF_DAY));
+        assertEquals(20, localDateTime.get(ChronoField.MINUTE_OF_HOUR));
+    }
+
+    @Test
+    public void shouldReturn10thNovember2010time8hour20minWhenConvertViaSqlTimestamp() {
+        // given
+        Calendar calendar = Calendar.getInstance();
+        calendar.set(2010, 10, 10, 8, 20);
+        Date dateToConvert = calendar.getTime();
+
+        // when
+        LocalDateTime localDateTime = DateToLocalDateTimeConverter.convertToLocalDateTimeViaSqlTimestamp(dateToConvert);
+
+        // then
+        assertEquals(2010, localDateTime.get(ChronoField.YEAR));
+        assertEquals(11, localDateTime.get(ChronoField.MONTH_OF_YEAR));
+        assertEquals(10, localDateTime.get(ChronoField.DAY_OF_MONTH));
+        assertEquals(8, localDateTime.get(ChronoField.HOUR_OF_DAY));
+        assertEquals(20, localDateTime.get(ChronoField.MINUTE_OF_HOUR));
+    }
+
+}

core-java-8/src/test/java/com/baeldung/datetime/LocalDateTimeToDateConverterTest.java

@@ -0,0 +1,61 @@
+/**
+ * 
+ */
+package com.baeldung.datetime;
+
+import static org.junit.Assert.assertEquals;
+
+import java.time.LocalDateTime;
+import java.util.Calendar;
+import java.util.Date;
+
+import org.junit.Test;
+
+/**
+ * 
+ * JUnits for {@link LocalDateTimeToDateConverter} class.
+ * 
+ * @author abialas
+ *
+ */
+public class LocalDateTimeToDateConverterTest {
+
+    @Test
+    public void shouldReturn10thNovember2010time8hour20minWhenConvertViaInstant() {
+        // given
+        LocalDateTime dateToConvert = LocalDateTime.of(2010, 11, 10, 8, 20);
+
+        // when
+        Date date = LocalDateTimeToDateConverter.convertToDateViaInstant(dateToConvert);
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(date);
+
+        // then
+        assertEquals(2010, calendar.get(Calendar.YEAR));
+        assertEquals(10, calendar.get(Calendar.MONTH));
+        assertEquals(10, calendar.get(Calendar.DAY_OF_MONTH));
+        assertEquals(8, calendar.get(Calendar.HOUR));
+        assertEquals(20, calendar.get(Calendar.MINUTE));
+        assertEquals(0, calendar.get(Calendar.SECOND));
+    }
+
+    @Test
+    public void shouldReturn10thNovember2010WhenConvertViaSqlTimestamp() {
+        // given
+        LocalDateTime dateToConvert = LocalDateTime.of(2010, 11, 10, 8, 20);
+
+        // when
+        Date date = LocalDateTimeToDateConverter.convertToDateViaSqlTimestamp(dateToConvert);
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(date);
+
+        // then
+        assertEquals(2010, calendar.get(Calendar.YEAR));
+        assertEquals(10, calendar.get(Calendar.MONTH));
+        assertEquals(10, calendar.get(Calendar.DAY_OF_MONTH));
+        assertEquals(8, calendar.get(Calendar.HOUR));
+        assertEquals(20, calendar.get(Calendar.MINUTE));
+        assertEquals(0, calendar.get(Calendar.SECOND));
+    }
+
+}

core-java-8/src/test/java/com/baeldung/datetime/LocalDateToDateConverterTest.java

@@ -0,0 +1,55 @@
+/**
+ * 
+ */
+package com.baeldung.datetime;
+
+import static org.junit.Assert.assertEquals;
+
+import java.time.LocalDate;
+import java.util.Calendar;
+import java.util.Date;
+
+import org.junit.Test;
+
+/**
+ * 
+ * JUnits for {@link LocalDateToDateConverter} class.
+ * 
+ * @author abialas
+ *
+ */
+public class LocalDateToDateConverterTest {
+
+    @Test
+    public void shouldReturn10thNovember2010WhenConvertViaInstant() {
+        // given
+        LocalDate dateToConvert = LocalDate.of(2010, 11, 10);
+
+        // when
+        Date date = LocalDateToDateConverter.convertToDateViaInstant(dateToConvert);
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(date);
+
+        // then
+        assertEquals(2010, calendar.get(Calendar.YEAR));
+        assertEquals(10, calendar.get(Calendar.MONTH));
+        assertEquals(10, calendar.get(Calendar.DAY_OF_MONTH));
+    }
+
+    @Test
+    public void shouldReturn10thNovember2010WhenConvertViaSqlDate() {
+        // given
+        LocalDate dateToConvert = LocalDate.of(2010, 11, 10);
+
+        // when
+        Date date = LocalDateToDateConverter.convertToDateViaSqlDate(dateToConvert);
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(date);
+
+        // then
+        assertEquals(2010, calendar.get(Calendar.YEAR));
+        assertEquals(10, calendar.get(Calendar.MONTH));
+        assertEquals(10, calendar.get(Calendar.DAY_OF_MONTH));
+    }
+
+}

core-java-9/src/main/java/com/baeldung/java9/datetime/DateToLocalDateConverter.java

@@ -0,0 +1,22 @@
+/**
+ * 
+ */
+package com.baeldung.java9.datetime;
+
+import java.time.LocalDate;
+import java.time.ZoneId;
+import java.util.Date;
+
+/**
+ * Class which shows a way to convert java.util.Date into java.time.LocalDate with new Java 1.9.
+ * 
+ * @author abialas
+ *
+ */
+public class DateToLocalDateConverter {
+
+    public static LocalDate convertToLocalDate(Date dateToConvert) {
+        return LocalDate.ofInstant(dateToConvert.toInstant(), ZoneId.systemDefault());
+    }
+
+}

core-java-9/src/main/java/com/baeldung/java9/datetime/DateToLocalDateTimeConverter.java

@@ -0,0 +1,22 @@
+/**
+ * 
+ */
+package com.baeldung.java9.datetime;
+
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.util.Date;
+
+/**
+ * Class which shows a way to convert java.util.Date into java.time.LocalDateTime with new Java 1.9.
+ * 
+ * @author abialas
+ *
+ */
+public class DateToLocalDateTimeConverter {
+
+    public static LocalDateTime convertToLocalDateTime(Date dateToConvert) {
+        return LocalDateTime.ofInstant(dateToConvert.toInstant(), ZoneId.systemDefault());
+    }
+
+}

core-java-9/src/test/java/com/baeldung/java9/datetime/DateToLocalDateConverterTest.java

@@ -0,0 +1,41 @@
+/**
+ * 
+ */
+package com.baeldung.java9.datetime;
+
+import static org.junit.Assert.assertEquals;
+
+import java.time.LocalDate;
+import java.time.temporal.ChronoField;
+import java.util.Calendar;
+import java.util.Date;
+
+import org.junit.Test;
+
+import com.baeldung.java9.datetime.DateToLocalDateConverter;
+
+/**
+ * JUnits for {@link DateToLocalDateConverter} class.
+ * 
+ * @author abialas
+ *
+ */
+public class DateToLocalDateConverterTest {
+
+    @Test
+    public void shouldReturn10thNovember2010WhenConvertToLocalDate() {
+        // given
+        Calendar calendar = Calendar.getInstance();
+        calendar.set(2010, 10, 10);
+        Date dateToConvert = calendar.getTime();
+
+        // when
+        LocalDate localDateTime = DateToLocalDateConverter.convertToLocalDate(dateToConvert);
+
+        // then
+        assertEquals(2010, localDateTime.get(ChronoField.YEAR));
+        assertEquals(11, localDateTime.get(ChronoField.MONTH_OF_YEAR));
+        assertEquals(10, localDateTime.get(ChronoField.DAY_OF_MONTH));
+    }
+
+}

core-java-9/src/test/java/com/baeldung/java9/datetime/DateToLocalDateTimeConverterTest.java

@@ -0,0 +1,43 @@
+/**
+ * 
+ */
+package com.baeldung.java9.datetime;
+
+import static org.junit.Assert.assertEquals;
+
+import java.time.LocalDateTime;
+import java.time.temporal.ChronoField;
+import java.util.Calendar;
+import java.util.Date;
+
+import org.junit.Test;
+
+import com.baeldung.java9.datetime.DateToLocalDateTimeConverter;
+
+/**
+ * JUnits for {@link DateToLocalDateTimeConverter} class.
+ * 
+ * @author abialas
+ *
+ */
+public class DateToLocalDateTimeConverterTest {
+
+    @Test
+    public void shouldReturn10thNovember2010time8hour20minWhenConvertViaInstant() {
+        // given
+        Calendar calendar = Calendar.getInstance();
+        calendar.set(2010, 10, 10, 8, 20);
+        Date dateToConvert = calendar.getTime();
+
+        // when
+        LocalDateTime localDateTime = DateToLocalDateTimeConverter.convertToLocalDateTime(dateToConvert);
+
+        // then
+        assertEquals(2010, localDateTime.get(ChronoField.YEAR));
+        assertEquals(11, localDateTime.get(ChronoField.MONTH_OF_YEAR));
+        assertEquals(10, localDateTime.get(ChronoField.DAY_OF_MONTH));
+        assertEquals(8, localDateTime.get(ChronoField.HOUR_OF_DAY));
+        assertEquals(20, localDateTime.get(ChronoField.MINUTE_OF_HOUR));
+    }
+
+}

core-java-concurrency/README.md

@@ -30,3 +30,4 @@
 - [Guide to Volatile Keyword in Java](http://www.baeldung.com/java-volatile)
 - [Overview of the java.util.concurrent](http://www.baeldung.com/java-util-concurrent)
 - [Semaphores in Java](http://www.baeldung.com/java-semaphore)
+- [Daemon Threads in Java](http://www.baeldung.com/java-daemon-thread)

core-java-concurrency/src/main/java/com/baeldung/concurrent/stopping/ControlSubThread.java

@@ -0,0 +1,52 @@
+package com.baeldung.concurrent.stopping;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class ControlSubThread implements Runnable {
+
+    private Thread worker;
+    private int interval = 100;
+    private AtomicBoolean running = new AtomicBoolean(false);
+    private AtomicBoolean stopped = new AtomicBoolean(true);
+
+
+    public ControlSubThread(int sleepInterval) {
+        interval = sleepInterval;
+    }
+
+    public void start() {
+        worker = new Thread(this);
+        worker.start();
+    }
+
+    public void stop() {
+        running.set(false);
+    }
+
+    public void interrupt() {
+        running.set(false);
+        worker.interrupt();
+    }
+
+    boolean isRunning() {
+        return running.get();
+    }
+
+    boolean isStopped() {
+        return stopped.get();
+    }
+
+    public void run() {
+        running.set(true);
+        stopped.set(false);
+        while (running.get()) {
+            try {
+                Thread.sleep(interval);
+            } catch (InterruptedException e) {
+                // no-op, just loop again
+            }
+            // do something
+        }
+        stopped.set(true);
+    }
+}

core-java-concurrency/src/test/java/com/baeldung/concurrent/runnable/RunnableVsThreadLiveTest.java

@@ -1,24 +1,21 @@
 package com.baeldung.concurrent.runnable;
 
 import java.util.concurrent.Callable;
-import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
 
 import org.apache.commons.lang3.RandomUtils;
-import org.junit.After;
 import org.junit.AfterClass;
-import org.junit.Before;
 import org.junit.BeforeClass;
 import org.junit.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-public class RunnableVsThreadTest {
+public class RunnableVsThreadLiveTest {
 
 	private static Logger log = 
-	  LoggerFactory.getLogger(RunnableVsThreadTest.class);
+	  LoggerFactory.getLogger(RunnableVsThreadLiveTest.class);
 
 	private static ExecutorService executorService;
 	
@@ -77,9 +74,7 @@ public class RunnableVsThreadTest {
 	public void givenACallableAsLambda_whenSubmitToES_thenResult() 
 	  throws Exception {
 		
-		Future<Integer> future = executorService.submit(() -> {
+		Future<Integer> future = executorService.submit(() -> RandomUtils.nextInt(0, 100));
-		  return RandomUtils.nextInt(0, 100);
-		});
 		
 		log.info("Result from callable: {}", future.get());
 	}
@@ -99,7 +94,7 @@ class SimpleThread extends Thread{
 	
 	private String message;
 	
-	public SimpleThread(String message) {
+	SimpleThread(String message) {
 		this.message = message;
 	}
 	
@@ -116,7 +111,7 @@ class SimpleRunnable implements Runnable {
 	
 	private String message;
 	
-	public SimpleRunnable(String message) {
+	SimpleRunnable(String message) {
 		this.message = message;
 	}
 	

core-java-concurrency/src/test/java/com/baeldung/concurrent/stopping/StopThreadTest.java

@@ -0,0 +1,50 @@
+package com.baeldung.concurrent.stopping;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+public class StopThreadTest {
+
+    @Test
+    public void whenStoppedThreadIsStopped() throws InterruptedException {
+
+        int interval = 100;
+
+        ControlSubThread controlSubThread = new ControlSubThread(interval);
+        controlSubThread.start();
+
+        // Give things a chance to get set up
+        Thread.sleep(interval);
+        assertTrue(controlSubThread.isRunning());
+        assertFalse(controlSubThread.isStopped());
+
+        // Stop it and make sure the flags have been reversed
+        controlSubThread.stop();
+        Thread.sleep(interval);
+        assertTrue(controlSubThread.isStopped());
+    }
+
+
+    @Test
+    public void whenInterruptedThreadIsStopped() throws InterruptedException {
+
+        int interval = 5000;
+
+        ControlSubThread controlSubThread = new ControlSubThread(interval);
+        controlSubThread.start();
+
+        // Give things a chance to get set up
+        Thread.sleep(100);
+        assertTrue(controlSubThread.isRunning());
+        assertFalse(controlSubThread.isStopped());
+
+        // Stop it and make sure the flags have been reversed
+        controlSubThread.interrupt();
+
+        // Wait less than the time we would normally sleep, and make sure we exited.
+        Thread.sleep(interval/10);
+        assertTrue(controlSubThread.isStopped());
+    }
+}

core-java/README.md

@@ -114,4 +114,6 @@
 - [StringBuilder and StringBuffer in Java](http://www.baeldung.com/java-string-builder-string-buffer)
 - [Number of Digits in an Integer in Java](http://www.baeldung.com/java-number-of-digits-in-int)
 - [Proxy, Decorator, Adapter and Bridge Patterns](http://www.baeldung.com/java-structural-design-patterns)
-
+- [Creating a Java Compiler Plugin](http://www.baeldung.com/java-build-compiler-plugin)
+- [A Guide to the Static Keyword in Java](http://www.baeldung.com/java-static)
+- [Initializing Arrays in Java](http://www.baeldung.com/java-initialize-array)

core-java/pom.xml

@@ -216,6 +216,13 @@
 		    <artifactId>spring-web</artifactId>
 		    <version>4.3.4.RELEASE</version>
 		</dependency>
+        <dependency>
+            <groupId>com.sun</groupId>
+            <artifactId>tools</artifactId>
+            <version>1.8.0</version>
+            <scope>system</scope>
+            <systemPath>${java.home}/../lib/tools.jar</systemPath>
+        </dependency>
     </dependencies>
 
     <build>
@@ -453,7 +460,7 @@
         <logback.version>1.1.7</logback.version>
 
         <!-- util -->
-        <guava.version>22.0</guava.version>
+        <guava.version>23.0</guava.version>
         <commons-lang3.version>3.5</commons-lang3.version>
         <bouncycastle.version>1.55</bouncycastle.version>
         <commons-codec.version>1.10</commons-codec.version>

core-java/src/main/java/com/baeldung/designpatterns/creational/abstractfactory/AbstractFactory.java

@@ -0,0 +1,6 @@
+package com.baeldung.designpatterns.creational.abstractfactory;
+
+public interface AbstractFactory {
+    Animal getAnimal(String toyType) ;
+    Color getColor(String colorType);
+}

core-java/src/main/java/com/baeldung/designpatterns/creational/abstractfactory/AbstractPatternDriver.java

@@ -0,0 +1,18 @@
+package com.baeldung.designpatterns.creational.abstractfactory;
+
+public class AbstractPatternDriver {
+    public static void main(String[] args) {
+        AbstractFactory abstractFactory;
+        
+        //creating a brown toy dog
+        abstractFactory = FactoryProvider.getFactory("Toy");
+        Animal toy = abstractFactory.getAnimal("Dog");
+        
+        abstractFactory = FactoryProvider.getFactory("Color");
+        Color color = abstractFactory.getColor("Brown");
+        
+        String result = "A " + toy.getType() + " with " + color.getColor() + " color " + toy.makeSound();
+        
+        System.out.println(result);
+    }
+}

core-java/src/main/java/com/baeldung/designpatterns/creational/abstractfactory/Animal.java

@@ -0,0 +1,6 @@
+package com.baeldung.designpatterns.creational.abstractfactory;
+
+public interface Animal {
+    String getType();
+    String makeSound();
+}

core-java/src/main/java/com/baeldung/designpatterns/creational/abstractfactory/AnimalFactory.java

@@ -0,0 +1,21 @@
+package com.baeldung.designpatterns.creational.abstractfactory;
+
+public class AnimalFactory implements AbstractFactory {
+
+    @Override
+    public Animal getAnimal(String animalType) {
+        if ("Dog".equalsIgnoreCase(animalType)) {
+            return new Dog();
+        } else if ("Duck".equalsIgnoreCase(animalType)) {
+            return new Duck();
+        }
+
+        return null;
+    }
+
+    @Override
+    public Color getColor(String color) {
+        throw new UnsupportedOperationException();
+    }
+
+}

core-java/src/main/java/com/baeldung/designpatterns/creational/abstractfactory/Brown.java

@@ -0,0 +1,10 @@
+package com.baeldung.designpatterns.creational.abstractfactory;
+
+public class Brown implements Color {
+
+    @Override
+    public String getColor() {
+        return "brown";
+    }
+
+}

core-java/src/main/java/com/baeldung/designpatterns/creational/abstractfactory/Color.java

@@ -0,0 +1,5 @@
+package com.baeldung.designpatterns.creational.abstractfactory;
+
+public interface Color {
+    String getColor();
+}

core-java/src/main/java/com/baeldung/designpatterns/creational/abstractfactory/ColorFactory.java

@@ -0,0 +1,21 @@
+package com.baeldung.designpatterns.creational.abstractfactory;
+
+public class ColorFactory implements AbstractFactory {
+
+    @Override
+    public Color getColor(String colorType) {
+        if ("Brown".equalsIgnoreCase(colorType)) {
+            return new Brown();
+        } else if ("White".equalsIgnoreCase(colorType)) {
+            return new White();
+        }
+
+        return null;
+    }
+
+    @Override
+    public Animal getAnimal(String toyType) {
+        throw new UnsupportedOperationException();
+    }
+
+}

core-java/src/main/java/com/baeldung/designpatterns/creational/abstractfactory/Dog.java

@@ -0,0 +1,15 @@
+package com.baeldung.designpatterns.creational.abstractfactory;
+
+public class Dog implements Animal {
+
+    @Override
+    public String getType() {
+        return "Dog";
+    }
+
+    @Override
+    public String makeSound() {
+        return "Barks";
+    }
+
+}

core-java/src/main/java/com/baeldung/designpatterns/creational/abstractfactory/Duck.java

@@ -0,0 +1,15 @@
+package com.baeldung.designpatterns.creational.abstractfactory;
+
+public class Duck implements Animal {
+
+    @Override
+    public String getType() {
+        return "Duck";
+    }
+
+    @Override
+    public String makeSound() {
+        return "Squeks";
+    }
+
+}

core-java/src/main/java/com/baeldung/designpatterns/creational/abstractfactory/FactoryProvider.java

@@ -0,0 +1,15 @@
+package com.baeldung.designpatterns.creational.abstractfactory;
+
+public class FactoryProvider {
+    public static AbstractFactory getFactory(String choice){
+        
+        if("Toy".equalsIgnoreCase(choice)){
+            return new AnimalFactory();
+        }
+        else if("Color".equalsIgnoreCase(choice)){
+            return new ColorFactory();
+        }
+        
+        return null;
+    }
+}

core-java/src/main/java/com/baeldung/designpatterns/creational/abstractfactory/White.java

@@ -0,0 +1,10 @@
+package com.baeldung.designpatterns.creational.abstractfactory;
+
+public class White implements Color {
+
+    @Override
+    public String getColor() {
+        return "White";
+    }
+
+}

core-java/src/main/java/com/baeldung/designpatterns/creational/builder/BankAccount.java

@@ -0,0 +1,64 @@
+package com.baeldung.designpatterns.creational.builder;
+
+public class BankAccount {
+    private String name;
+    private String accountNumber;
+    private String email;
+    private boolean newsletter;
+
+    //The constructor that takes a builder from which it will create object
+    //the access to this is only provided to builder
+    private BankAccount(BankAccountBuilder builder) {
+        this.name = builder.name;
+        this.accountNumber = builder.accountNumber;
+        this.email = builder.email;
+        this.newsletter = builder.newsletter;
+    }
+    
+    public static class BankAccountBuilder {
+        private String name;
+        private String accountNumber;
+        private String email;
+        private boolean newsletter;
+        
+        //All Mandatory parameters goes with this constructor
+        public BankAccountBuilder(String name, String accountNumber) {
+            this.name = name;
+            this.accountNumber = accountNumber;
+        }
+
+        //setters for optional parameters which returns this same builder
+        //to support fluent design
+        public BankAccountBuilder withEmail(String email) {
+            this.email = email;
+            return this;
+        }
+
+        public BankAccountBuilder wantNewsletter(boolean newsletter) {
+            this.newsletter = newsletter;
+            return this;
+        }
+        
+        //the actual build method that prepares and returns a BankAccount object
+        public BankAccount build() {
+            return new BankAccount(this);
+        }
+    }
+
+    //getters
+    public String getName() {
+        return name;
+    }
+
+    public String getAccountNumber() {
+        return accountNumber;
+    }
+
+    public String getEmail() {
+        return email;
+    }
+
+    public boolean isNewsletter() {
+        return newsletter;
+    }
+}

core-java/src/main/java/com/baeldung/designpatterns/creational/builder/BuilderPatternDriver.java

@@ -0,0 +1,16 @@
+package com.baeldung.designpatterns.creational.builder;
+
+public class BuilderPatternDriver {
+    public static void main(String[] args) {
+        BankAccount newAccount = new BankAccount
+          .BankAccountBuilder("Jon", "22738022275")
+          .withEmail("jon@example.com")
+          .wantNewsletter(true)
+          .build();
+
+        System.out.println("Name: " + newAccount.getName());
+        System.out.println("AccountNumber:" + newAccount.getAccountNumber());
+        System.out.println("Email: " + newAccount.getEmail());
+        System.out.println("Want News letter?: " + newAccount.isNewsletter());
+    }
+}

core-java/src/main/java/com/baeldung/designpatterns/creational/factory/FactoryDriver.java

@@ -0,0 +1,16 @@
+package com.baeldung.designpatterns.creational.factory;
+
+public class FactoryDriver {
+    public static void main(String[] args) {
+        Polygon p;
+        PolygonFactory factory = new PolygonFactory();
+        
+        //get the shape which has 4 sides
+        p = factory.getPolygon(4);
+        System.out.println("The shape with 4 sides is a " + p.getType());
+        
+        //get the shape which has 4 sides
+        p = factory.getPolygon(8);
+        System.out.println("The shape with 8 sides is a " + p.getType());
+    }
+}

core-java/src/main/java/com/baeldung/designpatterns/creational/factory/Heptagon.java

@@ -0,0 +1,10 @@
+package com.baeldung.designpatterns.creational.factory;
+
+public class Heptagon implements Polygon {
+
+    @Override
+    public String getType() {
+        return "Heptagon";
+    }
+
+}

core-java/src/main/java/com/baeldung/designpatterns/creational/factory/Octagon.java

@@ -0,0 +1,10 @@
+package com.baeldung.designpatterns.creational.factory;
+
+public class Octagon implements Polygon {
+
+    @Override
+    public String getType() {
+        return "Octagon";
+    }
+
+}

core-java/src/main/java/com/baeldung/designpatterns/creational/factory/Pentagon.java

@@ -0,0 +1,10 @@
+package com.baeldung.designpatterns.creational.factory;
+
+public class Pentagon implements Polygon {
+
+    @Override
+    public String getType() {
+        return "Pentagon";
+    }
+
+}

core-java/src/main/java/com/baeldung/designpatterns/creational/factory/Polygon.java

@@ -0,0 +1,5 @@
+package com.baeldung.designpatterns.creational.factory;
+
+public interface Polygon {
+    String getType();
+}

core-java/src/main/java/com/baeldung/designpatterns/creational/factory/PolygonFactory.java

@@ -0,0 +1,22 @@
+package com.baeldung.designpatterns.creational.factory;
+
+public class PolygonFactory {
+    public Polygon getPolygon(int numberOfSides) {
+        if(numberOfSides == 3) {
+            return new Triangle();
+        }
+        if(numberOfSides == 4) {
+            return new Square();
+        }
+        if(numberOfSides == 5) {
+            return new Pentagon();
+        }
+        if(numberOfSides == 4) {
+            return new Heptagon();
+        }
+        else if(numberOfSides == 8) {
+            return new Octagon();
+        }
+        return null;
+    }
+}

core-java/src/main/java/com/baeldung/designpatterns/creational/factory/Square.java

@@ -0,0 +1,10 @@
+package com.baeldung.designpatterns.creational.factory;
+
+public class Square implements Polygon {
+
+    @Override
+    public String getType() {
+        return "Square";
+    }
+
+}

core-java/src/main/java/com/baeldung/designpatterns/creational/factory/Triangle.java

@@ -0,0 +1,10 @@
+package com.baeldung.designpatterns.creational.factory;
+
+public class Triangle implements Polygon {
+
+    @Override
+    public String getType() {
+        return "Triangle";
+    }
+
+}

core-java/src/main/java/com/baeldung/designpatterns/creational/singleton/Singleton.java

@@ -0,0 +1,13 @@
+package com.baeldung.designpatterns.creational.singleton;
+
+public class Singleton  {    
+    private Singleton() {}
+    
+    private static class SingletonHolder {    
+        public static final Singleton instance = new Singleton();
+    }    
+
+    public static Singleton getInstance() {    
+        return SingletonHolder.instance;    
+    }    
+}

core-java/src/main/java/com/baeldung/designpatterns/creational/singleton/SingletonDriver.java

@@ -0,0 +1,8 @@
+package com.baeldung.designpatterns.creational.singleton;
+
+public class SingletonDriver {
+    public static void main(String[] args) {
+        Singleton instance = Singleton.getInstance();
+        System.out.println(instance.toString());
+    }
+}

core-java/src/main/java/com/baeldung/javac/Positive.java

@@ -0,0 +1,9 @@
+package com.baeldung.javac;
+
+import java.lang.annotation.*;
+
+@Documented
+@Retention(RetentionPolicy.CLASS)
+@Target({ElementType.PARAMETER})
+public @interface Positive {
+}

core-java/src/main/java/com/baeldung/javac/SampleJavacPlugin.java

@@ -0,0 +1,123 @@
+package com.baeldung.javac;
+
+import com.sun.source.tree.MethodTree;
+import com.sun.source.tree.VariableTree;
+import com.sun.source.util.*;
+import com.sun.tools.javac.api.BasicJavacTask;
+import com.sun.tools.javac.code.TypeTag;
+import com.sun.tools.javac.tree.JCTree;
+import com.sun.tools.javac.tree.TreeMaker;
+import com.sun.tools.javac.util.Context;
+import com.sun.tools.javac.util.Name;
+import com.sun.tools.javac.util.Names;
+
+import javax.tools.JavaCompiler;
+import java.util.*;
+import java.util.stream.Collectors;
+
+import static com.sun.tools.javac.util.List.nil;
+
+/**
+ * A {@link JavaCompiler javac} plugin which inserts {@code >= 0} checks into resulting {@code *.class} files
+ * for numeric method parameters marked by {@link Positive}
+ */
+public class SampleJavacPlugin implements Plugin {
+
+    public static final String NAME = "MyPlugin";
+
+    private static Set<String> TARGET_TYPES = new HashSet<>(Arrays.asList(
+        // Use only primitive types for simplicity
+        byte.class.getName(), short.class.getName(), char.class.getName(), 
+        int.class.getName(), long.class.getName(), float.class.getName(), double.class.getName()));
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    @Override
+    public void init(JavacTask task, String... args) {
+        Context context = ((BasicJavacTask) task).getContext();
+        task.addTaskListener(new TaskListener() {
+            @Override
+            public void started(TaskEvent e) {
+            }
+
+            @Override
+            public void finished(TaskEvent e) {
+                if (e.getKind() != TaskEvent.Kind.PARSE) {
+                    return;
+                }
+                e.getCompilationUnit()
+                    .accept(new TreeScanner<Void, Void>() {
+                        @Override
+                        public Void visitMethod(MethodTree method, Void v) {
+                            List<VariableTree> parametersToInstrument = method.getParameters()
+                                .stream()
+                                .filter(SampleJavacPlugin.this::shouldInstrument)
+                                .collect(Collectors.toList());
+                            if (!parametersToInstrument.isEmpty()) {
+                                // There is a possible case that more than one argument is marked by @Positive,
+                                // as the checks are added to the method's body beginning, we process parameters RTL
+                                // to ensure correct order.
+                                Collections.reverse(parametersToInstrument);
+                                parametersToInstrument.forEach(p -> addCheck(method, p, context));
+                            }
+                            // There is a possible case that there is a nested class declared in a method's body,
+                            // hence, we want to proceed with method body AST as well.
+                            return super.visitMethod(method, v);
+                        }
+                    }, null);
+            }
+        });
+    }
+
+    private boolean shouldInstrument(VariableTree parameter) {
+        return TARGET_TYPES.contains(parameter.getType().toString())
+          && parameter.getModifiers().getAnnotations()
+            .stream()
+            .anyMatch(a -> Positive.class.getSimpleName().equals(a.getAnnotationType().toString()));
+    }
+
+    private void addCheck(MethodTree method, VariableTree parameter, Context context) {
+        JCTree.JCIf check = createCheck(parameter, context);
+        JCTree.JCBlock body = (JCTree.JCBlock) method.getBody();
+        body.stats = body.stats.prepend(check);
+    }
+
+    private static JCTree.JCIf createCheck(VariableTree parameter, Context context) {
+        TreeMaker factory = TreeMaker.instance(context);
+        Names symbolsTable = Names.instance(context);
+        
+        return factory.at(((JCTree) parameter).pos)
+          .If(factory.Parens(createIfCondition(factory, symbolsTable, parameter)),
+            createIfBlock(factory, symbolsTable, parameter),
+            null);
+    }
+
+    private static JCTree.JCBinary createIfCondition(TreeMaker factory, Names symbolsTable, VariableTree parameter) {
+        Name parameterId = symbolsTable.fromString(parameter.getName().toString());
+        return factory.Binary(JCTree.Tag.LE, 
+          factory.Ident(parameterId), 
+          factory.Literal(TypeTag.INT, 0));
+    }
+
+    private static JCTree.JCBlock createIfBlock(TreeMaker factory, Names symbolsTable, VariableTree parameter) {
+        String parameterName = parameter.getName().toString();
+        Name parameterId = symbolsTable.fromString(parameterName);
+        
+        String errorMessagePrefix = String.format("Argument '%s' of type %s is marked by @%s but got '", 
+          parameterName, parameter.getType(), Positive.class.getSimpleName());
+        String errorMessageSuffix = "' for it";
+        
+        return factory.Block(0, com.sun.tools.javac.util.List.of(
+          factory.Throw(
+            factory.NewClass(null, nil(), 
+              factory.Ident(symbolsTable.fromString(IllegalArgumentException.class.getSimpleName())),
+                com.sun.tools.javac.util.List.of(factory.Binary(JCTree.Tag.PLUS, 
+                  factory.Binary(JCTree.Tag.PLUS, factory.Literal(TypeTag.CLASS, errorMessagePrefix), 
+                    factory.Ident(parameterId)), 
+                    factory.Literal(TypeTag.CLASS, errorMessageSuffix))), null))));
+    }
+
+}

core-java/src/main/java/com/baeldung/timezonedisplay/TimezoneDisplayJava7.java

@@ -0,0 +1,43 @@
+package com.baeldung.timezonedisplay;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.TimeZone;
+import java.util.concurrent.TimeUnit;
+
+public class TimezoneDisplayJava7 {
+
+    public enum OffsetBase {
+        GMT, UTC
+    }
+
+    public List<String> getTimeZoneList(TimezoneDisplayJava7.OffsetBase base) {
+        String[] availableZoneIds = TimeZone.getAvailableIDs();
+        List<String> result = new ArrayList<>(availableZoneIds.length);
+
+        for (String zoneId : availableZoneIds) {
+            TimeZone curTimeZone = TimeZone.getTimeZone(zoneId);
+
+            String offset = calculateOffset(curTimeZone.getRawOffset());
+
+            result.add(String.format("(%s%s) %s", base, offset, zoneId));
+        }
+
+        Collections.sort(result);
+
+        return result;
+    }
+
+    private String calculateOffset(int rawOffset) {
+        if (rawOffset == 0) {
+            return "+00:00";
+        }
+        long hours = TimeUnit.MILLISECONDS.toHours(rawOffset);
+        long minutes = TimeUnit.MILLISECONDS.toMinutes(rawOffset);
+        minutes = Math.abs(minutes - TimeUnit.HOURS.toMinutes(hours));
+
+        return String.format("%+03d:%02d", hours, Math.abs(minutes));
+    }
+
+}

core-java/src/main/java/com/baeldung/timezonedisplay/TimezoneDisplayJava7App.java

@@ -0,0 +1,23 @@
+package com.baeldung.timezonedisplay;
+
+import java.util.List;
+
+public class TimezoneDisplayJava7App {
+
+    public static void main(String... args) {
+        TimezoneDisplayJava7 display = new TimezoneDisplayJava7();
+
+        System.out.println("Time zones in UTC:");
+        List<String> utc = display.getTimeZoneList(TimezoneDisplayJava7.OffsetBase.UTC);
+        for (String timeZone : utc) {
+            System.out.println(timeZone);
+        }
+
+        System.out.println("Time zones in GMT:");
+        List<String> gmt = display.getTimeZoneList(TimezoneDisplayJava7.OffsetBase.GMT);
+        for (String timeZone : gmt) {
+            System.out.println(timeZone);
+        }
+    }
+
+}

core-java/src/main/resources/META-INF/services/com.sun.source.util.Plugin

@@ -0,0 +1 @@
+com.baeldung.javac.SampleJavacPlugin

core-java/src/test/java/com/baeldung/copyfiles/FileCopierTest.java

@@ -0,0 +1,70 @@
+package com.baeldung.copyfiles;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.StandardCopyOption;
+
+import org.apache.commons.io.FileUtils;
+import org.junit.Before;
+import org.junit.Test;
+import static org.assertj.core.api.Assertions.*;
+
+public class FileCopierTest {
+	File original = new File("src/test/resources/original.txt");
+
+	@Before
+	public void init() throws IOException {
+		if (!original.exists())
+			Files.createFile(original.toPath());
+	}
+
+	@Test
+	public void givenIoAPI_whenCopied_thenCopyExistsWithSameContents() throws IOException {
+		File copied = new File("src/test/resources/copiedWithIo.txt");
+		try (InputStream in = new BufferedInputStream(new FileInputStream(original));
+				OutputStream out = new BufferedOutputStream(new FileOutputStream(copied))) {
+			byte[] buffer = new byte[1024];
+			int lengthRead;
+			while ((lengthRead = in.read(buffer)) > 0) {
+				out.write(buffer, 0, lengthRead);
+				out.flush();
+			}
+		}
+		assertThat(copied).exists();
+		assertThat(Files.readAllLines(original.toPath()).equals(Files.readAllLines(copied.toPath())));
+	}
+
+	@Test
+	public void givenCommonsIoAPI_whenCopied_thenCopyExistsWithSameContents() throws IOException {
+		File copied = new File("src/test/resources/copiedWithApacheCommons.txt");
+		FileUtils.copyFile(original, copied);
+		assertThat(copied).exists();
+		assertThat(Files.readAllLines(original.toPath()).equals(Files.readAllLines(copied.toPath())));
+	}
+
+	@Test
+	public void givenNIO2_whenCopied_thenCopyExistsWithSameContents() throws IOException {
+		Path copied = Paths.get("src/test/resources/copiedWithNio.txt");
+		Path originalPath = original.toPath();
+		Files.copy(originalPath, copied, StandardCopyOption.REPLACE_EXISTING);
+		assertThat(copied).exists();
+		assertThat(Files.readAllLines(originalPath).equals(Files.readAllLines(copied)));
+	}
+
+	@Test
+	public void givenGuava_whenCopied_thenCopyExistsWithSameContents() throws IOException {
+		File copied = new File("src/test/resources/copiedWithApacheCommons.txt");
+		com.google.common.io.Files.copy(original, copied);
+		assertThat(copied).exists();
+		assertThat(Files.readAllLines(original.toPath()).equals(Files.readAllLines(copied.toPath())));
+	}
+}

core-java/src/test/java/com/baeldung/designpatterns/creational/abstractfactory/AbstractPatternIntegrationTest.java

@@ -0,0 +1,23 @@
+package com.baeldung.designpatterns.creational.abstractfactory;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+public class AbstractPatternIntegrationTest {
+    @Test
+    public void givenAbstractFactory_whenGettingObjects_thenSuccessful() {
+        AbstractFactory abstractFactory;
+        
+        //creating a brown toy dog
+        abstractFactory = FactoryProvider.getFactory("Toy");
+        Animal toy = abstractFactory.getAnimal("Dog");
+        
+        abstractFactory = FactoryProvider.getFactory("Color");
+        Color color = abstractFactory.getColor("Brown");
+        
+        String result = "A " + toy.getType() + " with " + color.getColor() + " color " + toy.makeSound();
+        assertEquals("A Dog with brown color Barks", result);
+    }
+
+}

core-java/src/test/java/com/baeldung/designpatterns/creational/builder/BuilderPatternIntegrationTest.java

@@ -0,0 +1,33 @@
+package com.baeldung.designpatterns.creational.builder;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+public class BuilderPatternIntegrationTest {
+    @Test
+    public void whenCreatingObjectThroughBuilder_thenObjectValid() {
+        BankAccount newAccount = new BankAccount
+          .BankAccountBuilder("Jon", "22738022275")
+          .withEmail("jon@example.com")
+          .wantNewsletter(true)
+          .build();
+        
+        assertEquals(newAccount.getName(), "Jon");
+        assertEquals(newAccount.getAccountNumber(), "22738022275");
+        assertEquals(newAccount.getEmail(), "jon@example.com");
+        assertEquals(newAccount.isNewsletter(), true);
+    }
+    
+    @Test
+    public void whenSkippingOptionalParameters_thenObjectValid() {
+        BankAccount newAccount = new BankAccount
+          .BankAccountBuilder("Jon", "22738022275")
+          .build();
+        
+        assertEquals(newAccount.getName(), "Jon");
+        assertEquals(newAccount.getAccountNumber(), "22738022275");
+        assertEquals(newAccount.getEmail(), null);
+        assertEquals(newAccount.isNewsletter(), false);
+    }
+}

core-java/src/test/java/com/baeldung/designpatterns/creational/factory/FactoryIntegrationTest.java

@@ -0,0 +1,32 @@
+package com.baeldung.designpatterns.creational.factory;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+public class FactoryIntegrationTest {
+
+    @Test
+    public void whenUsingFactoryForSquare_thenCorrectObjectReturned() {
+        Polygon p;
+        PolygonFactory factory = new PolygonFactory();
+        
+        //get the shape which has 4 sides
+        p = factory.getPolygon(4);
+        String result = "The shape with 4 sides is a " + p.getType();
+        
+        assertEquals("The shape with 4 sides is a Square", result);
+    }
+    
+    @Test
+    public void whenUsingFactoryForOctagon_thenCorrectObjectReturned() {
+        Polygon p;
+        PolygonFactory factory = new PolygonFactory();
+        
+        //get the shape which has 4 sides
+        p = factory.getPolygon(8);
+        String result = "The shape with 8 sides is a " + p.getType();
+        
+        assertEquals("The shape with 8 sides is a Octagon", result);
+    }
+}

core-java/src/test/java/com/baeldung/designpatterns/creational/singleton/SingletonIntegrationTest.java

@@ -0,0 +1,26 @@
+package com.baeldung.designpatterns.creational.singleton;
+
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class SingletonIntegrationTest {
+
+    @Test
+    /**
+     * Although there is absolutely no way to determine whether
+     * a class is Singleton, in this test case, we will just 
+     * check for two objects if they point to same instance or 
+     * not. We will also check for their hashcode.
+     */
+    public void whenGettingMultipleObjects_thenAllPointToSame() {
+        //first object
+        Singleton obj1 = Singleton.getInstance();
+        
+        //Second object
+        Singleton obj2 = Singleton.getInstance();
+        
+        assertTrue(obj1 == obj2);
+        assertEquals(obj1.hashCode(), obj2.hashCode());
+    }
+
+}

core-java/src/test/java/com/baeldung/javac/SampleJavacPluginIntegrationTest.java

@@ -0,0 +1,42 @@
+package com.baeldung.javac;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class SampleJavacPluginIntegrationTest {
+
+    private static final String CLASS_TEMPLATE =
+            "package com.baeldung.javac;\n" +
+            "\n" +
+            "public class Test {\n" +
+            "    public static %1$s service(@Positive %1$s i) {\n" +
+            "        return i;\n" +
+            "    }\n" +
+            "}\n" +
+            "";
+
+    private TestCompiler compiler = new TestCompiler();
+    private TestRunner   runner   = new TestRunner();
+
+    @Test(expected = IllegalArgumentException.class)
+    public void givenInt_whenNegative_thenThrowsException() throws Throwable {
+        compileAndRun(double.class,-1);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void givenInt_whenZero_thenThrowsException() throws Throwable {
+        compileAndRun(int.class,0);
+    }
+
+    @Test
+    public void givenInt_whenPositive_thenSuccess() throws Throwable {
+        assertEquals(1, compileAndRun(int.class, 1));
+    }
+
+    private Object compileAndRun(Class<?> argumentType, Object argument) throws Throwable {
+        String qualifiedClassName = "com.baeldung.javac.Test";
+        byte[] byteCode = compiler.compile(qualifiedClassName, String.format(CLASS_TEMPLATE, argumentType.getName()));
+        return runner.run(byteCode, qualifiedClassName, "service", new Class[] {argumentType}, argument);
+    }
+}

core-java/src/test/java/com/baeldung/javac/SimpleClassFile.java

@@ -0,0 +1,26 @@
+package com.baeldung.javac;
+
+import javax.tools.SimpleJavaFileObject;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.net.URI;
+
+/** Holds compiled byte code in a byte array */
+public class SimpleClassFile extends SimpleJavaFileObject {
+
+    private ByteArrayOutputStream out;
+
+    public SimpleClassFile(URI uri) {
+        super(uri, Kind.CLASS);
+    }
+
+    @Override
+    public OutputStream openOutputStream() throws IOException {
+        return out = new ByteArrayOutputStream();
+    }
+
+    public byte[] getCompiledBinaries() {
+        return out.toByteArray();
+    }
+}

core-java/src/test/java/com/baeldung/javac/SimpleFileManager.java

@@ -0,0 +1,34 @@
+package com.baeldung.javac;
+
+import javax.tools.*;
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.List;
+
+/** Adapts {@link SimpleClassFile} to the {@link JavaCompiler} */
+public class SimpleFileManager extends ForwardingJavaFileManager<StandardJavaFileManager> {
+
+    private final List<SimpleClassFile> compiled = new ArrayList<>();
+
+    public SimpleFileManager(StandardJavaFileManager delegate) {
+        super(delegate);
+    }
+
+    @Override
+    public JavaFileObject getJavaFileForOutput(Location location,
+                                               String className,
+                                               JavaFileObject.Kind kind,
+                                               FileObject sibling)
+    {
+        SimpleClassFile result = new SimpleClassFile(URI.create("string://" + className));
+        compiled.add(result);
+        return result;
+    }
+
+    /**
+     * @return  compiled binaries processed by the current class
+     */
+    public List<SimpleClassFile> getCompiled() {
+        return compiled;
+    }
+}

core-java/src/test/java/com/baeldung/javac/SimpleSourceFile.java

@@ -0,0 +1,23 @@
+package com.baeldung.javac;
+
+import javax.tools.SimpleJavaFileObject;
+import java.net.URI;
+
+/** Exposes given test source to the compiler. */
+public class SimpleSourceFile extends SimpleJavaFileObject {
+
+    private final String content;
+
+    public SimpleSourceFile(String qualifiedClassName, String testSource) {
+        super(URI.create(String.format("file://%s%s",
+                                       qualifiedClassName.replaceAll("\\.", "/"),
+                                       Kind.SOURCE.extension)),
+              Kind.SOURCE);
+        content = testSource;
+    }
+
+    @Override
+    public CharSequence getCharContent(boolean ignoreEncodingErrors) {
+        return content;
+    }
+}

core-java/src/test/java/com/baeldung/javac/TestCompiler.java

@@ -0,0 +1,35 @@
+package com.baeldung.javac;
+
+import javax.tools.JavaCompiler;
+import javax.tools.ToolProvider;
+import java.io.StringWriter;
+import java.util.ArrayList;
+import java.util.List;
+
+import static java.util.Arrays.asList;
+import static java.util.Collections.singletonList;
+
+public class TestCompiler {
+    public byte[] compile(String qualifiedClassName, String testSource) {
+        StringWriter output = new StringWriter();
+
+        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
+        SimpleFileManager fileManager = new SimpleFileManager(compiler.getStandardFileManager(
+                null,
+                null,
+                null
+        ));
+        List<SimpleSourceFile> compilationUnits = singletonList(new SimpleSourceFile(qualifiedClassName, testSource));
+        List<String> arguments = new ArrayList<>();
+        arguments.addAll(asList("-classpath", System.getProperty("java.class.path"),
+                                "-Xplugin:" + SampleJavacPlugin.NAME));
+        JavaCompiler.CompilationTask task = compiler.getTask(output,
+                                                             fileManager,
+                                                             null,
+                                                             arguments,
+                                                             null,
+                                                             compilationUnits);
+        task.call();
+        return fileManager.getCompiled().iterator().next().getCompiledBinaries();
+    }
+}

core-java/src/test/java/com/baeldung/javac/TestRunner.java

@@ -0,0 +1,41 @@
+package com.baeldung.javac;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class TestRunner {
+
+    public Object run(byte[] byteCode,
+                      String qualifiedClassName,
+                      String methodName,
+                      Class<?>[] argumentTypes,
+                      Object... args)
+            throws Throwable
+    {
+        ClassLoader classLoader = new ClassLoader() {
+            @Override
+            protected Class<?> findClass(String name) throws ClassNotFoundException {
+                return defineClass(name, byteCode, 0, byteCode.length);
+            }
+        };
+        Class<?> clazz;
+        try {
+            clazz = classLoader.loadClass(qualifiedClassName);
+        } catch (ClassNotFoundException e) {
+            throw new RuntimeException("Can't load compiled test class", e);
+        }
+
+        Method method;
+        try {
+            method = clazz.getMethod(methodName, argumentTypes);
+        } catch (NoSuchMethodException e) {
+            throw new RuntimeException("Can't find the 'main()' method in the compiled test class", e);
+        }
+
+        try {
+            return method.invoke(null, args);
+        } catch (InvocationTargetException e) {
+            throw e.getCause();
+        }
+    }
+}

core-java/src/test/java/com/baeldung/string/formatter/StringFormatterExampleTests.java

@@ -0,0 +1,141 @@
+package com.baeldung.string.formatter;
+
+import java.util.Calendar;
+import java.util.Formatter;
+import java.util.GregorianCalendar;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import org.junit.Test;
+
+public class StringFormatterExampleTests {
+
+    @Test
+    public void givenString_whenFormatSpecifierForCalendar_thenGotExpected() {
+        //Syntax of Format Specifiers for Date/Time Representation
+        Calendar c = new GregorianCalendar(2017, 11, 10);
+        String s = String.format("The date is: %1$tm %1$te,%1$tY", c);
+
+        assertEquals("The date is: 12 10,2017", s);
+    }
+
+    @Test
+    public void givenString_whenGeneralConversion_thenConvertedString() {
+        //General Conversions
+        String s = String.format("The correct answer is %s", false);
+        assertEquals("The correct answer is false", s);
+
+        s = String.format("The correct answer is %b", null);
+        assertEquals("The correct answer is false", s);
+
+        s = String.format("The correct answer is %B", true);
+        assertEquals("The correct answer is TRUE", s);
+    }
+    
+    @Test
+    public void givenString_whenCharConversion_thenConvertedString() {        
+        //Character Conversions
+        String s = String.format("The correct answer is %c", 'a');
+        assertEquals("The correct answer is a", s);
+
+        s = String.format("The correct answer is %c", null);
+        assertEquals("The correct answer is null", s);
+
+        s = String.format("The correct answer is %C", 'b');
+        assertEquals("The correct answer is B", s);
+        
+        s = String.format("The valid unicode character: %c", 0x0400);
+        assertTrue(Character.isValidCodePoint(0x0400));
+        assertEquals("The valid unicode character: Ѐ", s);
+    }
+    
+    @Test(expected = java.util.IllegalFormatCodePointException.class)
+    public void givenString_whenIllegalCodePointForConversion_thenError() {        
+        String s = String.format("The valid unicode character: %c", 0x11FFFF);
+        assertFalse(Character.isValidCodePoint(0x11FFFF));
+        assertEquals("The valid unicode character: Ā", s);
+    }
+    
+    @Test
+    public void givenString_whenNumericIntegralConversion_thenConvertedString() {
+        //Numeric Integral Conversions
+        String s = String.format("The number 25 in decimal = %d", 25);
+        assertEquals("The number 25 in decimal = 25", s);
+
+        s = String.format("The number 25 in octal = %o", 25);
+        assertEquals("The number 25 in octal = 31", s);
+
+        s = String.format("The number 25 in hexadecimal = %x", 25);
+        assertEquals("The number 25 in hexadecimal = 19", s);
+    }
+    
+    @Test
+    public void givenString_whenNumericFloatingConversion_thenConvertedString() {        
+        //Numeric Floating-point Conversions
+        String s = String.format("The computerized scientific format of 10000.00 "
+                + "= %e", 10000.00);
+        assertEquals("The computerized scientific format of 10000.00 = 1.000000e+04", s);
+
+        s = String.format("The decimal format of 10.019 = %f", 10.019);
+        assertEquals("The decimal format of 10.019 = 10.019000", s);
+    }
+    
+    @Test
+    public void givenString_whenLineSeparatorConversion_thenConvertedString() {        
+        //Line Separator Conversion
+        String s = String.format("First Line %nSecond Line");
+        assertEquals("First Line \n"
+                + "Second Line", s);
+    }
+
+    @Test
+    public void givenString_whenSpecifyFlag_thenGotFormattedString() {
+        //Without left-justified flag
+        String s = String.format("Without left justified flag: %5d", 25);
+        assertEquals("Without left justified flag:    25", s);
+
+        //Using left-justified flag
+        s = String.format("With left justified flag: %-5d", 25);
+        assertEquals("With left justified flag: 25   ", s);
+    }
+
+    @Test
+    public void givenString_whenSpecifyPrecision_thenGotExpected() {
+
+        //Precision
+        String s = String.format("Output of 25.09878 with Precision 2: %.2f", 25.09878);
+        assertEquals("Output of 25.09878 with Precision 2: 25.10", s);
+
+        s = String.format("Output of general conversion type with Precision 2: %.2b", true);
+        assertEquals("Output of general conversion type with Precision 2: tr", s);
+    }
+
+    @Test
+    public void givenString_whenSpecifyArgumentIndex_thenGotExpected() {
+        Calendar c = new GregorianCalendar(2017, 11, 10);
+        //Argument_Index
+        String s = String.format("The date is: %1$tm %1$te,%1$tY", c);
+        assertEquals("The date is: 12 10,2017", s);
+
+        s = String.format("The date is: %1$tm %<te,%<tY", c);
+        assertEquals("The date is: 12 10,2017", s);
+    }
+
+    @Test
+    public void givenAppendable_whenCreateFormatter_thenFormatterWorksOnAppendable() {
+        //Using String Formatter with Appendable
+        StringBuilder sb = new StringBuilder();
+        Formatter formatter = new Formatter(sb);
+        formatter.format("I am writting to a %1$s Instance.", sb.getClass());
+
+        assertEquals("I am writting to a class java.lang.StringBuilder Instance.", sb.toString());
+    }
+    
+    @Test
+    public void givenString_whenNoArguments_thenExpected() {
+        //Using String Formatter without arguments
+        String s = String.format("John scored 90%% in Fall semester");
+        assertEquals("John scored 90% in Fall semester", s);
+    }
+
+}

core-java/src/test/resources/original.txt

@@ -0,0 +1,2 @@
+#Copy a File with Java (www.Baeldung.com)
+Copying Files with Java is Fun!

deeplearning4j/README.md

@@ -2,4 +2,4 @@
 This is a sample project for the [deeplearning4j](https://deeplearning4j.org) library.
 
 ### Relevant Articles:
-- [A Guide to deeplearning4j](http://www.baeldung.com/a-guide-to-deeplearning4j/)
+- [A Guide to deeplearning4j](http://www.baeldung.com/deeplearning4j)

drools/README.MD

@@ -1,4 +1,3 @@
 ### Relevant Articles:
 - [Introduction to Drools](http://www.baeldung.com/drools)
 - [Drools Using Rules from Excel Files](http://www.baeldung.com/drools-excel)
-- [Drools Using Rules from Excel Files](http://www.baeldung.com/drools-excel)

drools/pom.xml

@@ -1,26 +1,19 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         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>drools</artifactId>
-    <version>1.0.0-SNAPSHOT</version>
-	
-	<packaging>pom</packaging>
-
     <parent>
         <groupId>com.baeldung</groupId>
         <artifactId>parent-modules</artifactId>
         <version>1.0.0-SNAPSHOT</version>
     </parent>
-
+	<properties>
-    <properties>
+		<http-component-version>4.4.6</http-component-version>
-        <http-component-version>4.4.6</http-component-version>
+		<drools-version>7.4.1.Final</drools-version>
-        <drools-version>7.1.0.Beta2</drools-version>
+		<apache-poi-version>3.13</apache-poi-version>
-        <apache-poi-version>3.13</apache-poi-version>
+	</properties>
-    </properties>
 
     <dependencies>
         <dependency>
@@ -70,4 +63,25 @@
 
     </dependencies>
 
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>${maven-surefire-plugin.version}</version>
+                <configuration>
+                    <forkCount>3</forkCount>
+                    <reuseForks>true</reuseForks>
+                    <excludes>
+                        <exclude>**/*IntegrationTest.java</exclude>
+                        <exclude>**/*LongRunningUnitTest.java</exclude>
+                        <exclude>**/*ManualTest.java</exclude>
+                        <exclude>**/JdbcTest.java</exclude>
+                        <exclude>**/*LiveTest.java</exclude>
+                    </excludes>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
 </project>

drools/src/main/java/com/baeldung/drools/backward_chaining/BackwardChaining.java

@@ -1,9 +1,8 @@
-package com.baeldung.drools;
+package com.baeldung.drools.backward_chaining;
 
-import org.kie.api.KieServices;
-import org.kie.api.runtime.KieContainer;
 import org.kie.api.runtime.KieSession;
 
+import com.baeldung.drools.config.DroolsBeanFactory;
 import com.baeldung.drools.model.Fact;
 import com.baeldung.drools.model.Result;
 
@@ -11,17 +10,17 @@ public class BackwardChaining {
     public static void main(String[] args) {
         Result result = new BackwardChaining().backwardChaining();
         System.out.println(result.getValue());
-        result.getFacts().stream().forEach(System.out::println);
+        result.getFacts()
+            .stream()
+            .forEach(System.out::println);
     }
 
     public Result backwardChaining() {
         Result result = new Result();
-        KieServices ks = KieServices.Factory.get();
+        KieSession ksession = new DroolsBeanFactory().getKieSession();
-        KieContainer kContainer = ks.getKieClasspathContainer();
-        KieSession ksession = kContainer.newKieSession("ksession-backward-chaining");
         ksession.setGlobal("result", result);
         ksession.insert(new Fact("Asia", "Planet Earth"));
-        // ksession.insert(new Fact("China", "Asia"));
+        ksession.insert(new Fact("China", "Asia"));
         ksession.insert(new Fact("Great Wall of China", "China"));
 
         ksession.fireAllRules();

drools/src/main/java/com/baeldung/drools/config/DroolsBeanFactory.java

@@ -3,7 +3,6 @@ package com.baeldung.drools.config;
 import org.drools.decisiontable.DecisionTableProviderImpl;
 import org.kie.api.KieServices;
 import org.kie.api.builder.*;
-import org.kie.api.io.KieResources;
 import org.kie.api.io.Resource;
 import org.kie.api.runtime.KieContainer;
 import org.kie.api.runtime.KieSession;
@@ -22,7 +21,7 @@ public class DroolsBeanFactory {
 
     private  KieFileSystem getKieFileSystem() throws IOException{
         KieFileSystem kieFileSystem = kieServices.newKieFileSystem();
-        List<String> rules=Arrays.asList("SuggestApplicant.drl","Product_rules.xls");
+        List<String> rules=Arrays.asList("BackwardChaining.drl","SuggestApplicant.drl","Product_rules.xls");
         for(String rule:rules){
             kieFileSystem.write(ResourceFactory.newClassPathResource(rule));
         }
@@ -56,9 +55,11 @@ public class DroolsBeanFactory {
         getKieRepository();
         KieFileSystem kieFileSystem = kieServices.newKieFileSystem();
 
+        kieFileSystem.write(ResourceFactory.newClassPathResource("com/baeldung/drools/rules/BackwardChaining.drl"));
         kieFileSystem.write(ResourceFactory.newClassPathResource("com/baeldung/drools/rules/SuggestApplicant.drl"));
         kieFileSystem.write(ResourceFactory.newClassPathResource("com/baeldung/drools/rules/Product_rules.xls"));
         
+        
         KieBuilder kb = kieServices.newKieBuilder(kieFileSystem);
         kb.buildAll();
         KieModule kieModule = kb.getKieModule();

drools/src/main/resources/com/baeldung/drools/rules/BackwardChaining.drl

@@ -1,4 +1,4 @@
-package com.baeldung
+package com.baeldung.drools.rules
 
 import com.baeldung.drools.model.Fact;
 

drools/src/test/java/com/baeldung/drools/backward_chaining/BackwardChainingTest.java

@@ -0,0 +1,36 @@
+package com.baeldung.drools.backward_chaining;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.kie.api.runtime.KieSession;
+
+import com.baeldung.drools.config.DroolsBeanFactory;
+import com.baeldung.drools.model.Fact;
+import com.baeldung.drools.model.Result;
+
+import static junit.framework.TestCase.assertEquals;
+
+public class BackwardChainingTest {
+    private Result result;
+    private KieSession ksession;
+ 
+    @Before
+    public void before() {
+        result = new Result();
+        ksession = new DroolsBeanFactory().getKieSession();
+    }
+
+    @Test
+    public void whenWallOfChinaIsGiven_ThenItBelongsToPlanetEarth() {
+
+        ksession.setGlobal("result", result);
+        ksession.insert(new Fact("Asia", "Planet Earth"));
+        ksession.insert(new Fact("China", "Asia"));
+        ksession.insert(new Fact("Great Wall of China", "China"));
+
+        ksession.fireAllRules();
+        
+        // Assert Decision one
+        assertEquals(result.getValue(), "Decision one taken: Great Wall of China BELONGS TO Planet Earth");
+    }
+}

ejb/wildfly/widlfly-web/src/main/java/TestEJBServlet.java

@@ -16,32 +16,26 @@ import wildfly.beans.UserBeanLocal;
  * Servlet implementation class TestEJBServlet
  */
 public class TestEJBServlet extends HttpServlet {
-	private static final long serialVersionUID = 1L;
 
-	@EJB
+    @EJB
-	private UserBeanLocal userBean;
+    private UserBeanLocal userBean;
 
-	protected void doGet(HttpServletRequest request, HttpServletResponse response)
+    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-			throws ServletException, IOException {
+        List<User> users = userBean.getUsers();
-		List<User> users = userBean.getUsers();
 
-		PrintWriter out = response.getWriter();
+        PrintWriter out = response.getWriter();
 
-		out.println("<html>");
+        out.println("<html>");
-		out.println("<head><title>Users</title></head>");
+        out.println("<body>");
-		out.println("<body>");
+        for (User user : users) {
-		out.println("<center><h1>List of users:</h1>");
+            out.print(user.getUsername());
-		out.println("<table border=\"1\" align=\"center\" style=\"width:50%\">");
+            out.print(" " + user.getEmail() + " <br>");
-		for (User user : users) {
+        }
-			out.println("<tr>");
+        out.println("</body>");
-			out.print("<td>" + user.getUsername() + "</td>");
+        out.println("</html>");
-			out.print("<td>" + user.getEmail() + "</td>");
+    }
-			out.println("</tr>");
-		}
-	}
 
-	protected void doPost(HttpServletRequest request, HttpServletResponse response)
+    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-			throws ServletException, IOException {
+        doGet(request, response);
-		doGet(request, response);
+    }
-	}
 }

guava-modules/README.md

@@ -0,0 +1,3 @@
+
+## Guava Modules
+

guava-modules/guava-18/pom.xml

@@ -4,13 +4,14 @@
     <modelVersion>4.0.0</modelVersion>
 
     <groupId>com.baeldung</groupId>
-    <artifactId>guava18</artifactId>
+    <artifactId>guava-18</artifactId>
     <version>0.1.0-SNAPSHOT</version>
 
     <parent>
         <groupId>com.baeldung</groupId>
         <artifactId>parent-modules</artifactId>
         <version>1.0.0-SNAPSHOT</version>
+        <relativePath>../</relativePath>        
     </parent>
 
     <dependencies>

guava-modules/guava-19/pom.xml

@@ -4,13 +4,14 @@
     <modelVersion>4.0.0</modelVersion>
 
     <groupId>com.baeldung</groupId>
-    <artifactId>guava19</artifactId>
+    <artifactId>guava-19</artifactId>
     <version>0.1.0-SNAPSHOT</version>
 
     <parent>
         <groupId>com.baeldung</groupId>
         <artifactId>parent-modules</artifactId>
         <version>1.0.0-SNAPSHOT</version>
+        <relativePath>../</relativePath>
     </parent>
 
     <dependencies>