- Updated test names to reflect what it is testing

java-dates/src/test/java/com/baeldung/date/AgeCalculatorUnitTest.java

@@ -0,0 +1,31 @@
+package com.baeldung.date;
+
+import static org.junit.Assert.assertEquals;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.time.LocalDate;
+import java.util.Date;
+import org.junit.jupiter.api.Test;
+
+public class AgeCalculatorUnitTest {
+    AgeCalculator ageCalculator = new AgeCalculator();
+
+    @Test
+    public void givenLocalDate_whenCalculateAge_thenOk() {
+        assertEquals(10, ageCalculator.calculateAge(LocalDate.of(2008, 5, 20), LocalDate.of(2018, 9, 20)));
+    }
+
+    @Test
+    public void givenJodaTime_whenCalculateAge_thenOk() {
+        assertEquals(10, ageCalculator.calculateAgeWithJodaTime(new org.joda.time.LocalDate(2008, 5, 20), new org.joda.time.LocalDate(2018, 9, 20)));
+    }
+
+    @Test
+    public void givenDate_whenCalculateAge_thenOk() throws ParseException {
+        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-mm-dd");
+        Date birthDate = sdf.parse("2008-05-20");
+        Date currentDate = sdf.parse("2018-09-20");
+        assertEquals(10, ageCalculator.calculateAgeWithJava7(birthDate, currentDate));
+    }
+
+}

java-dates/src/test/java/com/baeldung/date/DateDiffUnitTest.java

@@ -0,0 +1,115 @@
+package com.baeldung.date;
+
+import org.junit.Test;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.time.Duration;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.Period;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+import java.time.temporal.ChronoUnit;
+import java.util.Date;
+import java.util.Locale;
+import java.util.TimeZone;
+import java.util.concurrent.TimeUnit;
+
+import static org.junit.Assert.assertEquals;
+
+public class DateDiffUnitTest {
+
+    @Test
+    public void givenTwoDatesBeforeJava8_whenDifferentiating_thenWeGetSix() throws ParseException {
+        SimpleDateFormat sdf = new SimpleDateFormat("MM/dd/yyyy", Locale.ENGLISH);
+        Date firstDate = sdf.parse("06/24/2017");
+        Date secondDate = sdf.parse("06/30/2017");
+
+        long diffInMillies = Math.abs(secondDate.getTime() - firstDate.getTime());
+        long diff = TimeUnit.DAYS.convert(diffInMillies, TimeUnit.MILLISECONDS);
+
+        assertEquals(diff, 6);
+    }
+    
+    @Test
+    public void givenTwoDatesInJava8_whenDifferentiating_thenWeGetSix() {
+        LocalDate now = LocalDate.now();
+        LocalDate sixDaysBehind = now.minusDays(6);
+
+        Period period = Period.between(now, sixDaysBehind);
+        int diff = period.getDays();
+
+        assertEquals(diff, 6);
+    }
+
+    @Test
+    public void givenTwoDateTimesInJava8_whenDifferentiating_thenWeGetSix() {
+        LocalDateTime now = LocalDateTime.now();
+        LocalDateTime sixMinutesBehind = now.minusMinutes(6);
+
+        Duration duration = Duration.between(now, sixMinutesBehind);
+        long diff = Math.abs(duration.toMinutes());
+
+        assertEquals(diff, 6);
+    }
+
+    @Test
+    public void givenTwoDateTimesInJava8_whenDifferentiatingInSeconds_thenWeGetTen() {
+        LocalDateTime now = LocalDateTime.now();
+        LocalDateTime tenSecondsLater = now.plusSeconds(10);
+
+        long diff = ChronoUnit.SECONDS.between(now, tenSecondsLater);
+
+        assertEquals(diff, 10);
+    }
+
+    @Test
+    public void givenTwoZonedDateTimesInJava8_whenDifferentiating_thenWeGetSix() {
+        LocalDateTime ldt = LocalDateTime.now();
+        ZonedDateTime now = ldt.atZone(ZoneId.of("America/Montreal"));
+        ZonedDateTime sixDaysBehind = now.withZoneSameInstant(ZoneId.of("Asia/Singapore")).minusDays(6);
+        long diff = ChronoUnit.DAYS.between(sixDaysBehind, now);
+        assertEquals(diff, 6);
+    }
+
+    @Test
+    public void givenTwoDateTimesInJava8_whenDifferentiatingInSecondsUsingUntil_thenWeGetTen() {
+        LocalDateTime now = LocalDateTime.now();
+        LocalDateTime tenSecondsLater = now.plusSeconds(10);
+
+        long diff = now.until(tenSecondsLater, ChronoUnit.SECONDS);
+
+        assertEquals(diff, 10);
+    }
+
+    @Test
+    public void givenTwoDatesInJodaTime_whenDifferentiating_thenWeGetSix() {
+        org.joda.time.LocalDate now = org.joda.time.LocalDate.now();
+        org.joda.time.LocalDate sixDaysBehind = now.minusDays(6);
+
+        org.joda.time.Period period = new org.joda.time.Period(now, sixDaysBehind);
+        long diff = Math.abs(period.getDays());
+
+        assertEquals(diff, 6);
+    }
+
+    @Test
+    public void givenTwoDateTimesInJodaTime_whenDifferentiating_thenWeGetSix() {
+        org.joda.time.LocalDateTime now = org.joda.time.LocalDateTime.now();
+        org.joda.time.LocalDateTime sixMinutesBehind = now.minusMinutes(6);
+
+        org.joda.time.Period period = new org.joda.time.Period(now, sixMinutesBehind);
+        long diff = Math.abs(period.getDays());
+    }
+
+    @Test
+    public void givenTwoDatesInDate4j_whenDifferentiating_thenWeGetSix() {
+        hirondelle.date4j.DateTime now = hirondelle.date4j.DateTime.now(TimeZone.getDefault());
+        hirondelle.date4j.DateTime sixDaysBehind = now.minusDays(6);
+
+        long diff = Math.abs(now.numDaysFrom(sixDaysBehind));
+
+        assertEquals(diff, 6);
+    }
+}

java-dates/src/test/java/com/baeldung/date/DateWithoutTimeUnitTest.java

@@ -0,0 +1,92 @@
+package com.baeldung.date;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.text.ParseException;
+import java.time.LocalDate;
+import java.time.OffsetDateTime;
+import java.util.Calendar;
+import java.util.Date;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+
+public class DateWithoutTimeUnitTest {
+
+    private static final long MILLISECONDS_PER_DAY = 24 * 60 * 60 * 1000;
+
+    @Test
+    public void whenGettingDateWithoutTimeUsingCalendar_thenReturnDateWithoutTime() {
+        Date dateWithoutTime = DateWithoutTime.getDateWithoutTimeUsingCalendar();
+
+        // first check the time is set to 0
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(dateWithoutTime);
+
+        assertEquals(0, calendar.get(Calendar.HOUR_OF_DAY));
+        assertEquals(0, calendar.get(Calendar.MINUTE));
+        assertEquals(0, calendar.get(Calendar.SECOND));
+        assertEquals(0, calendar.get(Calendar.MILLISECOND));
+
+        // we get the day of the date
+        int day = calendar.get(Calendar.DAY_OF_MONTH);
+
+        // if we add the mills of one day minus 1 we should get the same day
+        calendar.setTimeInMillis(dateWithoutTime.getTime() + MILLISECONDS_PER_DAY - 1);
+        assertEquals(day, calendar.get(Calendar.DAY_OF_MONTH));
+
+        // if we add one full day in millis we should get a different day
+        calendar.setTimeInMillis(dateWithoutTime.getTime() + MILLISECONDS_PER_DAY);
+        assertNotEquals(day, calendar.get(Calendar.DAY_OF_MONTH));
+    }
+
+    @Test
+    public void whenGettingDateWithoutTimeUsingFormat_thenReturnDateWithoutTime() throws ParseException {
+        Date dateWithoutTime = DateWithoutTime.getDateWithoutTimeUsingFormat();
+
+        // first check the time is set to 0
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(dateWithoutTime);
+
+        assertEquals(0, calendar.get(Calendar.HOUR_OF_DAY));
+        assertEquals(0, calendar.get(Calendar.MINUTE));
+        assertEquals(0, calendar.get(Calendar.SECOND));
+        assertEquals(0, calendar.get(Calendar.MILLISECOND));
+
+        // we get the day of the date
+        int day = calendar.get(Calendar.DAY_OF_MONTH);
+
+        // if we add the mills of one day minus 1 we should get the same day
+        calendar.setTimeInMillis(dateWithoutTime.getTime() + MILLISECONDS_PER_DAY - 1);
+        assertEquals(day, calendar.get(Calendar.DAY_OF_MONTH));
+
+        // if we add one full day in millis we should get a different day
+        calendar.setTimeInMillis(dateWithoutTime.getTime() + MILLISECONDS_PER_DAY);
+        assertNotEquals(day, calendar.get(Calendar.DAY_OF_MONTH));
+    }
+
+    @Test
+    public void whenGettingLocalDate_thenReturnDateWithoutTime() {
+        // get the local date
+        LocalDate localDate = DateWithoutTime.getLocalDate();
+
+        // get the millis of our LocalDate
+        long millisLocalDate = localDate
+          .atStartOfDay()
+          .toInstant(OffsetDateTime
+            .now()
+            .getOffset())
+          .toEpochMilli();
+
+        Calendar calendar = Calendar.getInstance();
+        // if we add the millis of one day minus 1 we should get the same day
+        calendar.setTimeInMillis(millisLocalDate + MILLISECONDS_PER_DAY - 1);
+        assertEquals(localDate.getDayOfMonth(), calendar.get(Calendar.DAY_OF_MONTH));
+
+        // if we add one full day in millis we should get a different day
+        calendar.setTimeInMillis(millisLocalDate + MILLISECONDS_PER_DAY);
+        assertNotEquals(localDate.getDayOfMonth(), calendar.get(Calendar.DAY_OF_MONTH));
+    }
+
+}

java-dates/src/test/java/com/baeldung/date/comparison/DateTimeComparisonUtilsUnitTest.java

