Fix Format

java-dates-2/src/main/java/com/baeldung/date/comparison/DateTimeComparisonUtils.java

@@ -0,0 +1,35 @@
+package com.baeldung.date.comparison;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+
+import static java.time.temporal.ChronoUnit.*;
+
+public class DateTimeComparisonUtils {
+
+    public static boolean isSameDay(LocalDateTime timestamp, LocalDate localDateToCompare) {
+        return timestamp.toLocalDate().isEqual(localDateToCompare);
+    }
+
+    public static boolean isSameDay(LocalDateTime timestamp, LocalDateTime timestampToCompare) {
+        return timestamp.truncatedTo(DAYS).isEqual(timestampToCompare.truncatedTo(DAYS));
+    }
+
+    public static boolean isSameHour(LocalDateTime timestamp, LocalDateTime timestampToCompare) {
+        return timestamp.truncatedTo(HOURS).isEqual(timestampToCompare.truncatedTo(HOURS));
+    }
+
+    public static boolean isSameMinute(LocalDateTime timestamp, LocalDateTime timestampToCompare) {
+        return timestamp.truncatedTo(MINUTES).isEqual(timestampToCompare.truncatedTo(MINUTES));
+    }
+
+    public static boolean isSameHour(ZonedDateTime zonedTimestamp, ZonedDateTime zonedTimestampToCompare) {
+        return zonedTimestamp.truncatedTo(HOURS).isEqual(zonedTimestampToCompare.truncatedTo(HOURS));
+    }
+
+    public static boolean isSameHour(ZonedDateTime zonedDateTime, LocalDateTime localDateTime, ZoneId zoneId) {
+        return isSameHour(zonedDateTime, localDateTime.atZone(zoneId));
+    }
+}

java-dates-2/src/main/java/com/baeldung/date/comparison/LegacyDateComparisonUtils.java

@@ -0,0 +1,17 @@
+package com.baeldung.date.comparison;
+
+import org.apache.commons.lang3.time.DateUtils;
+
+import java.util.Calendar;
+import java.util.Date;
+
+public class LegacyDateComparisonUtils {
+
+    public static boolean isSameDay(Date date, Date dateToCompare) {
+        return DateUtils.isSameDay(date, dateToCompare);
+    }
+
+    public static boolean isSameHour(Date date, Date dateToCompare) {
+        return DateUtils.truncatedEquals(date, dateToCompare, Calendar.HOUR);
+    }
+}

java-dates-2/src/main/java/com/baeldung/date/validation/DateValidator.java

@@ -0,0 +1,5 @@
+package com.baeldung.date.validation;
+
+public interface DateValidator {
+   boolean isValid(String dateStr);
+}

java-dates-2/src/main/java/com/baeldung/date/validation/DateValidatorUsingApacheValidator.java

@@ -0,0 +1,11 @@
+package com.baeldung.date.validation;
+
+import org.apache.commons.validator.GenericValidator;
+
+public class DateValidatorUsingApacheValidator implements DateValidator {
+
+    @Override
+    public boolean isValid(String dateStr) {
+        return GenericValidator.isDate(dateStr, "yyyy-MM-dd", true); 
+    }
+}

java-dates-2/src/main/java/com/baeldung/date/validation/DateValidatorUsingDateFormat.java

@@ -0,0 +1,25 @@
+package com.baeldung.date.validation;
+
+import java.text.DateFormat;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+
+public class DateValidatorUsingDateFormat implements DateValidator {
+    private String dateFormat;
+
+    public DateValidatorUsingDateFormat(String dateFormat) {
+        this.dateFormat = dateFormat;
+    }
+
+    @Override
+    public boolean isValid(String dateStr) {
+        DateFormat sdf = new SimpleDateFormat(this.dateFormat);
+        sdf.setLenient(false);
+        try {
+            sdf.parse(dateStr);
+        } catch (ParseException e) {
+            return false;
+        }
+        return true;
+    }
+}

java-dates-2/src/main/java/com/baeldung/date/validation/DateValidatorUsingDateTimeFormatter.java

@@ -0,0 +1,22 @@
+package com.baeldung.date.validation;
+
+import java.time.format.DateTimeFormatter;
+import java.time.format.DateTimeParseException;
+
+public class DateValidatorUsingDateTimeFormatter implements DateValidator {
+    private DateTimeFormatter dateFormatter;
+    
+    public DateValidatorUsingDateTimeFormatter(DateTimeFormatter dateFormatter) {
+        this.dateFormatter = dateFormatter;
+    }
+
+    @Override
+    public boolean isValid(String dateStr) {
+        try {
+            this.dateFormatter.parse(dateStr);
+        } catch (DateTimeParseException e) {
+            return false;
+        }
+        return true;
+    }
+}

