[BAEL-8456] - Moved Java Date articles into a new module - 'java-dates'

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/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");
+    }
+}