@@ -0,0 +1,75 @@
+package com.baeldung.date.comparison;
+
+import org.junit.jupiter.api.Test;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertThat;
+
+class DateTimeComparisonUtilsUnitTest {
+
+    @Test
+    void givenLocalDateTimes_whenIsSameDay_thenCompareTrue() {
+        LocalDateTime firstTimestamp = LocalDateTime.of(2019, 8, 10, 11, 00, 0);
+        LocalDateTime secondTimestamp = firstTimestamp.plusHours(5);
+        LocalDateTime thirdTimestamp = firstTimestamp.plusDays(1);
+
+        assertThat(DateTimeComparisonUtils.isSameDay(firstTimestamp, secondTimestamp), is(true));
+
+        assertThat(DateTimeComparisonUtils.isSameDay(secondTimestamp, thirdTimestamp), is(false));
+    }
+
+    @Test
+    void givenLocalDateAndLocalDateTime_whenIsSameDay_thenCompareTrue() {
+        LocalDate localDate = LocalDate.of(2019, 8, 10);
+        LocalDateTime localDateTime = LocalDateTime.of(2019, 8, 10, 11, 30, 0);
+
+        assertThat(DateTimeComparisonUtils.isSameDay(localDateTime, localDate), is(true));
+    }
+
+    @Test
+    void givenLocalDateTimes_whenIsSameHour_thenCompareTrue() {
+        LocalDateTime firstTimestamp = LocalDateTime.of(2019, 8, 10, 8, 00, 0);
+        LocalDateTime secondTimestamp = firstTimestamp.plusMinutes(15);
+        LocalDateTime thirdTimestamp = firstTimestamp.plusHours(2);
+
+        assertThat(DateTimeComparisonUtils.isSameHour(firstTimestamp, secondTimestamp), is(true));
+
+        assertThat(DateTimeComparisonUtils.isSameHour(secondTimestamp, thirdTimestamp), is(false));
+    }
+
+    @Test
+    void givenLocalDateTimes_whenIsSameMinute_thenCompareTrue() {
+        LocalDateTime firstTimestamp = LocalDateTime.of(2019, 8, 10, 8, 15, 0);
+        LocalDateTime secondTimestamp = firstTimestamp.plusSeconds(30);
+        LocalDateTime thirdTimestamp = firstTimestamp.plusMinutes(5);
+
+        assertThat(DateTimeComparisonUtils.isSameMinute(firstTimestamp, secondTimestamp), is(true));
+
+        assertThat(DateTimeComparisonUtils.isSameMinute(secondTimestamp, thirdTimestamp), is(false));
+    }
+
+    @Test
+    void givenZonedDateTimes_whenIsSameHour_thenCompareTrue() {
+        ZonedDateTime zonedTimestamp = ZonedDateTime.of(2019, 8, 10, 8, 0, 0, 30,
+          ZoneId.of("America/New_York"));
+        ZonedDateTime zonedTimestampToCompare = ZonedDateTime.of(2019, 8, 10, 14, 0, 0, 0,
+          ZoneId.of("Europe/Berlin"));
+
+        assertThat(DateTimeComparisonUtils.isSameHour(zonedTimestamp, zonedTimestampToCompare), is(true));
+    }
+
+    @Test
+    void givenZonedDateTimeAndLocalDateTime_whenIsSameHour_thenCompareTrue() {
+        ZonedDateTime zonedTimestamp = ZonedDateTime.of(2019, 8, 10, 8, 15, 0, 0,
+          ZoneId.of("America/New_York"));
+        LocalDateTime localTimestamp = LocalDateTime.of(2019, 8, 10, 14, 20, 0);
+        ZoneId zoneId = ZoneId.of("Europe/Berlin");
+
+        assertThat(DateTimeComparisonUtils.isSameHour(zonedTimestamp, localTimestamp, zoneId), is(true));
+    }
+}

java-dates/src/test/java/com/baeldung/date/comparison/Java8DateTimeApiGeneralComparisonsUnitTest.java

@@ -0,0 +1,83 @@
+package com.baeldung.date.comparison;
+
+import org.junit.Test;
+
+import java.time.*;
+
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertThat;
+
+public class Java8DateTimeApiGeneralComparisonsUnitTest {
+
+    @Test
+    public void givenLocalDates_whenComparing_thenAssertsPass() {
+        LocalDate firstDate = LocalDate.of(2019, 8, 10);
+        LocalDate secondDate = LocalDate.of(2019, 7, 1);
+        LocalDate thirdDate = LocalDate.of(2019, 7, 1); // same date as secondDate
+
+        assertThat(firstDate.isAfter(secondDate), is(true));
+        assertThat(firstDate.isBefore(secondDate), is(false));
+
+        assertThat(firstDate.isEqual(secondDate), is(false));
+        assertThat(firstDate.equals(secondDate), is(false));
+
+        assertThat(firstDate.compareTo(secondDate), is(1));
+        assertThat(secondDate.compareTo(firstDate), is(-1));
+
+        assertThat(secondDate.isAfter(thirdDate), is(false));
+        assertThat(secondDate.isBefore(thirdDate), is(false));
+        assertThat(secondDate.isEqual(thirdDate), is(true));
+        assertThat(secondDate.equals(thirdDate), is(true));
+        assertThat(secondDate.compareTo(thirdDate), is(0));
+    }
+
+    @Test
+    public void givenLocalDateTimes_whenComparing_thenAssertsPass() {
+        LocalDateTime firstTimestamp = LocalDateTime.of(2019, 8, 10, 11, 30, 0);
+        LocalDateTime secondTimestamp = LocalDateTime.of(2019, 8, 10, 11, 15, 0);
+        LocalDateTime thirdTimestamp = LocalDateTime.of(2019, 8, 10, 11, 15, 0); // same as secondTimestamp
+
+        assertThat(firstTimestamp.isAfter(secondTimestamp), is(true));
+        assertThat(firstTimestamp.isBefore(secondTimestamp), is(false));
+
+        assertThat(firstTimestamp.isEqual(secondTimestamp), is(false));
+        assertThat(firstTimestamp.equals(secondTimestamp), is(false));
+
+        assertThat(firstTimestamp.compareTo(secondTimestamp), is(1));
+        assertThat(secondTimestamp.compareTo(firstTimestamp), is(-1));
+
+        assertThat(secondTimestamp.isAfter(thirdTimestamp), is(false));
+        assertThat(secondTimestamp.isBefore(thirdTimestamp), is(false));
+        assertThat(secondTimestamp.isEqual(thirdTimestamp), is(true));
+        assertThat(secondTimestamp.compareTo(thirdTimestamp), is(0));
+    }
+
+    @Test
+    public void givenZonedDateTimes_whenComparing_thenAssertsPass() {
+        ZonedDateTime timeInNewYork = ZonedDateTime.of(2019, 8, 10, 8, 0, 0, 0,
+          ZoneId.of("America/New_York"));
+        ZonedDateTime timeInBerlin = ZonedDateTime.of(2019, 8, 10, 14, 0, 0, 0,
+          ZoneId.of("Europe/Berlin"));
+
+        assertThat(timeInNewYork.isAfter(timeInBerlin), is(false));
+        assertThat(timeInNewYork.isBefore(timeInBerlin), is(false));
+
+        assertThat(timeInNewYork.isEqual(timeInBerlin), is(true));
+        assertThat(timeInNewYork.equals(timeInBerlin), is(false));
+
+        assertThat(timeInNewYork.compareTo(timeInBerlin), is(-1));
+    }
+
+    @Test
+    public void givenLocalTimes_whenComparing_thenAssertsPass() {
+        LocalTime firstTime = LocalTime.of(8, 30);
+        LocalTime secondTime = LocalTime.of(9, 45);
+
+        assertThat(firstTime.isAfter(secondTime), is(false));
+        assertThat(firstTime.isBefore(secondTime), is(true));
+
+        assertThat(firstTime.equals(secondTime), is(false));
+
+        assertThat(firstTime.compareTo(secondTime), is(-1));
+    }
+}

java-dates/src/test/java/com/baeldung/date/comparison/LegacyDateComparisonUtilsUnitTest.java

@@ -0,0 +1,54 @@
+package com.baeldung.date.comparison;
+
+import org.junit.jupiter.api.Test;
+
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.util.Date;
+
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertThat;
+
+class LegacyDateComparisonUtilsUnitTest {
+
+    private Date toDate(LocalDateTime localDateTime) {
+        return Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());
+    }
+
+    @Test
+    void givenDatesWithDifferentHours_whenIsSameDay_thenReturnsTrue() {
+        Date firstDate = toDate(LocalDateTime.of(2019, 8, 10, 11, 00, 00));
+        Date secondDate = toDate(LocalDateTime.of(2019, 8, 10, 12, 00, 00));
+        Date thirdDate = toDate(LocalDateTime.of(2019, 8, 15, 12, 00, 00));
+
+        assertThat(LegacyDateComparisonUtils.isSameDay(firstDate, secondDate), is(true));
+        assertThat(LegacyDateComparisonUtils.isSameDay(secondDate, thirdDate), is(false));
+    }
+
+    @Test
+    void givenDatesWithingSameHour_whenIsSameHour_thenReturnsTrue() {
+        Date firstDate = toDate(LocalDateTime.of(2019, 8, 10, 11, 00, 00));
+        Date secondDate = toDate(LocalDateTime.of(2019, 8, 10, 11, 15, 00));
+        Date thirdDate = toDate(LocalDateTime.of(2019, 8, 10, 12, 00, 00));
+
+        assertThat(LegacyDateComparisonUtils.isSameHour(firstDate, secondDate), is(true));
+        assertThat(LegacyDateComparisonUtils.isSameHour(secondDate, thirdDate), is(false));
+    }
+
+    @Test
+    void givenDates__whenComparing_thenAssertsPass() {
+        Date firstDate = toDate(LocalDateTime.of(2019, 8, 10, 0, 00, 00));
+        Date secondDate = toDate(LocalDateTime.of(2019, 8, 15, 0, 00, 00));
+        Date thirdDate = toDate(LocalDateTime.of(2019, 8, 15, 0, 00, 00)); // same date as secondDate
+
+        assertThat(firstDate.after(secondDate), is(false));
+        assertThat(firstDate.before(secondDate), is(true));
+        assertThat(firstDate.compareTo(secondDate), is(-1));
+        assertThat(firstDate.equals(secondDate), is(false));
+
+        assertThat(thirdDate.after(secondDate), is(false));
+        assertThat(thirdDate.before(secondDate), is(false));
+        assertThat(thirdDate.compareTo(secondDate), is(0));
+        assertThat(thirdDate.equals(secondDate), is(true));
+    }
+}

java-dates/src/test/java/com/baeldung/dateapi/ConversionExample.java

@@ -0,0 +1,19 @@
+package com.baeldung.dateapi;
+
+import java.time.Instant;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+import java.util.Date;
+import java.util.GregorianCalendar;
+import java.util.TimeZone;
+
+public class ConversionExample {
+    public static void main(String[] args) {
+        Instant instantFromCalendar = GregorianCalendar.getInstance().toInstant();
+        ZonedDateTime zonedDateTimeFromCalendar = new GregorianCalendar().toZonedDateTime();
+        Date dateFromInstant = Date.from(Instant.now());
+        GregorianCalendar calendarFromZonedDateTime = GregorianCalendar.from(ZonedDateTime.now());
+        Instant instantFromDate = new Date().toInstant();
+        ZoneId zoneIdFromTimeZone = TimeZone.getTimeZone("PST").toZoneId();
+    }
+}

java-dates/src/test/java/com/baeldung/dateapi/JavaDurationUnitTest.java