java-dates-2/src/main/java/com/baeldung/date/validation/DateValidatorUsingLocalDate.java

@@ -0,0 +1,23 @@
+package com.baeldung.date.validation;
+
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+import java.time.format.DateTimeParseException;
+
+public class DateValidatorUsingLocalDate implements DateValidator {
+    private DateTimeFormatter dateFormatter;
+    
+    public DateValidatorUsingLocalDate(DateTimeFormatter dateFormatter) {
+        this.dateFormatter = dateFormatter;
+    }
+
+    @Override
+    public boolean isValid(String dateStr) {
+        try {
+            LocalDate.parse(dateStr, this.dateFormatter);
+        } catch (DateTimeParseException e) {
+            return false;
+        }
+        return true;
+    }
+}

java-dates-2/src/test/java/com/baeldung/convert/ConvertDateTimeUnitTest.java

@@ -0,0 +1,59 @@
+package com.baeldung.convert;
+
+import org.joda.time.Instant;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+import java.util.Calendar;
+import java.util.Date;
+
+public class ConvertDateTimeUnitTest {
+
+    public final long millis = 1556175797428L;
+
+    @Test
+    public void givenLocalDateTime_WhenToEpochMillis_ThenMillis() {
+        ZoneId id = ZoneId.systemDefault();
+
+        LocalDateTime localDateTime =
+                LocalDateTime.ofInstant(java.time.Instant.ofEpochMilli(millis), id);
+
+        ZonedDateTime zdt = ZonedDateTime.of(localDateTime, id);
+
+        Assert.assertEquals(millis, zdt.toInstant().toEpochMilli());
+    }
+
+    @Test
+    public void givenJava8Instant_WhenGToEpochMillis_ThenMillis() {
+        java.time.Instant instant = java.time.Instant.ofEpochMilli(millis);
+        Assert.assertEquals(millis, instant.toEpochMilli());
+    }
+
+    @Test
+    public void givenDate_WhenGetTime_ThenMillis() {
+        Date date = new Date(millis);
+        Assert.assertEquals(millis, date.getTime());
+    }
+
+    @Test
+    public void givenCalendar_WhenGetTimeInMillis_ThenMillis() {
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(new Date(millis));
+        Assert.assertEquals(millis, calendar.getTimeInMillis());
+    }
+
+    @Test
+    public void givenJodaInstant_WhenGetMillis_ThenMillis() {
+        Instant jodaInstant = Instant.ofEpochMilli(millis);
+        Assert.assertEquals(millis, jodaInstant.getMillis());
+    }
+
+    @Test
+    public void givenJODADateTime_WhenGetMillis_ThenMillis() {
+        org.joda.time.DateTime jodaDateTime = new org.joda.time.DateTime(millis);
+        Assert.assertEquals(millis, jodaDateTime.getMillis());
+    }
+}

java-dates-2/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-2/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-2/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-2/src/test/java/com/baeldung/date/validation/DateValidatorUsingApacheValidatorUnitTest.java

@@ -0,0 +1,20 @@
+package com.baeldung.date.validation;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.apache.commons.validator.GenericValidator;
+import org.junit.Test;
+
+public class DateValidatorUsingApacheValidatorUnitTest {
+
+    @Test
+    public void whenValidDatePassed_ThenTrue() {
+        assertTrue(GenericValidator.isDate("2019-02-28", "yyyy-MM-dd", true));
+    }
+
+    @Test
+    public void whenInvalidDatePassed_ThenFalse() {
+        assertFalse(GenericValidator.isDate("2019-02-29", "yyyy-MM-dd", true));
+    }
+}

java-dates-2/src/test/java/com/baeldung/date/validation/DateValidatorUsingDateFormatUnitTest.java

@@ -0,0 +1,23 @@
+package com.baeldung.date.validation;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public class DateValidatorUsingDateFormatUnitTest {
+    
+    @Test
+    public void givenValidator_whenValidDatePassed_ThenTrue() {
+        DateValidator validator = new DateValidatorUsingDateFormat("MM/dd/yyyy");
+        
+        assertTrue(validator.isValid("02/28/2019"));
+    }
+    
+    @Test
+    public void givenValidator_whenInvalidDatePassed_ThenFalse() {
+        DateValidator validator = new DateValidatorUsingDateFormat("MM/dd/yyyy");
+        
+        assertFalse(validator.isValid("02/30/2019"));
+    }
+}