@@ -0,0 +1,42 @@
+package com.baeldung.dateapi;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+
+import java.time.Duration;
+import java.time.Instant;
+import java.time.temporal.ChronoUnit;
+
+import org.junit.Test;
+
+public class JavaDurationUnitTest {
+
+    @Test
+    public void test2() {
+        Instant start = Instant.parse("2017-10-03T10:15:30.00Z");
+        Instant end = Instant.parse("2017-10-03T10:16:30.00Z");
+
+        Duration duration = Duration.between(start, end);
+
+        assertFalse(duration.isNegative());
+
+        assertEquals(60, duration.getSeconds());
+        assertEquals(1, duration.toMinutes());
+
+        Duration fromDays = Duration.ofDays(1);
+        assertEquals(86400, fromDays.getSeconds());
+
+        Duration fromMinutes = Duration.ofMinutes(60);
+        assertEquals(1, fromMinutes.toHours());
+
+        assertEquals(120, duration.plusSeconds(60).getSeconds());
+        assertEquals(30, duration.minusSeconds(30).getSeconds());
+
+        assertEquals(120, duration.plus(60, ChronoUnit.SECONDS).getSeconds());
+        assertEquals(30, duration.minus(30, ChronoUnit.SECONDS).getSeconds());
+
+        Duration fromChar1 = Duration.parse("P1DT1H10M10.5S");
+        Duration fromChar2 = Duration.parse("PT10M");
+    }
+
+}

java-dates/src/test/java/com/baeldung/dateapi/JavaPeriodUnitTest.java

@@ -0,0 +1,44 @@
+package com.baeldung.dateapi;
+
+import org.apache.log4j.Logger;
+import org.junit.Test;
+
+import java.time.LocalDate;
+import java.time.Period;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+
+public class JavaPeriodUnitTest {
+
+    private static final Logger LOG = Logger.getLogger(JavaPeriodUnitTest.class);
+
+    @Test
+    public void whenTestPeriod_thenOk() {
+
+        LocalDate startDate = LocalDate.of(2015, 2, 15);
+        LocalDate endDate = LocalDate.of(2017, 1, 21);
+
+        Period period = Period.between(startDate, endDate);
+
+        LOG.info(String.format("Years:%d months:%d days:%d", period.getYears(), period.getMonths(), period.getDays()));
+
+        assertFalse(period.isNegative());
+        assertEquals(56, period.plusDays(50).getDays());
+        assertEquals(9, period.minusMonths(2).getMonths());
+
+        Period fromUnits = Period.of(3, 10, 10);
+        Period fromDays = Period.ofDays(50);
+        Period fromMonths = Period.ofMonths(5);
+        Period fromYears = Period.ofYears(10);
+        Period fromWeeks = Period.ofWeeks(40);
+
+        assertEquals(280, fromWeeks.getDays());
+
+        Period fromCharYears = Period.parse("P2Y");
+        assertEquals(2, fromCharYears.getYears());
+        Period fromCharUnits = Period.parse("P2Y3M5D");
+        assertEquals(5, fromCharUnits.getDays());
+    }
+
+}

java-dates/src/test/java/com/baeldung/dateapi/JavaUtilTimeUnitTest.java

@@ -0,0 +1,89 @@
+package com.baeldung.dateapi;
+
+import org.junit.Test;
+
+import java.text.ParseException;
+import java.time.Duration;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.Month;
+import java.time.YearMonth;
+import java.time.format.DateTimeFormatter;
+import java.time.temporal.ChronoUnit;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class JavaUtilTimeUnitTest {
+
+    @Test
+    public void currentTime() {
+        final LocalDate now = LocalDate.now();
+
+        System.out.println(now);
+        // there is not much to test here
+    }
+
+    @Test
+    public void specificTime() {
+        LocalDate birthDay = LocalDate.of(1990, Month.DECEMBER, 15);
+
+        System.out.println(birthDay);
+        // there is not much to test here
+    }
+
+    @Test
+    public void extractMonth() {
+        Month month = LocalDate.of(1990, Month.DECEMBER, 15).getMonth();
+
+        assertThat(month).isEqualTo(Month.DECEMBER);
+    }
+
+    @Test
+    public void subtractTime() {
+        LocalDateTime fiveHoursBefore = LocalDateTime.of(1990, Month.DECEMBER, 15, 15, 0).minusHours(5);
+
+        assertThat(fiveHoursBefore.getHour()).isEqualTo(10);
+    }
+
+    @Test
+    public void alterField() {
+        LocalDateTime inJune = LocalDateTime.of(1990, Month.DECEMBER, 15, 15, 0).with(Month.JUNE);
+
+        assertThat(inJune.getMonth()).isEqualTo(Month.JUNE);
+    }
+
+    @Test
+    public void truncate() {
+        LocalTime truncated = LocalTime.of(15, 12, 34).truncatedTo(ChronoUnit.HOURS);
+
+        assertThat(truncated).isEqualTo(LocalTime.of(15, 0, 0));
+    }
+
+    @Test
+    public void getTimeSpan() {
+        LocalDateTime now = LocalDateTime.now();
+        LocalDateTime hourLater = now.plusHours(1);
+        Duration span = Duration.between(now, hourLater);
+
+        assertThat(span).isEqualTo(Duration.ofHours(1));
+    }
+
+    @Test
+    public void formatAndParse() throws ParseException {
+        LocalDate someDate = LocalDate.of(2016, 12, 7);
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
+        String formattedDate = someDate.format(formatter);
+        LocalDate parsedDate = LocalDate.parse(formattedDate, formatter);
+
+        assertThat(formattedDate).isEqualTo("2016-12-07");
+        assertThat(parsedDate).isEqualTo(someDate);
+    }
+
+    @Test
+    public void daysInMonth() {
+        int daysInMonth = YearMonth.of(1990, 2).lengthOfMonth();
+
+        assertThat(daysInMonth).isEqualTo(28);
+    }
+}

java-dates/src/test/java/com/baeldung/datetime/AddHoursToDateUnitTest.java

@@ -0,0 +1,116 @@
+package com.baeldung.datetime;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.time.Instant;
+import java.time.LocalDateTime;
+import java.time.Month;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.GregorianCalendar;
+
+import org.junit.Test;
+
+public class AddHoursToDateUnitTest {
+
+    private final AddHoursToDate addHoursToDateObj = new AddHoursToDate();
+
+    @Test
+    public void givenJavaUtilDate_whenPositiveHours_thenAddHours() {
+        Date actualDate = new GregorianCalendar(2018, Calendar.JUNE, 25, 5, 0).getTime();
+        Date expectedDate = new GregorianCalendar(2018, Calendar.JUNE, 25, 7, 0).getTime();
+
+        assertThat(addHoursToDateObj.addHoursToJavaUtilDate(actualDate, 2)).isEqualTo(expectedDate);
+    }
+
+    @Test
+    public void givenJavaUtilDate_whenNegativeHours_thenMinusHours() {
+        Date actualDate = new GregorianCalendar(2018, Calendar.JUNE, 25, 5, 0).getTime();
+        Date expectedDate = new GregorianCalendar(2018, Calendar.JUNE, 25, 3, 0).getTime();
+
+        assertThat(addHoursToDateObj.addHoursToJavaUtilDate(actualDate, -2)).isEqualTo(expectedDate);
+    }
+
+    @Test
+    public void givenJavaUtilDate_whenUsingToInstantAndPostiveHours_thenAddHours() {
+        Date actualDate = new GregorianCalendar(2018, Calendar.JUNE, 25, 5, 0).getTime();
+        Date expectedDate = new GregorianCalendar(2018, Calendar.JUNE, 25, 7, 0).getTime();
+
+        assertThat(addHoursToDateObj.addHoursToDateUsingInstant(actualDate, 2)).isEqualTo(expectedDate);
+    }
+
+    @Test
+    public void givenJavaUtilDate_whenUsingToInstantAndNegativeHours_thenAddHours() {
+        Date actualDate = new GregorianCalendar(2018, Calendar.JUNE, 25, 5, 0).getTime();
+        Date expectedDate = new GregorianCalendar(2018, Calendar.JUNE, 25, 3, 0).getTime();
+
+        assertThat(addHoursToDateObj.addHoursToDateUsingInstant(actualDate, -2)).isEqualTo(expectedDate);
+    }
+
+    @Test
+    public void givenLocalDateTime_whenUsingAddHoursToLocalDateTime_thenAddHours() {
+        LocalDateTime actualDateTime = LocalDateTime.of(2018, Month.JUNE, 25, 5, 0);
+        LocalDateTime expectedDateTime = LocalDateTime.of(2018, Month.JUNE, 25, 7, 0);
+
+        assertThat(addHoursToDateObj.addHoursToLocalDateTime(actualDateTime, 2)).isEqualTo(expectedDateTime);
+    }
+
+    @Test
+    public void givenLocalDateTime_whenUsingMinusHoursToLocalDateTime_thenMinusHours() {
+        LocalDateTime actualDateTime = LocalDateTime.of(2018, Month.JUNE, 25, 5, 0);
+        LocalDateTime expectedDateTime = LocalDateTime.of(2018, Month.JUNE, 25, 3, 0);
+
+        assertThat(addHoursToDateObj.subtractHoursToLocalDateTime(actualDateTime, 2)).isEqualTo(expectedDateTime);
+    }
+
+    @Test
+    public void givenZonedDateTime_whenUsingAddHoursToZonedDateTime_thenAddHours() {
+        ZonedDateTime actualZonedDateTime = ZonedDateTime.of(LocalDateTime.of(2018, Month.JUNE, 25, 5, 0), ZoneId.systemDefault());
+        ZonedDateTime expectedZonedDateTime = ZonedDateTime.of(LocalDateTime.of(2018, Month.JUNE, 25, 7, 0), ZoneId.systemDefault());
+
+        assertThat(addHoursToDateObj.addHoursToZonedDateTime(actualZonedDateTime, 2)).isEqualTo(expectedZonedDateTime);
+    }
+
+    @Test
+    public void givenZonedDateTime_whenUsingMinusHoursToZonedDateTime_thenMinusHours() {
+        ZonedDateTime actualZonedDateTime = ZonedDateTime.of(LocalDateTime.of(2018, Month.JUNE, 25, 5, 0), ZoneId.systemDefault());
+        ZonedDateTime expectedZonedDateTime = ZonedDateTime.of(LocalDateTime.of(2018, Month.JUNE, 25, 3, 0), ZoneId.systemDefault());
+
+        assertThat(addHoursToDateObj.subtractHoursToZonedDateTime(actualZonedDateTime, 2)).isEqualTo(expectedZonedDateTime);
+    }
+
+    @Test
+    public void givenJavaUtilDate_whenUsingPositiveHrsAndAddHoursWithApacheCommons_thenAddHours() {
+        Date actualDate = new GregorianCalendar(2018, Calendar.JUNE, 25, 5, 0).getTime();
+        Date expectedDate = new GregorianCalendar(2018, Calendar.JUNE, 25, 7, 0).getTime();
+
+        assertThat(addHoursToDateObj.addHoursWithApacheCommons(actualDate, 2)).isEqualTo(expectedDate);
+    }
+
+    @Test
+    public void givenJavaUtilDate_whenUsingNegativeHrsAndAddHoursWithApacheCommons_thenMinusHours() {
+        Date actualDate = new GregorianCalendar(2018, Calendar.JUNE, 25, 7, 0).getTime();
+        Date expectedDate = new GregorianCalendar(2018, Calendar.JUNE, 25, 5, 0).getTime();
+
+        assertThat(addHoursToDateObj.addHoursWithApacheCommons(actualDate, -2)).isEqualTo(expectedDate);
+    }
+
+    @Test
+    public void givenInstant_whenUsingAddHoursToInstant_thenAddHours() {
+        Instant actualValue = Instant.parse("2018-06-25T05:12:35Z");
+        Instant expectedValue = Instant.parse("2018-06-25T07:12:35Z");
+
+        assertThat(addHoursToDateObj.addHoursToInstant(actualValue, 2)).isEqualTo(expectedValue);
+    }
+
+    @Test
+    public void givenInstant_whenUsingSubtractHoursToInstant_thenMinusHours() {
+        Instant actualValue = Instant.parse("2018-06-25T07:12:35Z");
+        Instant expectedValue = Instant.parse("2018-06-25T05:12:35Z");
+
+        assertThat(addHoursToDateObj.subtractHoursToInstant(actualValue, 2)).isEqualTo(expectedValue);
+    }
+
+}

java-dates/src/test/java/com/baeldung/datetime/DateExtractYearMonthDayIntegerValuesUnitTest.java

@@ -0,0 +1,45 @@
+package com.baeldung.datetime;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+import org.junit.Before;
+import org.junit.Test;
+
+public class DateExtractYearMonthDayIntegerValuesUnitTest {
+
+    DateExtractYearMonthDayIntegerValues extractYearMonthDateIntegerValues = new DateExtractYearMonthDayIntegerValues();
+    
+    Date date;
+    
+    @Before
+    public void setup() throws ParseException
+    {
+        date=new SimpleDateFormat("dd-MM-yyyy").parse("01-03-2018");
+    }
+    
+    @Test
+    public void whenGetYear_thenCorrectYear()
+    {
+       int actualYear=extractYearMonthDateIntegerValues.getYear(date);
+       assertThat(actualYear,is(2018));
+    }
+    
+    @Test
+    public void whenGetMonth_thenCorrectMonth()
+    {
+       int actualMonth=extractYearMonthDateIntegerValues.getMonth(date);
+       assertThat(actualMonth,is(02));
+    }
+    
+    @Test
+    public void whenGetDay_thenCorrectDay()
+    {
+       int actualDayOfMonth=extractYearMonthDateIntegerValues.getDay(date);
+       assertThat(actualDayOfMonth,is(01));
+    }
+}

java-dates/src/test/java/com/baeldung/datetime/LocalDateExtractYearMonthDayIntegerValuesUnitTest.java

@@ -0,0 +1,36 @@
+package com.baeldung.datetime;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.time.LocalDate;
+
+import org.junit.Test;
+
+public class LocalDateExtractYearMonthDayIntegerValuesUnitTest {
+
+    LocalDateExtractYearMonthDayIntegerValues localDateExtractYearMonthDayIntegerValues=new LocalDateExtractYearMonthDayIntegerValues();
+    
+    LocalDate localDate=LocalDate.parse("2007-12-03");
+    
+    @Test
+    public void whenGetYear_thenCorrectYear()
+    {
+       int actualYear=localDateExtractYearMonthDayIntegerValues.getYear(localDate);
+       assertThat(actualYear,is(2007));
+    }
+    
+    @Test
+    public void whenGetMonth_thenCorrectMonth()
+    {
+       int actualMonth=localDateExtractYearMonthDayIntegerValues.getMonth(localDate);
+       assertThat(actualMonth,is(12));
+    }
+    
+    @Test
+    public void whenGetDay_thenCorrectDay()
+    {
+       int actualDayOfMonth=localDateExtractYearMonthDayIntegerValues.getDay(localDate);
+       assertThat(actualDayOfMonth,is(03));
+    }
+}

java-dates/src/test/java/com/baeldung/datetime/LocalDateTimeExtractYearMonthDayIntegerValuesUnitTest.java

@@ -0,0 +1,36 @@
+package com.baeldung.datetime;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.time.LocalDateTime;
+
+import org.junit.Test;
+
+public class LocalDateTimeExtractYearMonthDayIntegerValuesUnitTest {
+
+    LocalDateTimeExtractYearMonthDayIntegerValues localDateTimeExtractYearMonthDayIntegerValues = new LocalDateTimeExtractYearMonthDayIntegerValues();
+    
+    LocalDateTime localDateTime=LocalDateTime.parse("2007-12-03T10:15:30");
+    
+    @Test
+    public void whenGetYear_thenCorrectYear()
+    {
+       int actualYear=localDateTimeExtractYearMonthDayIntegerValues.getYear(localDateTime);
+       assertThat(actualYear,is(2007));
+    }
+    
+    @Test
+    public void whenGetMonth_thenCorrectMonth()
+    {
+       int actualMonth=localDateTimeExtractYearMonthDayIntegerValues.getMonth(localDateTime);
+       assertThat(actualMonth,is(12));
+    }
+    
+    @Test
+    public void whenGetDay_thenCorrectDay()
+    {
+       int actualDayOfMonth=localDateTimeExtractYearMonthDayIntegerValues.getDay(localDateTime);
+       assertThat(actualDayOfMonth,is(03));
+    }
+}

java-dates/src/test/java/com/baeldung/datetime/OffsetDateTimeExtractYearMonthDayIntegerValuesUnitTest.java

@@ -0,0 +1,36 @@
+package com.baeldung.datetime;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.time.OffsetDateTime;
+
+import org.junit.Test;
+
+public class OffsetDateTimeExtractYearMonthDayIntegerValuesUnitTest {
+
+    OffsetDateTimeExtractYearMonthDayIntegerValues offsetDateTimeExtractYearMonthDayIntegerValues = new OffsetDateTimeExtractYearMonthDayIntegerValues();
+    
+    OffsetDateTime offsetDateTime=OffsetDateTime.parse("2007-12-03T10:15:30+01:00");
+    
+    @Test
+    public void whenGetYear_thenCorrectYear()
+    {
+       int actualYear=offsetDateTimeExtractYearMonthDayIntegerValues.getYear(offsetDateTime);
+       assertThat(actualYear,is(2007));
+    }
+    
+    @Test
+    public void whenGetMonth_thenCorrectMonth()
+    {
+       int actualMonth=offsetDateTimeExtractYearMonthDayIntegerValues.getMonth(offsetDateTime);
+       assertThat(actualMonth,is(12));
+    }
+    
+    @Test
+    public void whenGetDay_thenCorrectDay()
+    {
+       int actualDayOfMonth=offsetDateTimeExtractYearMonthDayIntegerValues.getDay(offsetDateTime);
+       assertThat(actualDayOfMonth,is(03));
+    }
+}

java-dates/src/test/java/com/baeldung/datetime/UseLocalDateTimeUnitTest.java

@@ -0,0 +1,36 @@
+package com.baeldung.datetime;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.Month;
+
+import org.junit.Test;
+
+public class UseLocalDateTimeUnitTest {
+
+    UseLocalDateTime useLocalDateTime = new UseLocalDateTime();
+
+    @Test
+    public void givenString_whenUsingParse_thenLocalDateTime() {
+        assertEquals(LocalDate.of(2016, Month.MAY, 10), useLocalDateTime.getLocalDateTimeUsingParseMethod("2016-05-10T06:30")
+            .toLocalDate());
+        assertEquals(LocalTime.of(6, 30), useLocalDateTime.getLocalDateTimeUsingParseMethod("2016-05-10T06:30")
+            .toLocalTime());
+    }
+
+    @Test
+    public void givenLocalDateTime_whenSettingEndOfDay_thenReturnLastMomentOfDay() {
+        LocalDateTime givenTimed = LocalDateTime.parse("2018-06-23T05:55:55");
+
+        LocalDateTime endOfDayFromGivenDirectly = useLocalDateTime.getEndOfDayFromLocalDateTimeDirectly(givenTimed);
+        LocalDateTime endOfDayFromGiven = useLocalDateTime.getEndOfDayFromLocalDateTime(givenTimed);
+
+        assertThat(endOfDayFromGivenDirectly).isEqualTo(endOfDayFromGiven);
+        assertThat(endOfDayFromGivenDirectly.toLocalTime()).isEqualTo(LocalTime.MAX);
+        assertThat(endOfDayFromGivenDirectly.toString()).isEqualTo("2018-06-23T23:59:59.999999999");
+    }
+}

java-dates/src/test/java/com/baeldung/datetime/UseLocalDateUnitTest.java

@@ -0,0 +1,91 @@
+package com.baeldung.datetime;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+
+import java.time.DayOfWeek;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+
+import org.junit.Test;
+
+public class UseLocalDateUnitTest {
+
+    UseLocalDate useLocalDate = new UseLocalDate();
+
+    @Test
+    public void givenValues_whenUsingFactoryOf_thenLocalDate() {
+        assertEquals("2016-05-10", useLocalDate.getLocalDateUsingFactoryOfMethod(2016, 5, 10)
+            .toString());
+    }
+
+    @Test
+    public void givenString_whenUsingParse_thenLocalDate() {
+        assertEquals("2016-05-10", useLocalDate.getLocalDateUsingParseMethod("2016-05-10")
+            .toString());
+    }
+
+    @Test
+    public void whenUsingClock_thenLocalDate() {
+        assertEquals(LocalDate.now(), useLocalDate.getLocalDateFromClock());
+    }
+
+    @Test
+    public void givenDate_whenUsingPlus_thenNextDay() {
+        assertEquals(LocalDate.now()
+            .plusDays(1), useLocalDate.getNextDay(LocalDate.now()));
+    }
+
+    @Test
+    public void givenDate_whenUsingMinus_thenPreviousDay() {
+        assertEquals(LocalDate.now()
+            .minusDays(1), useLocalDate.getPreviousDay(LocalDate.now()));
+    }
+
+    @Test
+    public void givenToday_whenUsingGetDayOfWeek_thenDayOfWeek() {
+        assertEquals(DayOfWeek.SUNDAY, useLocalDate.getDayOfWeek(LocalDate.parse("2016-05-22")));
+    }
+
+    @Test
+    public void givenToday_whenUsingWithTemporalAdjuster_thenFirstDayOfMonth() {
+        assertEquals(1, useLocalDate.getFirstDayOfMonth()
+            .getDayOfMonth());
+    }
+
+    @Test
+    public void givenLocalDate_whenUsingAtStartOfDay_thenReturnMidnight() {
+        assertEquals(LocalDateTime.parse("2016-05-22T00:00:00"), useLocalDate.getStartOfDay(LocalDate.parse("2016-05-22")));
+    }
+
+    @Test
+    public void givenLocalDate_whenSettingStartOfDay_thenReturnMidnightInAllCases() {
+        LocalDate given = LocalDate.parse("2018-06-23");
+
+        LocalDateTime startOfDayWithMethod = useLocalDate.getStartOfDay(given);
+        LocalDateTime startOfDayOfLocalDate = useLocalDate.getStartOfDayOfLocalDate(given);
+        LocalDateTime startOfDayWithMin = useLocalDate.getStartOfDayAtMinTime(given);
+        LocalDateTime startOfDayWithMidnight = useLocalDate.getStartOfDayAtMidnightTime(given);
+
+        assertThat(startOfDayWithMethod).isEqualTo(startOfDayWithMin)
+            .isEqualTo(startOfDayWithMidnight)
+            .isEqualTo(startOfDayOfLocalDate)
+            .isEqualTo(LocalDateTime.parse("2018-06-23T00:00:00"));
+        assertThat(startOfDayWithMin.toLocalTime()).isEqualTo(LocalTime.MIDNIGHT);
+        assertThat(startOfDayWithMin.toString()).isEqualTo("2018-06-23T00:00");
+    }
+
+    @Test
+    public void givenLocalDate_whenSettingEndOfDay_thenReturnLastMomentOfDay() {
+        LocalDate given = LocalDate.parse("2018-06-23");
+
+        LocalDateTime endOfDayWithMax = useLocalDate.getEndOfDay(given);
+        LocalDateTime endOfDayFromLocalTime = useLocalDate.getEndOfDayFromLocalTime(given);
+
+        assertThat(endOfDayWithMax).isEqualTo(endOfDayFromLocalTime);
+        assertThat(endOfDayWithMax.toLocalTime()).isEqualTo(LocalTime.MAX);
+        assertThat(endOfDayWithMax.toString()).isEqualTo("2018-06-23T23:59:59.999999999");
+    }
+
+}