java-dates-2/src/test/java/com/baeldung/date/validation/DateValidatorUsingDateTimeFormatterUnitTest.java

@@ -0,0 +1,32 @@
+package com.baeldung.date.validation;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.time.format.DateTimeFormatter;
+import java.time.format.ResolverStyle;
+import java.util.Locale;
+
+import org.junit.Test;
+
+public class DateValidatorUsingDateTimeFormatterUnitTest {
+    
+    @Test
+    public void givenValidator_whenValidDatePassed_ThenTrue() {
+        DateTimeFormatter dateFormatter = DateTimeFormatter.ofPattern("uuuu-MM-dd", Locale.US)
+            .withResolverStyle(ResolverStyle.STRICT);
+        DateValidator validator = new DateValidatorUsingDateTimeFormatter(dateFormatter);
+        
+        assertTrue(validator.isValid("2019-02-28"));
+    }
+    
+    @Test
+    public void givenValidator_whenInValidDatePassed_ThenFalse() {
+        DateTimeFormatter dateFormatter = DateTimeFormatter.ofPattern("uuuu-MM-dd", Locale.US)
+            .withResolverStyle(ResolverStyle.STRICT);
+        DateValidator validator = new DateValidatorUsingDateTimeFormatter(dateFormatter);
+        
+        assertFalse(validator.isValid("2019-02-30"));
+    }
+
+}

java-dates-2/src/test/java/com/baeldung/date/validation/DateValidatorUsingLocalDateUnitTest.java

@@ -0,0 +1,27 @@
+package com.baeldung.date.validation;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.time.format.DateTimeFormatter;
+
+import org.junit.Test;
+
+public class DateValidatorUsingLocalDateUnitTest {
+    
+    @Test
+    public void givenValidator_whenValidDatePassed_ThenTrue() {
+        DateTimeFormatter dateFormatter = DateTimeFormatter.BASIC_ISO_DATE;
+        DateValidator validator = new DateValidatorUsingLocalDate(dateFormatter);
+        
+        assertTrue(validator.isValid("20190228"));
+    }
+    
+    @Test
+    public void givenValidator_whenInValidDatePassed_ThenFalse() {
+        DateTimeFormatter dateFormatter = DateTimeFormatter.BASIC_ISO_DATE;
+        DateValidator validator = new DateValidatorUsingLocalDate(dateFormatter);
+        
+        assertFalse(validator.isValid("20190230"));
+    }
+}

java-dates-2/src/test/java/com/baeldung/xmlgregoriancalendar/XmlGregorianCalendarConverterUnitTest.java

@@ -0,0 +1,36 @@
+package com.baeldung.xmlgregoriancalendar;
+
+import org.junit.Test;
+
+import javax.xml.datatype.DatatypeConfigurationException;
+import javax.xml.datatype.DatatypeConstants;
+import javax.xml.datatype.DatatypeFactory;
+import javax.xml.datatype.XMLGregorianCalendar;
+import java.time.LocalDate;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class XmlGregorianCalendarConverterUnitTest {
+
+    @Test
+    public void fromLocalDateToXMLGregorianCalendar() throws DatatypeConfigurationException {
+        LocalDate localDate = LocalDate.of(2017, 4, 25);
+        XMLGregorianCalendar xmlGregorianCalendar = DatatypeFactory.newInstance().newXMLGregorianCalendar(localDate.toString());
+
+        assertThat(xmlGregorianCalendar.getYear()).isEqualTo(localDate.getYear());
+        assertThat(xmlGregorianCalendar.getMonth()).isEqualTo(localDate.getMonthValue());
+        assertThat(xmlGregorianCalendar.getDay()).isEqualTo(localDate.getDayOfMonth());
+        assertThat(xmlGregorianCalendar.getTimezone()).isEqualTo(DatatypeConstants.FIELD_UNDEFINED);
+    }
+
+    @Test
+    public void fromXMLGregorianCalendarToLocalDate() throws DatatypeConfigurationException {
+        XMLGregorianCalendar xmlGregorianCalendar = DatatypeFactory.newInstance().newXMLGregorianCalendar("2017-04-25");
+        LocalDate localDate = LocalDate.of(xmlGregorianCalendar.getYear(), xmlGregorianCalendar.getMonth(), xmlGregorianCalendar.getDay());
+
+        assertThat(localDate.getYear()).isEqualTo(xmlGregorianCalendar.getYear());
+        assertThat(localDate.getMonthValue()).isEqualTo(xmlGregorianCalendar.getMonth());
+        assertThat(localDate.getDayOfMonth()).isEqualTo(xmlGregorianCalendar.getDay());
+    }
+
+}