java-dates/src/test/java/com/baeldung/datetime/UseLocalTimeUnitTest.java

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

java-dates/src/test/java/com/baeldung/datetime/UsePeriodUnitTest.java

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

java-dates/src/test/java/com/baeldung/datetime/UseTimeZoneUnitTest.java

@@ -0,0 +1,72 @@
+package com.baeldung.datetime;
+
+import java.text.SimpleDateFormat;
+import java.time.Instant;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.TimeZone;
+
+import org.joda.time.DateTime;
+import org.joda.time.DateTimeZone;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class UseTimeZoneUnitTest {
+
+    /* https://en.wikipedia.org/wiki/List_of_tz_database_time_zones */
+
+    String timeZone = "Asia/Singapore";
+
+    private static final String PATTERN = "E yyyy-MM-dd HH:mm:ss a";
+
+    @Test
+    public void givenDateWithoutTimeZone_WhenSetTimeZoneUsingJava7_ThenTimeZoneIsSetSuccessfully() {
+        Date nowUtc = new Date();
+        TimeZone asiaSingapore = TimeZone.getTimeZone(timeZone);
+
+        Calendar nowAsiaSingapore = Calendar.getInstance(asiaSingapore);
+        nowAsiaSingapore.setTime(nowUtc);
+
+        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(PATTERN);
+        simpleDateFormat.setTimeZone(TimeZone.getTimeZone(timeZone));
+
+        System.out.println(String.format("Java7: Time now in '%s' is '%s'", nowAsiaSingapore.getTimeZone()
+            .getID(), simpleDateFormat.format(nowAsiaSingapore.getTime())));
+        
+        Assert.assertEquals(nowUtc.toInstant().getEpochSecond(), nowAsiaSingapore.toInstant().getEpochSecond());
+        Assert.assertEquals(asiaSingapore, nowAsiaSingapore.getTimeZone());
+
+    }
+
+    @Test
+    public void givenDateWithoutTimeZone_WhenSetTimeZoneUsingJava8_ThenTimeZoneIsSetSuccessfully() {
+        Instant nowUtc = Instant.now();
+        ZoneId asiaSingapore = ZoneId.of(timeZone);
+
+        ZonedDateTime nowAsiaSingapore = ZonedDateTime.ofInstant(nowUtc, asiaSingapore);
+
+        System.out.println(String.format("Java8: Time now in '%s' is '%s'", nowAsiaSingapore.getZone(), 
+            nowAsiaSingapore.format(DateTimeFormatter.ofPattern(PATTERN))));
+
+        Assert.assertEquals(nowUtc.getEpochSecond(), nowAsiaSingapore.toEpochSecond());
+        Assert.assertEquals(asiaSingapore, nowAsiaSingapore.getZone());
+    }
+
+    @Test
+    public void givenDateWithoutTimeZone_WhenSetTimeZoneUsingJodaTime_ThenTimeZoneIsSetSuccessfully() {
+        org.joda.time.Instant nowUtc = org.joda.time.Instant.now();
+        DateTimeZone asiaSingapore = DateTimeZone.forID(timeZone);
+
+        DateTime nowAsiaSingapore = nowUtc.toDateTime(asiaSingapore);
+
+        System.out.println(String.format("Joda-time: Time now in '%s' is '%s'", nowAsiaSingapore.getZone(), 
+            nowAsiaSingapore.toString(PATTERN)));
+        
+        Assert.assertEquals(nowUtc.toInstant().getMillis(), nowAsiaSingapore.toInstant().getMillis());
+        Assert.assertEquals(asiaSingapore, nowAsiaSingapore.getZone());
+    }
+
+}

java-dates/src/test/java/com/baeldung/datetime/UseZonedDateTimeUnitTest.java

@@ -0,0 +1,45 @@
+package com.baeldung.datetime;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class UseZonedDateTimeUnitTest {
+
+    UseZonedDateTime zonedDateTime = new UseZonedDateTime();
+
+    @Test
+    public void givenZoneId_thenZonedDateTime() {
+        ZoneId zoneId = ZoneId.of("Europe/Paris");
+        ZonedDateTime zonedDatetime = zonedDateTime.getZonedDateTime(LocalDateTime.parse("2016-05-20T06:30"), zoneId);
+        Assert.assertEquals(zoneId, ZoneId.from(zonedDatetime));
+    }
+
+    @Test
+    public void givenLocalDateOrZoned_whenSettingStartOfDay_thenReturnMidnightInAllCases() {
+        LocalDate given = LocalDate.parse("2018-06-23");
+        ZoneId zone = ZoneId.of("Europe/Paris");
+        ZonedDateTime zonedGiven = ZonedDateTime.of(given, LocalTime.NOON, zone);
+
+        ZonedDateTime startOfOfDayWithMethod = zonedDateTime.getStartOfDay(given, zone);
+        ZonedDateTime startOfOfDayWithShorthandMethod = zonedDateTime.getStartOfDayShorthand(given, zone);
+        ZonedDateTime startOfOfDayFromZonedDateTime = zonedDateTime.getStartOfDayFromZonedDateTime(zonedGiven);
+        ZonedDateTime startOfOfDayAtMinTime = zonedDateTime.getStartOfDayAtMinTime(zonedGiven);
+        ZonedDateTime startOfOfDayAtMidnightTime = zonedDateTime.getStartOfDayAtMidnightTime(zonedGiven);
+
+        assertThat(startOfOfDayWithMethod).isEqualTo(startOfOfDayWithShorthandMethod)
+            .isEqualTo(startOfOfDayFromZonedDateTime)
+            .isEqualTo(startOfOfDayAtMinTime)
+            .isEqualTo(startOfOfDayAtMidnightTime);
+        assertThat(startOfOfDayWithMethod.toLocalTime()).isEqualTo(LocalTime.MIDNIGHT);
+        assertThat(startOfOfDayWithMethod.toLocalTime()
+            .toString()).isEqualTo("00:00");
+    }
+}

java-dates/src/test/java/com/baeldung/datetime/ZonedDateTimeExtractYearMonthDayIntegerValuesUnitTest.java

@@ -0,0 +1,36 @@
+package com.baeldung.datetime;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.time.ZonedDateTime;
+
+import org.junit.Test;
+
+public class ZonedDateTimeExtractYearMonthDayIntegerValuesUnitTest {
+
+    ZonedDateTimeExtractYearMonthDayIntegerValues zonedDateTimeExtractYearMonthDayIntegerValues = new ZonedDateTimeExtractYearMonthDayIntegerValues();
+    
+    ZonedDateTime zonedDateTime=ZonedDateTime.parse("2007-12-03T10:15:30+01:00");
+    
+    @Test
+    public void whenGetYear_thenCorrectYear()
+    {
+       int actualYear=zonedDateTimeExtractYearMonthDayIntegerValues.getYear(zonedDateTime);
+       assertThat(actualYear,is(2007));
+    }
+    
+    @Test
+    public void whenGetMonth_thenCorrectMonth()
+    {
+       int actualMonth=zonedDateTimeExtractYearMonthDayIntegerValues.getMonth(zonedDateTime);
+       assertThat(actualMonth,is(12));
+    }
+    
+    @Test
+    public void whenGetDay_thenCorrectDay()
+    {
+       int actualDayOfMonth=zonedDateTimeExtractYearMonthDayIntegerValues.getDay(zonedDateTime);
+       assertThat(actualDayOfMonth,is(03));
+    }
+}

java-dates/src/test/java/com/baeldung/datetime/modify/DateIncrementerUnitTest.java

@@ -0,0 +1,34 @@
+package com.baeldung.datetime.modify;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class DateIncrementerUnitTest {
+    private final static String DATE_TO_INCREMENT = "2018-07-03";
+    private final static String EXPECTED_DATE = "2018-07-04";
+
+    @Test
+    public void givenDate_whenUsingJava8_thenAddOneDay() throws Exception {
+        String incrementedDate = DateIncrementer.addOneDay(DATE_TO_INCREMENT);
+        assertEquals(EXPECTED_DATE, incrementedDate);
+    }
+
+    @Test
+    public void givenDate_whenUsingJodaTime_thenAddOneDay() throws Exception {
+        String incrementedDate = DateIncrementer.addOneDayJodaTime(DATE_TO_INCREMENT);
+        assertEquals(EXPECTED_DATE, incrementedDate);
+    }
+
+    @Test
+    public void givenDate_whenUsingCalendar_thenAddOneDay() throws Exception {
+        String incrementedDate = DateIncrementer.addOneDayCalendar(DATE_TO_INCREMENT);
+        assertEquals(EXPECTED_DATE, incrementedDate);
+    }
+
+    @Test
+    public void givenDate_whenUsingApacheCommons_thenAddOneDay() throws Exception {
+        String incrementedDate = DateIncrementer.addOneDayApacheCommons(DATE_TO_INCREMENT);
+        assertEquals(EXPECTED_DATE, incrementedDate);
+    }
+}

java-dates/src/test/java/com/baeldung/dst/DaylightSavingTimeExamplesUnitTest.java

@@ -0,0 +1,69 @@
+package com.baeldung.dst;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.text.DateFormat;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.Locale;
+import java.util.TimeZone;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+public class DaylightSavingTimeExamplesUnitTest {
+
+    @Test
+    public void givenItalianTimeZone_WhenDSTHappens_ThenCorrectlyShiftTimeZone() throws ParseException {        
+        TimeZone.setDefault(TimeZone.getTimeZone("Europe/Rome"));
+        
+        TimeZone tz = TimeZone.getTimeZone("Europe/Rome");
+        Calendar cal = Calendar.getInstance(tz, Locale.ITALIAN);
+        DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm", Locale.ITALIAN);
+        Date dateBeforeDST = df.parse("2018-03-25 01:55");
+        prettyPrint(cal.getTimeZone());
+
+        cal.setTime(dateBeforeDST);
+        System.out.println("Before DST (00:55 UTC - 01:55 GMT+1) = " + dateBeforeDST);
+
+        System.out.println("With this Calendar " + (cal.get(Calendar.ZONE_OFFSET) + cal.get(Calendar.DST_OFFSET)) / (60 * 1000) + " minutes must be added to UTC (GMT TimeZone) to get a correct date for this TimeZone\n");
+        assertThat(cal.get(Calendar.ZONE_OFFSET)).isEqualTo(3600000);
+        assertThat(cal.get(Calendar.DST_OFFSET)).isEqualTo(0);
+
+        cal.add(Calendar.MINUTE, 10);
+
+        Date dateAfterDST = cal.getTime();
+
+        System.out.println(" After DST (01:05 UTC - 03:05 GMT+2) = " + dateAfterDST);
+        System.out.println("With this Calendar " + (cal.get(Calendar.ZONE_OFFSET) + cal.get(Calendar.DST_OFFSET)) / (60 * 1000) + " minutes must be added to UTC (GMT TimeZone) to get a correct date for this TimeZone\n");
+        assertThat(cal.get(Calendar.DST_OFFSET)).isEqualTo(3600000);
+        assertThat(dateAfterDST).isEqualTo(df.parse("2018-03-25 03:05"));
+
+        Long deltaBetweenDatesInMillis = dateAfterDST.getTime() - dateBeforeDST.getTime();
+        Long tenMinutesInMillis = (1000L * 60 * 10);
+        assertThat(deltaBetweenDatesInMillis).isEqualTo(tenMinutesInMillis);
+    }
+
+    private void prettyPrint(TimeZone tz) {
+
+        //@formatter:off
+        System.out.println(String.format(
+               "    Zone ID = %s (%s)\n"  
+             + "  RawOffset = %s minutes\n"
+             + "        DST = %s minutes\n"
+             + "  -----------------------------------------",
+             tz.getID(), tz.getDisplayName(), tz.getRawOffset()/60000, tz.getDSTSavings()/60000));
+        //@formatter:on
+    }
+
+    @Test
+    @Ignore
+    public void whenIterating_ThenPrintAllTimeZones() {
+        for (String id : TimeZone.getAvailableIDs()) {
+            TimeZone tz = TimeZone.getTimeZone(id);
+            prettyPrint(tz);
+        }
+    }
+}

java-dates/src/test/java/com/baeldung/dst/DaylightSavingTimeJavaTimeExamplesUnitTest.java

@@ -0,0 +1,56 @@
+package com.baeldung.dst;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.text.ParseException;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+import java.time.temporal.ChronoUnit;
+import java.util.TimeZone;
+
+import org.junit.Test;
+
+public class DaylightSavingTimeJavaTimeExamplesUnitTest {
+
+    @Test
+    public void givenItalianTimeZone_WhenDSTHappens_ThenCorrectlyShiftTimeZone() throws ParseException {
+        ZoneId italianZoneId = ZoneId.of("Europe/Rome");
+
+        LocalDateTime localDateTimeBeforeDST = LocalDateTime.of(2018, 3, 25, 1, 55);
+        System.out.println(localDateTimeBeforeDST);
+        assertThat(localDateTimeBeforeDST.toString()).isEqualTo("2018-03-25T01:55");
+
+        ZonedDateTime zonedDateTimeBeforeDST = localDateTimeBeforeDST.atZone(italianZoneId);
+        prettyPrint(zonedDateTimeBeforeDST);
+        assertThat(zonedDateTimeBeforeDST.toString()).isEqualTo("2018-03-25T01:55+01:00[Europe/Rome]");
+
+        ZonedDateTime zonedDateTimeAfterDST = zonedDateTimeBeforeDST.plus(10, ChronoUnit.MINUTES);
+        prettyPrint(zonedDateTimeAfterDST);
+        assertThat(zonedDateTimeAfterDST.toString()).isEqualTo("2018-03-25T03:05+02:00[Europe/Rome]");
+
+        Long deltaBetweenDatesInMinutes = ChronoUnit.MINUTES.between(zonedDateTimeBeforeDST, zonedDateTimeAfterDST);
+        assertThat(deltaBetweenDatesInMinutes).isEqualTo(10);
+
+    }
+
+    private void prettyPrint(ZonedDateTime zdt) {
+        //@formatter:off
+        System.out.println(String.format(
+              " ZonedDateTime = %s\n"  
+            + "       Zone ID = %s (%s)\n"  
+            + "     RawOffset = %s minutes\n"
+            + "  -----------------------------------------",
+            zdt, zdt.getZone(), zdt.getZone().getId(), zdt.getOffset().getTotalSeconds()/60));
+        //@formatter:on
+    }
+
+    @Test
+    public void whenCounting_ThenPrintDifferencesBetweenAPIs() {
+        System.out.println("Total java.time.ZoneId      count : " + ZoneId.getAvailableZoneIds()
+            .size());
+        System.out.println("Total java.util.TimeZone Id count : " + TimeZone.getAvailableIDs().length);
+    }
+
+    
+}

java-dates/src/test/java/com/baeldung/gregorian/calendar/GregorianCalendarTester.java

@@ -0,0 +1,228 @@
+package com.baeldung.gregorian.calendar;
+
+import static org.junit.Assert.*;
+
+import java.time.format.DateTimeFormatter;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.GregorianCalendar;
+import java.util.Locale;
+import java.util.TimeZone;
+
+import javax.xml.datatype.DatatypeConfigurationException;
+import javax.xml.datatype.DatatypeFactory;
+import javax.xml.datatype.XMLGregorianCalendar;
+
+import org.junit.Test;
+
+import com.baeldung.gregorian.calendar.GregorianCalendarExample;
+
+public class GregorianCalendarTester {
+
+    @Test
+    public void test_Calendar_Return_Type_Valid() {
+        Calendar calendar = Calendar.getInstance();
+        assert ("gregory".equals(calendar.getCalendarType()));
+    }
+
+    @Test
+    public void test_Calendar_Return_Type_InValid() {
+        Calendar calendar = Calendar.getInstance();
+        assertNotEquals("gregorys", calendar.getCalendarType());
+    }
+
+    @Test(expected = ClassCastException.class)
+    public void test_Class_Cast_Exception() {
+        TimeZone tz = TimeZone.getTimeZone("GMT+9:00");
+        Locale loc = new Locale("ja", "JP", "JP");
+        Calendar calendar = Calendar.getInstance(loc);
+        GregorianCalendar gc = (GregorianCalendar) calendar;
+    }
+
+    @Test
+    public void test_Getting_Calendar_information() {
+        GregorianCalendar calendar = new GregorianCalendar(2018, 5, 28);
+        assertTrue(false == calendar.isLeapYear(calendar.YEAR));
+        assertTrue(52 == calendar.getWeeksInWeekYear());
+        assertTrue(2018 == calendar.getWeekYear());
+        assertTrue(30 == calendar.getActualMaximum(calendar.DAY_OF_MONTH));
+        assertTrue(1 == calendar.getActualMinimum(calendar.DAY_OF_MONTH));
+        assertTrue(1 == calendar.getGreatestMinimum(calendar.DAY_OF_MONTH));
+        assertTrue(28 == calendar.getLeastMaximum(calendar.DAY_OF_MONTH));
+        assertTrue(31 == calendar.getMaximum(calendar.DAY_OF_MONTH));
+        assertTrue(1 == calendar.getMinimum(calendar.DAY_OF_MONTH));
+        assertTrue(52 == calendar.getWeeksInWeekYear());
+    }
+
+    @Test
+    public void test_Compare_Date_FirstDate_Greater_SecondDate() {
+        GregorianCalendar firstDate = new GregorianCalendar(2018, 6, 28);
+        GregorianCalendar secondDate = new GregorianCalendar(2018, 5, 28);
+        assertTrue(1 == firstDate.compareTo(secondDate));
+    }
+
+
+    @Test
+    public void test_Compare_Date_FirstDate_Smaller_SecondDate() {
+        GregorianCalendar firstDate = new GregorianCalendar(2018, 5, 28);
+        GregorianCalendar secondDate = new GregorianCalendar(2018, 6, 28);
+        assertTrue(-1 == firstDate.compareTo(secondDate));
+    }
+
+    @Test
+    public void test_Compare_Date_Both_Dates_Equal() {
+        GregorianCalendar firstDate = new GregorianCalendar(2018, 6, 28);
+        GregorianCalendar secondDate = new GregorianCalendar(2018, 6, 28);
+        assertTrue(0 == firstDate.compareTo(secondDate));
+    }
+
+    @Test
+    public void test_date_format() {
+        GregorianCalendarExample calendarDemo = new GregorianCalendarExample();
+        GregorianCalendar calendar = new GregorianCalendar(2018, 6, 28);
+        assertEquals("28 Jul 2018", calendarDemo.formatDate(calendar));
+    }
+
+    @Test
+    public void test_dateFormatdMMMuuuu() {
+        String expectedDate = new GregorianCalendar(2018, 6, 28).toZonedDateTime()
+            .format(DateTimeFormatter.ofPattern("d MMM uuuu"));
+        assertEquals("28 Jul 2018", expectedDate);
+    }
+
+    @Test
+    public void test_addDays() {
+        GregorianCalendarExample calendarDemo = new GregorianCalendarExample();
+        GregorianCalendar calendarActual = new GregorianCalendar(2018, 6, 28);
+        GregorianCalendar calendarExpected = new GregorianCalendar(2018, 6, 28);
+        calendarExpected.add(Calendar.DATE, 1);
+        Date expectedDate = calendarExpected.getTime();
+        assertEquals(expectedDate, calendarDemo.addDays(calendarActual, 1));
+    }
+
+    @Test
+    public void test_whenAddOneDay_thenMonthIsChanged() {
+        final int finalDay1 = 1;
+        final int finalMonthJul = 6; 
+        GregorianCalendar calendarExpected = new GregorianCalendar(2018, 5, 30);
+        calendarExpected.add(Calendar.DATE, 1);
+        System.out.println(calendarExpected.getTime());
+        assertEquals(calendarExpected.get(Calendar.DATE), finalDay1);
+        assertEquals(calendarExpected.get(Calendar.MONTH), finalMonthJul);
+    }
+
+    @Test
+    public void test_whenSubtractOneDay_thenMonthIsChanged() {
+        final int finalDay31 = 31;
+        final int finalMonthMay = 4; 
+        GregorianCalendar calendarExpected = new GregorianCalendar(2018, 5, 1);
+        calendarExpected.add(Calendar.DATE, -1);
+        assertEquals(calendarExpected.get(Calendar.DATE), finalDay31);
+        assertEquals(calendarExpected.get(Calendar.MONTH), finalMonthMay);
+    }
+
+    @Test
+    public void test_subDays() {
+        GregorianCalendarExample calendarDemo = new GregorianCalendarExample();
+        GregorianCalendar calendarActual = new GregorianCalendar(2018, 6, 28);
+        GregorianCalendar calendarExpected = new GregorianCalendar(2018, 6, 28);
+        calendarExpected.add(Calendar.DATE, -1);
+        Date expectedDate = calendarExpected.getTime();
+        assertEquals(expectedDate, calendarDemo.subtractDays(calendarActual, 1));
+    }
+
+    @Test
+    public void test_rollAdd() {
+        GregorianCalendarExample calendarDemo = new GregorianCalendarExample();
+        GregorianCalendar calendarActual = new GregorianCalendar(2018, 6, 28);
+        GregorianCalendar calendarExpected = new GregorianCalendar(2018, 6, 28);
+        calendarExpected.roll(Calendar.MONTH, 8);
+        Date expectedDate = calendarExpected.getTime();
+        assertEquals(expectedDate, calendarDemo.rollAdd(calendarActual, 8));
+    }
+
+    @Test
+    public void test_whenRollUpOneMonth_thenYearIsUnchanged() {
+        final int rolledUpMonthJuly = 7, orginalYear2018 = 2018;
+        GregorianCalendar calendarExpected = new GregorianCalendar(2018, 6, 28);
+        calendarExpected.roll(Calendar.MONTH, 1);
+        assertEquals(calendarExpected.get(Calendar.MONTH), rolledUpMonthJuly);
+        assertEquals(calendarExpected.get(Calendar.YEAR), orginalYear2018);
+    }
+
+    @Test
+    public void test_whenRollDownOneMonth_thenYearIsUnchanged() {
+        final int rolledDownMonthJune = 5, orginalYear2018 = 2018;
+        GregorianCalendar calendarExpected = new GregorianCalendar(2018, 6, 28);
+        calendarExpected.roll(Calendar.MONTH, -1);
+        assertEquals(calendarExpected.get(Calendar.MONTH), rolledDownMonthJune);
+        assertEquals(calendarExpected.get(Calendar.YEAR), orginalYear2018);
+    }
+
+    @Test
+    public void test_rollSubtract() {
+        GregorianCalendarExample calendarDemo = new GregorianCalendarExample();
+        GregorianCalendar calendarActual = new GregorianCalendar(2018, 6, 28);
+        GregorianCalendar calendarExpected = new GregorianCalendar(2018, 6, 28);
+        calendarExpected.roll(Calendar.MONTH, -8);
+        Date expectedDate = calendarExpected.getTime();
+        assertEquals(expectedDate, calendarDemo.rollAdd(calendarActual, -8));
+    }
+
+    @Test
+    public void test_setMonth() {
+        GregorianCalendarExample calendarDemo = new GregorianCalendarExample();
+        GregorianCalendar calendarActual = new GregorianCalendar(2018, 6, 28);
+        GregorianCalendar calendarExpected = new GregorianCalendar(2018, 6, 28);
+        calendarExpected.set(Calendar.MONTH, 3);
+        Date expectedDate = calendarExpected.getTime();
+        assertEquals(expectedDate, calendarDemo.setMonth(calendarActual, 3));
+    }
+
+    @Test
+    public void test_setMonthApril() {
+        final int setMonthApril = 3, orginalYear2018 = 2018, originalDate28 = 28;
+        GregorianCalendar calendarExpected = new GregorianCalendar(2018, 6, 28);
+        calendarExpected.set(Calendar.MONTH, 3);
+        assertEquals(calendarExpected.get(Calendar.MONTH), setMonthApril);
+        assertEquals(calendarExpected.get(Calendar.YEAR), orginalYear2018);
+        assertEquals(calendarExpected.get(Calendar.DATE), originalDate28);
+    }
+
+    @Test
+    public void test_toXMLGregorianCalendar() throws DatatypeConfigurationException {
+        GregorianCalendarExample calendarDemo = new GregorianCalendarExample();
+        DatatypeFactory datatypeFactory = DatatypeFactory.newInstance();
+        GregorianCalendar calendarActual = new GregorianCalendar(2018, 6, 28);
+        GregorianCalendar calendarExpected = new GregorianCalendar(2018, 6, 28);
+        XMLGregorianCalendar expectedXMLGregorianCalendar = datatypeFactory
+            .newXMLGregorianCalendar(calendarExpected);
+        assertEquals(expectedXMLGregorianCalendar, 
+            calendarDemo.toXMLGregorianCalendar(calendarActual));
+    }
+
+    @Test
+    public void test_isLeapYear_True() {
+        GregorianCalendarExample calendarDemo = new GregorianCalendarExample();
+        assertEquals(true, calendarDemo.isLeapYearExample(2016));
+
+    }
+
+    @Test
+    public void test_isLeapYear_False() {
+        GregorianCalendarExample calendarDemo = new GregorianCalendarExample();
+        assertEquals(false, calendarDemo.isLeapYearExample(2018));
+
+    }
+    
+    @Test
+    public void test_toDate() throws DatatypeConfigurationException {
+        GregorianCalendar calendarActual = new GregorianCalendar(2018, 6, 28);
+        DatatypeFactory datatypeFactory = DatatypeFactory.newInstance();
+        XMLGregorianCalendar expectedXMLGregorianCalendar = datatypeFactory
+            .newXMLGregorianCalendar(calendarActual);
+        expectedXMLGregorianCalendar.toGregorianCalendar().getTime();
+        assertEquals(calendarActual.getTime(), 
+            expectedXMLGregorianCalendar.toGregorianCalendar().getTime() );
+    }
+}

java-dates/src/test/java/com/baeldung/java9/time/TimeApiUnitTest.java

@@ -0,0 +1,58 @@
+package com.baeldung.java9.time;
+
+import java.time.LocalDate;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+import org.junit.Test;
+
+public class TimeApiUnitTest {
+
+    @Test
+    public void givenGetDatesBetweenWithUsingJava7_WhenStartEndDate_thenDatesList() {
+        Date startDate = Calendar.getInstance().getTime();
+        Calendar endCalendar = Calendar.getInstance();
+        endCalendar.add(Calendar.DATE, 2);
+        Date endDate = endCalendar.getTime();
+
+        List<Date> dates = TimeApi.getDatesBetweenUsingJava7(startDate, endDate);
+        assertEquals(dates.size(), 2);
+
+        Calendar calendar = Calendar.getInstance();
+        Date date1 = calendar.getTime();
+        assertEquals(dates.get(0).getDay(), date1.getDay());
+        assertEquals(dates.get(0).getMonth(), date1.getMonth());
+        assertEquals(dates.get(0).getYear(), date1.getYear());
+
+        calendar.add(Calendar.DATE, 1);
+        Date date2 = calendar.getTime();
+        assertEquals(dates.get(1).getDay(), date2.getDay());
+        assertEquals(dates.get(1).getMonth(), date2.getMonth());
+        assertEquals(dates.get(1).getYear(), date2.getYear());
+    }
+
+    @Test
+    public void givenGetDatesBetweenWithUsingJava8_WhenStartEndDate_thenDatesList() {
+        LocalDate startDate = LocalDate.now();
+        LocalDate endDate = LocalDate.now().plusDays(2);
+
+        List<LocalDate> dates = TimeApi.getDatesBetweenUsingJava8(startDate, endDate);
+        assertEquals(dates.size(), 2);
+        assertEquals(dates.get(0), LocalDate.now());
+        assertEquals(dates.get(1), LocalDate.now().plusDays(1));
+    }
+
+    @Test
+    public void givenGetDatesBetweenWithUsingJava9_WhenStartEndDate_thenDatesList() {
+        LocalDate startDate = LocalDate.now();
+        LocalDate endDate = LocalDate.now().plusDays(2);
+
+        List<LocalDate> dates = TimeApi.getDatesBetweenUsingJava9(startDate, endDate);
+        assertEquals(dates.size(), 2);
+        assertEquals(dates.get(0), LocalDate.now());
+        assertEquals(dates.get(1), LocalDate.now().plusDays(1));
+    }
+
+}

java-dates/src/test/java/com/baeldung/jodatime/JodaTimeUnitTest.java

@@ -0,0 +1,186 @@
+package com.baeldung.jodatime;
+
+import org.joda.time.*;
+import org.joda.time.format.DateTimeFormat;
+import org.joda.time.format.DateTimeFormatter;
+import org.junit.Test;
+
+import java.util.Date;
+import java.util.TimeZone;
+
+import static org.junit.Assert.*;
+
+public class JodaTimeUnitTest {
+
+    @Test
+    public void testDateTimeRepresentation() {
+
+        DateTimeZone.setDefault(DateTimeZone.forID("Europe/Bucharest"));
+
+        // representing current date and time
+        LocalDate currentDate = LocalDate.now();
+        LocalTime currentTime = LocalTime.now();
+        LocalDateTime currentLocalDateTime = LocalDateTime.now();
+
+        LocalDateTime currentDateTimeFromJavaDate = new LocalDateTime(new Date());
+        Date currentJavaDate = currentDateTimeFromJavaDate.toDate();
+
+        // representing custom date and time
+        Date oneMinuteAgoDate = new Date(System.currentTimeMillis() - (60 * 1000));
+        Instant oneMinutesAgoInstant = new Instant(oneMinuteAgoDate);
+
+        DateTime customDateTimeFromInstant = new DateTime(oneMinutesAgoInstant);
+        DateTime customDateTimeFromJavaDate = new DateTime(oneMinuteAgoDate);
+        DateTime customDateTimeFromString = new DateTime("2018-05-05T10:11:12.123");
+        DateTime customDateTimeFromParts = new DateTime(2018, 5, 5, 10, 11, 12, 123);
+
+        // parsing
+        DateTime parsedDateTime = DateTime.parse("2018-05-05T10:11:12.123");
+        assertEquals("2018-05-05T10:11:12.123+03:00", parsedDateTime.toString());
+
+        DateTimeFormatter dateTimeFormatter = DateTimeFormat.forPattern("MM/dd/yyyy HH:mm:ss");
+        DateTime parsedDateTimeUsingFormatter = DateTime.parse("05/05/2018 10:11:12", dateTimeFormatter);
+        assertEquals("2018-05-05T10:11:12.000+03:00", parsedDateTimeUsingFormatter.toString());
+
+        // Instant
+        Instant instant = new Instant();
+        Instant.now();
+
+        Instant instantFromString = new Instant("2018-05-05T10:11:12");
+        Instant instantFromDate = new Instant(oneMinuteAgoDate);
+        Instant instantFromTimestamp = new Instant(System.currentTimeMillis() - (60 * 1000));
+        Instant parsedInstant = Instant.parse("05/05/2018 10:11:12", dateTimeFormatter);
+
+        Instant instantNow = Instant.now();
+        Instant oneMinuteAgoInstant = new Instant(oneMinuteAgoDate);
+
+        // epochMilli and epochSecond
+        long milliesFromEpochTime = System.currentTimeMillis();
+        long secondsFromEpochTime = milliesFromEpochTime / 1000;
+        Instant instantFromEpochMilli = Instant.ofEpochMilli(milliesFromEpochTime);
+        Instant instantFromEpocSeconds = Instant.ofEpochSecond(secondsFromEpochTime);
+
+        // convert Instants
+        DateTime dateTimeFromInstant = instant.toDateTime();
+        Date javaDateFromInstant = instant.toDate();
+
+        int year = instant.get(DateTimeFieldType.year());
+        int month = instant.get(DateTimeFieldType.monthOfYear());
+        int day = instant.get(DateTimeFieldType.dayOfMonth());
+        int hour = instant.get(DateTimeFieldType.hourOfDay());
+
+        // Duration, Period, Instant
+        long currentTimestamp = System.currentTimeMillis();
+        long oneHourAgo = currentTimestamp - 24*60*1000;
+
+        Duration duration = new Duration(oneHourAgo, currentTimestamp);
+        Instant.now().plus(duration);
+
+        long durationInDays = duration.getStandardDays();
+        long durationInHours = duration.getStandardHours();
+        long durationInMinutes = duration.getStandardMinutes();
+        long durationInSeconds = duration.getStandardSeconds();
+        long durationInMilli = duration.getMillis();
+
+        // converting between classes
+        DateTimeUtils.setCurrentMillisFixed(currentTimestamp);
+        LocalDateTime currentDateAndTime  = LocalDateTime.now();
+
+        assertEquals(new DateTime(currentTimestamp), currentDateAndTime.toDateTime());
+        assertEquals(new LocalDate(currentTimestamp), currentDateAndTime.toLocalDate());
+        assertEquals(new LocalTime(currentTimestamp), currentDateAndTime.toLocalTime());
+    }
+
+    @Test
+    public void testJodaInstant() {
+
+        Date oneMinuteAgoDate = new Date(System.currentTimeMillis() - (60 * 1000));
+
+        Instant instantNow = Instant.now();
+        Instant oneMinuteAgoInstant = new Instant(oneMinuteAgoDate);
+
+        assertTrue(instantNow.compareTo(oneMinuteAgoInstant) > 0);
+        assertTrue(instantNow.isAfter(oneMinuteAgoInstant));
+        assertTrue(oneMinuteAgoInstant.isBefore(instantNow));
+        assertTrue(oneMinuteAgoInstant.isBeforeNow());
+        assertFalse(oneMinuteAgoInstant.isEqual(instantNow));
+
+        LocalDateTime localDateTime = new LocalDateTime("2018-02-01");
+        Period period = new Period().withMonths(1);
+        LocalDateTime datePlusPeriod = localDateTime.plus(period);
+
+        Instant startInterval1 = new Instant("2018-05-05T09:00:00.000");
+        Instant endInterval1 = new Instant("2018-05-05T11:00:00.000");
+        Interval interval1 = new Interval(startInterval1, endInterval1);
+
+        Instant startInterval2 = new Instant("2018-05-05T10:00:00.000");
+        Instant endInterval2 = new Instant("2018-05-05T11:00:00.000");
+        Interval interval2 = new Interval(startInterval2, endInterval2);
+
+        Instant startInterval3 = new Instant("2018-05-05T11:00:00.000");
+        Instant endInterval3 = new Instant("2018-05-05T13:00:00.000");
+        Interval interval3 = new Interval(startInterval3, endInterval3);
+
+        Interval overlappingInterval = interval1.overlap(interval2);
+        Interval notOverlappingInterval = interval1.overlap(interval3);
+
+        assertTrue(overlappingInterval.isEqual(new Interval(new Instant("2018-05-05T10:00:00.000"), new Instant("2018-05-05T11:00:00.000"))));
+        assertNotNull(overlappingInterval);
+
+        interval1.abuts(interval3);
+        assertTrue(interval1.abuts(new Interval(new Instant("2018-05-05T11:00:00.000"), new Instant("2018-05-05T13:00:00.000"))));
+
+        interval1.gap(interval2);
+    }
+
+
+    @Test
+    public void testDateTimeOperations() {
+
+        DateTimeUtils.setCurrentMillisFixed(1529612783288L);
+        DateTimeZone.setDefault(DateTimeZone.UTC);
+
+        LocalDateTime currentLocalDateTime = LocalDateTime.now();
+        assertEquals("2018-06-21T20:26:23.288", currentLocalDateTime.toString());
+
+        LocalDateTime nextDayDateTime = currentLocalDateTime.plusDays(1);
+        assertEquals("2018-06-22T20:26:23.288", nextDayDateTime.toString());
+
+        Period oneMonth = new Period().withMonths(1);
+        LocalDateTime nextMonthDateTime = currentLocalDateTime.plus(oneMonth);
+        assertEquals("2018-07-21T20:26:23.288", nextMonthDateTime.toString());
+
+        LocalDateTime previousDayLocalDateTime = currentLocalDateTime.minusDays(1);
+        assertEquals("2018-06-20T20:26:23.288", previousDayLocalDateTime.toString());
+
+        LocalDateTime currentDateAtHour10 = currentLocalDateTime
+                .withHourOfDay(0)
+                .withMinuteOfHour(0)
+                .withSecondOfMinute(0)
+                .withMillisOfSecond(0);
+        assertEquals("2018-06-21T00:00:00.000", currentDateAtHour10.toString());
+    }
+
+    @Test
+    public void testTimezones() {
+
+        System.getProperty("user.timezone");
+        DateTimeZone.getAvailableIDs();
+        // DateTimeZone.setDefault(DateTimeZone.forID("Europe/Bucharest"));
+
+        DateTimeUtils.setCurrentMillisFixed(1529612783288L);
+
+        DateTime dateTimeInChicago = new DateTime(DateTimeZone.forID("America/Chicago"));
+        assertEquals("2018-06-21T15:26:23.288-05:00", dateTimeInChicago.toString());
+
+        DateTime dateTimeInBucharest = new DateTime(DateTimeZone.forID("Europe/Bucharest"));
+        assertEquals("2018-06-21T23:26:23.288+03:00", dateTimeInBucharest.toString());
+
+        LocalDateTime localDateTimeInChicago = new LocalDateTime(DateTimeZone.forID("America/Chicago"));
+        assertEquals("2018-06-21T15:26:23.288", localDateTimeInChicago.toString());
+
+        DateTime convertedDateTime = localDateTimeInChicago.toDateTime(DateTimeZone.forID("Europe/Bucharest"));
+        assertEquals("2018-06-21T15:26:23.288+03:00", convertedDateTime.toString());
+    }
+
+}

java-dates/src/test/java/com/baeldung/temporaladjusters/CustomTemporalAdjusterUnitTest.java

@@ -0,0 +1,43 @@
+package com.baeldung.temporaladjusters;
+
+import com.baeldung.temporaladjuster.CustomTemporalAdjuster;
+import org.junit.Test;
+
+import java.time.LocalDate;
+import java.time.Period;
+import java.time.temporal.TemporalAdjuster;
+
+import static org.junit.Assert.assertEquals;
+
+public class CustomTemporalAdjusterUnitTest {
+
+    private static final TemporalAdjuster NEXT_WORKING_DAY = new CustomTemporalAdjuster();
+
+    @Test
+    public void whenAdjustAndImplementInterface_thenNextWorkingDay() {
+        LocalDate localDate = LocalDate.of(2017, 07, 8);
+        CustomTemporalAdjuster temporalAdjuster = new CustomTemporalAdjuster();
+        LocalDate nextWorkingDay = localDate.with(temporalAdjuster);
+
+        assertEquals("2017-07-10", nextWorkingDay.toString());
+    }
+
+    @Test
+    public void whenAdjust_thenNextWorkingDay() {
+        LocalDate localDate = LocalDate.of(2017, 07, 8);
+        LocalDate date = localDate.with(NEXT_WORKING_DAY);
+
+        assertEquals("2017-07-10", date.toString());
+    }
+
+    @Test
+    public void whenAdjust_thenFourteenDaysAfterDate() {
+        LocalDate localDate = LocalDate.of(2017, 07, 8);
+        TemporalAdjuster temporalAdjuster = (t) -> t.plus(Period.ofDays(14));
+        LocalDate result = localDate.with(temporalAdjuster);
+
+        String fourteenDaysAfterDate = "2017-07-22";
+
+        assertEquals(fourteenDaysAfterDate, result.toString());
+    }
+}

java-dates/src/test/java/com/baeldung/temporaladjusters/TemporalAdjustersUnitTest.java

@@ -0,0 +1,22 @@
+package com.baeldung.temporaladjusters;
+
+import java.time.DayOfWeek;
+import java.time.LocalDate;
+import java.time.temporal.TemporalAdjusters;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TemporalAdjustersUnitTest {
+
+    @Test
+    public void whenAdjust_thenNextSunday() {
+        LocalDate localDate = LocalDate.of(2017, 07, 8);
+        LocalDate nextSunday = localDate.with(TemporalAdjusters.next(DayOfWeek.SUNDAY));
+
+        String expected = "2017-07-09";
+
+        Assert.assertEquals(expected, nextSunday.toString());
+    }
+
+}

java-dates/src/test/java/com/baeldung/time/ElapsedTimeUnitTest.java

@@ -0,0 +1,76 @@
+package com.baeldung.time;
+
+import static org.junit.Assert.assertEquals;
+
+import java.time.Duration;
+import java.time.Instant;
+import java.util.concurrent.TimeUnit;
+
+import org.apache.commons.lang3.time.StopWatch;
+import org.junit.Test;
+
+public class ElapsedTimeUnitTest {
+
+    @Test
+    public void givenRunningTask_whenMeasuringTimeWithCurrentTimeMillis_thenGetElapsedTime() throws InterruptedException {
+        long start = System.currentTimeMillis();
+        
+        simulateRunningTask();
+        
+        long finish = System.currentTimeMillis();
+        
+        long timeElapsed = finish - start;
+        
+        assertEquals(true, (2000L <= timeElapsed) && (timeElapsed <= 3000L));
+    }
+    
+    @Test
+    public void giveRunningTask_whenMeasuringTimeWithNanoTime_thenGetElapsedTime() throws InterruptedException {
+        long start = System.nanoTime();
+        
+        simulateRunningTask();
+        
+        long finish = System.nanoTime();
+        
+        long timeElapsed = finish - start;
+        
+        assertEquals(true, (2000000000L <= timeElapsed) && (timeElapsed <= 3000000000L));
+    }
+    
+    @Test
+    public void givenRunningTask_whenMeasuringTimeWithStopWatch_thenGetElapsedTime() throws InterruptedException {
+        StopWatch watch = new StopWatch();        
+        watch.start();
+
+        simulateRunningTask();
+        
+        watch.stop();
+        
+        long timeElapsed = watch.getTime();
+        
+        assertEquals(true, (2000L <= timeElapsed) && (timeElapsed <= 3000L));
+    }
+    
+    @Test
+    public void givenRunningTask_whenMeasuringTimeWithInstantClass_thenGetElapsedTime() throws InterruptedException {
+        Instant start = Instant.now();
+        
+        simulateRunningTask();
+        
+        Instant finish = Instant.now();
+        
+        long timeElapsed = Duration.between(start, finish).toMillis();
+        
+        assertEquals(true, (2000L <= timeElapsed) && (timeElapsed <= 3000L));
+    }
+    
+    /**
+     * Simulate task running for 2.5 seconds.
+     * 
+     * @throws InterruptedException
+     */
+    private static void simulateRunningTask() throws InterruptedException {
+        TimeUnit.MILLISECONDS.sleep(2500); // 2.5 seconds
+
+    } 
+}