mindol1004/spring-boot-rest
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Split the first 2 modules: java-dates-conversion and java-dates-string.

Browse Source
This commit is contained in:
Alessio Stalla
2019-09-17 19:13:21 +02:00
parent 9154f5e062
commit ed9463faa1
62 changed files with 158 additions and 48 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
java-dates/src/test/java/com/baeldung/datetime/ConvertInstantToTimestampUnitTest.java
View File

@@ -1,30 +0,0 @@
package com.baeldung.datetime;
import static org.assertj.core.api.Assertions.assertThat;
import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.time.Instant;
import java.time.ZoneId;
import java.util.TimeZone;
import org.junit.Test;
public class ConvertInstantToTimestampUnitTest {
@Test
public void givenInstant_whenConvertedToTimestamp_thenGetTimestampWithSamePointOnTimeline() {
Instant instant = Instant.now();
Timestamp timestamp = Timestamp.from(instant); // same point on the time-line as Instant
assertThat(instant.toEpochMilli()).isEqualTo(timestamp.getTime());
instant = timestamp.toInstant();
assertThat(instant.toEpochMilli()).isEqualTo(timestamp.getTime());
DateFormat df = DateFormat.getDateTimeInstance();
df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SS'Z'");
df.setTimeZone(TimeZone.getTimeZone("UTC"));
assertThat(instant.toString()).isEqualTo(df.format(timestamp).toString());
}
}

158
java-dates/src/test/java/com/baeldung/datetime/DateTimeFormatterUnitTest.java
View File

@@ -1,158 +0,0 @@
package com.baeldung.datetime;
import org.junit.Assert;
import org.junit.Test;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.time.format.FormatStyle;
import java.time.temporal.ChronoUnit;
import java.util.Locale;
import java.util.TimeZone;
public class DateTimeFormatterUnitTest {
@Test
public void givenDefaultUsLocaleAndDateTimeAndPattern_whenFormatWithDifferentLocales_thenGettingLocalizedDateTimes() {
Locale.setDefault(Locale.US);
LocalDateTime localDateTime = LocalDateTime.of(2018, 1, 1, 10, 15, 50, 500);
String pattern = "dd-MMMM-yyyy HH:mm:ss.SSS";
DateTimeFormatter defaultTimeFormatter = DateTimeFormatter.ofPattern(pattern);
DateTimeFormatter plTimeFormatter = DateTimeFormatter.ofPattern(pattern, new Locale("pl", "PL"));
DateTimeFormatter deTimeFormatter = DateTimeFormatter.ofPattern(pattern).withLocale(Locale.GERMANY);
Assert.assertEquals("01-January-2018 10:15:50.000", defaultTimeFormatter.format(localDateTime));
Assert.assertEquals("01-stycznia-2018 10:15:50.000", plTimeFormatter.format(localDateTime));
Assert.assertEquals("01-Januar-2018 10:15:50.000", deTimeFormatter.format(localDateTime));
}
@Test
public void givenDateTimeAndTimeZone_whenFormatWithDifferentLocales_thenGettingLocalizedZonedDateTimes() {
Locale.setDefault(Locale.US);
LocalDateTime localDateTime = LocalDateTime.of(2018, 1, 1, 10, 15, 50, 500);
ZoneId losAngelesTimeZone = TimeZone.getTimeZone("America/Los_Angeles").toZoneId();
DateTimeFormatter localizedFormatter = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.FULL);
DateTimeFormatter frLocalizedFormatter =
DateTimeFormatter.ofLocalizedDateTime(FormatStyle.FULL).withLocale(Locale.FRANCE);
String formattedDateTime = localizedFormatter.format(ZonedDateTime.of(localDateTime, losAngelesTimeZone));
String frFormattedDateTime = frLocalizedFormatter.format(ZonedDateTime.of(localDateTime, losAngelesTimeZone));
Assert.assertEquals("Monday, January 1, 2018 10:15:50 AM PST", formattedDateTime);
Assert.assertEquals("lundi 1 janvier 2018 10 h 15 PST", frFormattedDateTime);
}
@Test
public void shouldPrintFormattedDate() {
String europeanDatePattern = "dd.MM.yyyy";
DateTimeFormatter europeanDateFormatter = DateTimeFormatter.ofPattern(europeanDatePattern);
LocalDate summerDay = LocalDate.of(2016, 7, 31);
Assert.assertEquals("31.07.2016", europeanDateFormatter.format(summerDay));
}
@Test
public void shouldPrintFormattedTime24() {
String timeColonPattern = "HH:mm:ss";
DateTimeFormatter timeColonFormatter = DateTimeFormatter.ofPattern(timeColonPattern);
LocalTime colonTime = LocalTime.of(17, 35, 50);
Assert.assertEquals("17:35:50", timeColonFormatter.format(colonTime));
}
@Test
public void shouldPrintFormattedTimeWithMillis() {
String timeColonPattern = "HH:mm:ss SSS";
DateTimeFormatter timeColonFormatter = DateTimeFormatter.ofPattern(timeColonPattern);
LocalTime colonTime = LocalTime.of(17, 35, 50).plus(329, ChronoUnit.MILLIS);
Assert.assertEquals("17:35:50 329", timeColonFormatter.format(colonTime));
}
@Test
public void shouldPrintFormattedTimePM() {
String timeColonPattern = "hh:mm:ss a";
DateTimeFormatter timeColonFormatter = DateTimeFormatter.ofPattern(timeColonPattern);
LocalTime colonTime = LocalTime.of(17, 35, 50);
Assert.assertEquals("05:35:50 PM", timeColonFormatter.format(colonTime));
}
@Test
public void shouldPrintFormattedUTCRelatedZonedDateTime() {
String newYorkDateTimePattern = "dd.MM.yyyy HH:mm z";
DateTimeFormatter newYorkDateFormatter = DateTimeFormatter.ofPattern(newYorkDateTimePattern);
LocalDateTime summerDay = LocalDateTime.of(2016, 7, 31, 14, 15);
Assert.assertEquals("31.07.2016 14:15 UTC-04:00", newYorkDateFormatter.format(ZonedDateTime.of(summerDay, ZoneId.of("UTC-4"))));
}
@Test
public void shouldPrintFormattedNewYorkZonedDateTime() {
String newYorkDateTimePattern = "dd.MM.yyyy HH:mm z";
DateTimeFormatter newYorkDateFormatter = DateTimeFormatter.ofPattern(newYorkDateTimePattern);
LocalDateTime summerDay = LocalDateTime.of(2016, 7, 31, 14, 15);
Assert.assertEquals("31.07.2016 14:15 EDT", newYorkDateFormatter.format(ZonedDateTime.of(summerDay, ZoneId.of("America/New_York"))));
}
@Test
public void shouldPrintStyledDate() {
LocalDate anotherSummerDay = LocalDate.of(2016, 8, 23);
Assert.assertEquals("Tuesday, August 23, 2016", DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL).format(anotherSummerDay));
Assert.assertEquals("August 23, 2016", DateTimeFormatter.ofLocalizedDate(FormatStyle.LONG).format(anotherSummerDay));
Assert.assertEquals("Aug 23, 2016", DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM).format(anotherSummerDay));
Assert.assertEquals("8/23/16", DateTimeFormatter.ofLocalizedDate(FormatStyle.SHORT).format(anotherSummerDay));
}
@Test
public void shouldPrintStyledDateTime() {
LocalDateTime anotherSummerDay = LocalDateTime.of(2016, 8, 23, 13, 12, 45);
Assert.assertEquals("Tuesday, August 23, 2016 1:12:45 PM EET", DateTimeFormatter.ofLocalizedDateTime(FormatStyle.FULL).withZone(ZoneId.of("Europe/Helsinki")).format(anotherSummerDay));
Assert.assertEquals("August 23, 2016 1:12:45 PM EET", DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG).withZone(ZoneId.of("Europe/Helsinki")).format(anotherSummerDay));
Assert.assertEquals("Aug 23, 2016 1:12:45 PM", DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM).withZone(ZoneId.of("Europe/Helsinki")).format(anotherSummerDay));
Assert.assertEquals("8/23/16 1:12 PM", DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT).withZone(ZoneId.of("Europe/Helsinki")).format(anotherSummerDay));
}
@Test
public void shouldPrintFormattedDateTimeWithPredefined() {
Assert.assertEquals("2018-03-09", DateTimeFormatter.ISO_LOCAL_DATE.format(LocalDate.of(2018, 3, 9)));
Assert.assertEquals("2018-03-09-03:00", DateTimeFormatter.ISO_OFFSET_DATE.format(LocalDate.of(2018, 3, 9).atStartOfDay(ZoneId.of("UTC-3"))));
Assert.assertEquals("Fri, 9 Mar 2018 00:00:00 -0300", DateTimeFormatter.RFC_1123_DATE_TIME.format(LocalDate.of(2018, 3, 9).atStartOfDay(ZoneId.of("UTC-3"))));
}
@Test
public void shouldParseDateTime() {
Assert.assertEquals(LocalDate.of(2018, 3, 12), LocalDate.from(DateTimeFormatter.ISO_LOCAL_DATE.parse("2018-03-09")).plusDays(3));
}
@Test
public void shouldParseFormatStyleFull() {
ZonedDateTime dateTime = ZonedDateTime.from(DateTimeFormatter.ofLocalizedDateTime(FormatStyle.FULL).parse("Tuesday, August 23, 2016 1:12:45 PM EET"));
Assert.assertEquals(ZonedDateTime.of(LocalDateTime.of(2016, 8, 23, 22, 12, 45), ZoneId.of("Europe/Bucharest")), dateTime.plusHours(9));
}
@Test
public void shouldParseDateWithCustomFormatter() {
DateTimeFormatter europeanDateFormatter = DateTimeFormatter.ofPattern("dd.MM.yyyy");
Assert.assertFalse(LocalDate.from(europeanDateFormatter.parse("15.08.2014")).isLeapYear());
}
@Test
public void shouldParseTimeWithCustomFormatter() {
DateTimeFormatter timeFormatter = DateTimeFormatter.ofPattern("hh:mm:ss a");
Assert.assertTrue(LocalTime.from(timeFormatter.parse("12:25:30 AM")).isBefore(LocalTime.NOON));
}
@Test
public void shouldParseZonedDateTimeWithCustomFormatter() {
DateTimeFormatter zonedFormatter = DateTimeFormatter.ofPattern("dd.MM.yyyy HH:mm z");
Assert.assertEquals(7200, ZonedDateTime.from(zonedFormatter.parse("31.07.2016 14:15 GMT+02:00")).getOffset().getTotalSeconds());
}
@Test(expected = DateTimeParseException.class)
public void shouldExpectAnExceptionIfDateTimeStringNotMatchPattern() {
DateTimeFormatter zonedFormatter = DateTimeFormatter.ofPattern("dd.MM.yyyy HH:mm z");
ZonedDateTime.from(zonedFormatter.parse("31.07.2016 14:15"));
}
}

89
java-dates/src/test/java/com/baeldung/datetolocaldate/DateToLocalDateConverterUnitTest.java
View File

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

97
java-dates/src/test/java/com/baeldung/datetolocaldate/DateToLocalDateTimeConverterUnitTest.java
View File

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

63
java-dates/src/test/java/com/baeldung/datetolocaldate/LocalDateTimeToDateConverterUnitTest.java
View File

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

57
java-dates/src/test/java/com/baeldung/datetolocaldate/LocalDateToDateConverterUnitTest.java
View File

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

24
java-dates/src/test/java/com/baeldung/regexp/datepattern/FormattedDateMatcherUnitTest.java
View File

@@ -1,24 +0,0 @@
package com.baeldung.regexp.datepattern;
import org.junit.Assert;
import org.junit.Test;
public class FormattedDateMatcherUnitTest {
private DateMatcher matcher = new FormattedDateMatcher();
@Test
public void whenUsingFormattedDateMatcher_thenFormatConstraintsSatisfied() {
Assert.assertTrue(matcher.matches("2017-12-31"));
Assert.assertTrue(matcher.matches("2018-01-01"));
Assert.assertTrue(matcher.matches("0000-00-00"));
Assert.assertTrue(matcher.matches("1029-99-72"));
Assert.assertFalse(matcher.matches("2018-01"));
Assert.assertFalse(matcher.matches("2018-01-01-01"));
Assert.assertFalse(matcher.matches("2018-01-XX"));
Assert.assertFalse(matcher.matches(" 2018-01-01"));
Assert.assertFalse(matcher.matches("2018-01-01 "));
Assert.assertFalse(matcher.matches("2018/01/01"));
}
}

31
java-dates/src/test/java/com/baeldung/regexp/datepattern/RangedDateMatcherUnitTest.java
View File

@@ -1,31 +0,0 @@
package com.baeldung.regexp.datepattern;
import org.junit.Assert;
import org.junit.Test;
public class RangedDateMatcherUnitTest {
private DateMatcher matcher = new RangedDateMatcher();
@Test
public void whenUsingRangedDateMatcher_thenFormatConstraintsSatisfied() {
Assert.assertFalse(matcher.matches("2018-01"));
Assert.assertFalse(matcher.matches("2018-01-01-01"));
Assert.assertFalse(matcher.matches("2018-01-XX"));
Assert.assertFalse(matcher.matches(" 2018-01-01"));
Assert.assertFalse(matcher.matches("2018-01-01 "));
Assert.assertFalse(matcher.matches("2018/01/01"));
}
@Test
public void whenUsingRangedDateMatcher_thenRangeConstraintsSatisfied() {
Assert.assertTrue(matcher.matches("1900-01-01"));
Assert.assertTrue(matcher.matches("2018-02-31"));
Assert.assertTrue(matcher.matches("2999-12-31"));
Assert.assertFalse(matcher.matches("1899-12-31"));
Assert.assertFalse(matcher.matches("2018-05-35"));
Assert.assertFalse(matcher.matches("2018-13-05"));
Assert.assertFalse(matcher.matches("3000-01-01"));
}
}

17
java-dates/src/test/java/com/baeldung/regexp/datepattern/gregorian/February29thMatcherUnitTest.java
View File

@@ -1,17 +0,0 @@
package com.baeldung.regexp.datepattern.gregorian;
import com.baeldung.regexp.datepattern.DateMatcher;
import com.baeldung.regexp.datepattern.gregorian.testhelper.GregorianDateTestHelper;
import org.junit.Test;
public class February29thMatcherUnitTest {
private DateMatcher matcher = new February29thMatcher();
private GregorianDateTestHelper testHelper = new GregorianDateTestHelper(matcher);
@Test
public void whenYearIsLeap_thenYearHasFebruary29th() {
testHelper.assertFebruary29th();
}
}

17
java-dates/src/test/java/com/baeldung/regexp/datepattern/gregorian/FebruaryGeneralMatcherUnitTest.java
View File

@@ -1,17 +0,0 @@
package com.baeldung.regexp.datepattern.gregorian;
import com.baeldung.regexp.datepattern.DateMatcher;
import com.baeldung.regexp.datepattern.gregorian.testhelper.GregorianDateTestHelper;
import org.junit.Test;
public class FebruaryGeneralMatcherUnitTest {
private DateMatcher matcher = new FebruaryGeneralMatcher();
private GregorianDateTestHelper testHelper = new GregorianDateTestHelper(matcher);
@Test
public void whenMonthIsFebruary_thenMonthContainsUpTo28Days() {
testHelper.assertFebruaryGeneralDates();
}
}

42
java-dates/src/test/java/com/baeldung/regexp/datepattern/gregorian/GregorianDateMatcherUnitTest.java
View File

@@ -1,42 +0,0 @@
package com.baeldung.regexp.datepattern.gregorian;
import com.baeldung.regexp.datepattern.DateMatcher;
import com.baeldung.regexp.datepattern.gregorian.testhelper.GregorianDateTestHelper;
import org.junit.Test;
public class GregorianDateMatcherUnitTest {
private DateMatcher matcher = new GregorianDateMatcher();
private GregorianDateTestHelper testHelper = new GregorianDateTestHelper(matcher);
@Test
public void whenUsingGregorianDateMatcher_thenFormatConstraintsSatisfied() {
testHelper.assertFormat();
}
@Test
public void whenUsingGregorianDateMatcher_thenRangeConstraintsSatisfied() {
testHelper.assertRange();
}
@Test
public void whenYearIsLeap_thenFebruaryHas29Days() {
testHelper.assertFebruary29th();
}
@Test
public void whenMonthIsFebruary_thenMonthContainsUpTo28Days() {
testHelper.assertFebruaryGeneralDates();
}
@Test
public void whenMonthIsShort_thenMonthContainsUpTo30Days() {
testHelper.assertMonthsOf30Days();
}
@Test
public void whenMonthIsLong_thenMonthContainsUpTo31Days() {
testHelper.assertMonthsOf31Dates();
}
}

17
java-dates/src/test/java/com/baeldung/regexp/datepattern/gregorian/MonthsOf30DaysMatcherUnitTest.java
View File

@@ -1,17 +0,0 @@
package com.baeldung.regexp.datepattern.gregorian;
import com.baeldung.regexp.datepattern.DateMatcher;
import com.baeldung.regexp.datepattern.gregorian.testhelper.GregorianDateTestHelper;
import org.junit.Test;
public class MonthsOf30DaysMatcherUnitTest {
private DateMatcher matcher = new MonthsOf30DaysMatcher();
private GregorianDateTestHelper testHelper = new GregorianDateTestHelper(matcher);
@Test
public void whenMonthIsShort_thenMonthContainsUpTo30Days() {
testHelper.assertMonthsOf30Days();
}
}

17
java-dates/src/test/java/com/baeldung/regexp/datepattern/gregorian/MonthsOf31DaysMatcherUnitTest.java
View File

@@ -1,17 +0,0 @@
package com.baeldung.regexp.datepattern.gregorian;
import com.baeldung.regexp.datepattern.DateMatcher;
import com.baeldung.regexp.datepattern.gregorian.testhelper.GregorianDateTestHelper;
import org.junit.Test;
public class MonthsOf31DaysMatcherUnitTest {
private DateMatcher matcher = new MonthsOf31DaysMatcher();
private GregorianDateTestHelper testHelper = new GregorianDateTestHelper(matcher);
@Test
public void whenMonthIsLong_thenMonthContainsUpTo31Days() {
testHelper.assertMonthsOf31Dates();
}
}

102
java-dates/src/test/java/com/baeldung/regexp/datepattern/gregorian/testhelper/GregorianDateTestHelper.java
View File

@@ -1,102 +0,0 @@
package com.baeldung.regexp.datepattern.gregorian.testhelper;
import com.baeldung.regexp.datepattern.DateMatcher;
import org.junit.Assert;
public class GregorianDateTestHelper {
private final DateMatcher matcher;
public GregorianDateTestHelper(DateMatcher matcher) {
this.matcher = matcher;
}
public void assertFormat() {
Assert.assertTrue(matcher.matches("2017-12-31"));
Assert.assertTrue(matcher.matches("2018-01-01"));
Assert.assertFalse(matcher.matches("2018-02"));
Assert.assertFalse(matcher.matches("2018-02-01-01"));
Assert.assertFalse(matcher.matches("2018-02-XX"));
Assert.assertFalse(matcher.matches(" 2018-02-01"));
Assert.assertFalse(matcher.matches("2018-02-01 "));
Assert.assertFalse(matcher.matches("2020/02/28"));
Assert.assertFalse(matcher.matches("2020.02.29"));
}
public void assertRange() {
Assert.assertTrue(matcher.matches("1900-01-01"));
Assert.assertTrue(matcher.matches("2205-05-25"));
Assert.assertTrue(matcher.matches("2999-12-31"));
Assert.assertFalse(matcher.matches("1899-12-31"));
Assert.assertFalse(matcher.matches("2018-05-35"));
Assert.assertFalse(matcher.matches("2018-13-05"));
Assert.assertFalse(matcher.matches("3000-01-01"));
Assert.assertFalse(matcher.matches("3200-02-29"));
}
public void assertFebruary29th() {
Assert.assertTrue(matcher.matches("2000-02-29"));
Assert.assertTrue(matcher.matches("2400-02-29"));
Assert.assertTrue(matcher.matches("2800-02-29"));
Assert.assertTrue(matcher.matches("2020-02-29"));
Assert.assertTrue(matcher.matches("2024-02-29"));
Assert.assertTrue(matcher.matches("2028-02-29"));
Assert.assertFalse(matcher.matches("2017-02-29"));
Assert.assertFalse(matcher.matches("2018-02-29"));
Assert.assertFalse(matcher.matches("2019-02-29"));
Assert.assertFalse(matcher.matches("2100-02-29"));
Assert.assertFalse(matcher.matches("2200-02-29"));
Assert.assertFalse(matcher.matches("2300-02-29"));
}
public void assertFebruaryGeneralDates() {
Assert.assertTrue(matcher.matches("2018-02-01"));
Assert.assertTrue(matcher.matches("2019-02-13"));
Assert.assertTrue(matcher.matches("2020-02-25"));
Assert.assertFalse(matcher.matches("2000-02-30"));
Assert.assertFalse(matcher.matches("2400-02-62"));
Assert.assertFalse(matcher.matches("2420-02-94"));
}
public void assertMonthsOf30Days() {
Assert.assertTrue(matcher.matches("2018-04-30"));
Assert.assertTrue(matcher.matches("2019-06-30"));
Assert.assertTrue(matcher.matches("2020-09-30"));
Assert.assertTrue(matcher.matches("2021-11-30"));
Assert.assertTrue(matcher.matches("2022-04-02"));
Assert.assertTrue(matcher.matches("2023-06-14"));
Assert.assertTrue(matcher.matches("2024-09-26"));
Assert.assertFalse(matcher.matches("2018-04-31"));
Assert.assertFalse(matcher.matches("2019-06-31"));
Assert.assertFalse(matcher.matches("2020-09-31"));
Assert.assertFalse(matcher.matches("2021-11-31"));
Assert.assertFalse(matcher.matches("2022-04-32"));
Assert.assertFalse(matcher.matches("2023-06-64"));
Assert.assertFalse(matcher.matches("2024-09-96"));
}
public void assertMonthsOf31Dates() {
Assert.assertTrue(matcher.matches("2018-01-31"));
Assert.assertTrue(matcher.matches("2019-03-31"));
Assert.assertTrue(matcher.matches("2020-05-31"));
Assert.assertTrue(matcher.matches("2021-07-31"));
Assert.assertTrue(matcher.matches("2022-08-31"));
Assert.assertTrue(matcher.matches("2023-10-31"));
Assert.assertTrue(matcher.matches("2024-12-31"));
Assert.assertTrue(matcher.matches("2025-01-03"));
Assert.assertTrue(matcher.matches("2026-03-15"));
Assert.assertTrue(matcher.matches("2027-05-27"));
Assert.assertFalse(matcher.matches("2018-01-32"));
Assert.assertFalse(matcher.matches("2019-03-64"));
Assert.assertFalse(matcher.matches("2020-05-96"));
}
}

60
java-dates/src/test/java/com/baeldung/simpledateformat/SimpleDateFormatUnitTest.java
View File

@@ -1,60 +0,0 @@
package com.baeldung.simpledateformat;
import org.junit.Test;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
import java.util.TimeZone;
import java.util.logging.Logger;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
public class SimpleDateFormatUnitTest {
private static final Logger logger = Logger.getLogger(SimpleDateFormatUnitTest.class.getName());
@Test
public void givenSpecificDate_whenFormatted_thenCheckFormatCorrect() throws Exception {
SimpleDateFormat formatter = new SimpleDateFormat("dd-MM-yyyy");
assertEquals("24-05-1977", formatter.format(new Date(233345223232L)));
}
@Test
public void givenSpecificDate_whenFormattedUsingDateFormat_thenCheckFormatCorrect() throws Exception {
DateFormat formatter = DateFormat.getDateInstance(DateFormat.SHORT, Locale.US);
assertEquals("5/24/77", formatter.format(new Date(233345223232L)));
}
@Test
public void givenStringDate_whenParsed_thenCheckDateCorrect() throws Exception{
SimpleDateFormat formatter = new SimpleDateFormat("dd-MM-yyyy");
formatter.setTimeZone(TimeZone.getTimeZone("Europe/London"));
Date myDate = new Date(233276400000L);
Date parsedDate = formatter.parse("24-05-1977");
assertEquals(myDate.getTime(), parsedDate.getTime());
}
@Test
public void givenFranceLocale_whenFormatted_thenCheckFormatCorrect() throws Exception{
SimpleDateFormat franceDateFormatter = new SimpleDateFormat("EEEEE dd-MMMMMMM-yyyy", Locale.FRANCE);
Date myWednesday = new Date(1539341312904L);
assertTrue(franceDateFormatter.format(myWednesday).startsWith("vendredi"));
}
@Test
public void given2TimeZones_whenFormatted_thenCheckTimeDifference() throws Exception {
Date now = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("EEEE dd-MMM-yy HH:mm:ssZ");
simpleDateFormat.setTimeZone(TimeZone.getTimeZone("Europe/London"));
logger.info(simpleDateFormat.format(now));
//change the date format
simpleDateFormat.setTimeZone(TimeZone.getTimeZone("America/New_York"));
logger.info(simpleDateFormat.format(now));
}
}

22
java-dates/src/test/java/com/baeldung/timestamp/StringToTimestampConverterUnitTest.java
View File

@@ -1,22 +0,0 @@
package com.baeldung.timestamp;
import org.junit.Assert;
import org.junit.Test;
import java.sql.Timestamp;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
public class StringToTimestampConverterUnitTest {
@Test
public void givenDatePattern_whenParsing_thenTimestampIsCorrect() {
String pattern = "MMM dd, yyyy HH:mm:ss.SSSSSSSS";
String timestampAsString = "Nov 12, 2018 13:02:56.12345678";
DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
LocalDateTime localDateTime = LocalDateTime.from(formatter.parse(timestampAsString));
Timestamp timestamp = Timestamp.valueOf(localDateTime);
Assert.assertEquals("2018-11-12 13:02:56.12345678", timestamp.toString());
}
}

19
java-dates/src/test/java/com/baeldung/timestamp/TimestampToStringConverterTest.java
View File

@@ -1,19 +0,0 @@
package com.baeldung.timestamp;
import org.junit.Assert;
import org.junit.jupiter.api.Test;
import java.sql.Timestamp;
import java.time.format.DateTimeFormatter;
public class TimestampToStringConverterTest {
@Test
public void givenDatePattern_whenFormatting_thenResultingStringIsCorrect() {
Timestamp timestamp = Timestamp.valueOf("2018-12-12 01:02:03.123456789");
DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
String timestampAsString = formatter.format(timestamp.toLocalDateTime());
Assert.assertEquals("2018-12-12T01:02:03.123456789", timestampAsString);
}
}

22
java-dates/src/test/java/com/baeldung/zoneddatetime/OffsetDateTimeExampleUnitTest.java
View File

@@ -1,22 +0,0 @@
package com.baeldung.zoneddatetime;
import static org.junit.Assert.assertTrue;
import java.time.OffsetDateTime;
import java.time.ZoneOffset;
import org.junit.Test;
public class OffsetDateTimeExampleUnitTest {
OffsetDateTimeExample offsetDateTimeExample = new OffsetDateTimeExample();
@Test
public void givenZoneOffset_whenGetCurrentTime_thenResultHasZone() {
String offset = "+02:00";
OffsetDateTime time = offsetDateTimeExample.getCurrentTimeByZoneOffset(offset);
assertTrue(time.getOffset()
.equals(ZoneOffset.of(offset)));
}
}

22
java-dates/src/test/java/com/baeldung/zoneddatetime/OffsetTimeExampleUnitTest.java
View File

@@ -1,22 +0,0 @@
package com.baeldung.zoneddatetime;
import static org.junit.Assert.assertTrue;
import java.time.OffsetTime;
import java.time.ZoneOffset;
import org.junit.Test;
public class OffsetTimeExampleUnitTest {
OffsetTimeExample offsetTimeExample = new OffsetTimeExample();
@Test
public void givenZoneOffset_whenGetCurrentTime_thenResultHasZone() {
String offset = "+02:00";
OffsetTime time = offsetTimeExample.getCurrentTimeByZoneOffset(offset);
assertTrue(time.getOffset()
.equals(ZoneOffset.of(offset)));
}
}

33
java-dates/src/test/java/com/baeldung/zoneddatetime/ZoneDateTimeExampleUnitTest.java
View File

@@ -1,33 +0,0 @@
package com.baeldung.zoneddatetime;
import static org.junit.Assert.assertTrue;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import org.junit.Test;
public class ZoneDateTimeExampleUnitTest {
ZoneDateTimeExample zoneDateTimeExample = new ZoneDateTimeExample();
@Test
public void givenZone_whenGetCurrentTime_thenResultHasZone() {
String zone = "Europe/Berlin";
ZonedDateTime time = zoneDateTimeExample.getCurrentTimeByZoneId(zone);
assertTrue(time.getZone()
.equals(ZoneId.of(zone)));
}
@Test
public void givenZones_whenConvertDateByZone_thenGetConstantDiff() {
String sourceZone = "Europe/Berlin";
String destZone = "Asia/Tokyo";
ZonedDateTime sourceDate = zoneDateTimeExample.getCurrentTimeByZoneId(sourceZone);
ZonedDateTime destDate = zoneDateTimeExample.convertZonedDateTime(sourceDate, destZone);
assertTrue(sourceDate.toInstant()
.compareTo(destDate.toInstant()) == 0);
}
}

58
java-dates/src/test/java/com/baeldung/zoneddatetime/ZonedDateTimeUnitTest.java
View File

@@ -1,58 +0,0 @@
package com.baeldung.zoneddatetime;
import static org.junit.jupiter.api.Assertions.assertThrows;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.util.logging.Logger;
import org.junit.jupiter.api.Test;
public class ZonedDateTimeUnitTest {
private static final Logger log = Logger.getLogger(ZonedDateTimeUnitTest.class.getName());
@Test
public void givenZonedDateTime_whenConvertToString_thenOk() {
ZonedDateTime zonedDateTimeNow = ZonedDateTime.now(ZoneId.of("UTC"));
ZonedDateTime zonedDateTimeOf = ZonedDateTime.of(2018, 01, 01, 0, 0, 0, 0, ZoneId.of("UTC"));
LocalDateTime localDateTime = LocalDateTime.now();
ZonedDateTime zonedDateTime = ZonedDateTime.of(localDateTime, ZoneId.of("UTC"));
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy - HH:mm:ss Z");
String formattedString = zonedDateTime.format(formatter);
DateTimeFormatter formatter2 = DateTimeFormatter.ofPattern("MM/dd/yyyy - HH:mm:ss z");
String formattedString2 = zonedDateTime.format(formatter2);
log.info(formattedString);
log.info(formattedString2);
}
@Test
public void givenString_whenParseZonedDateTime_thenOk() {
ZonedDateTime zonedDateTime = ZonedDateTime.parse("2011-12-03T10:15:30+01:00");
log.info(zonedDateTime.format(DateTimeFormatter.ISO_ZONED_DATE_TIME));
}
@Test
public void givenString_whenParseZonedDateTimeWithoutZone_thenException() {
assertThrows(DateTimeParseException.class, () -> ZonedDateTime.parse("2011-12-03T10:15:30", DateTimeFormatter.ISO_DATE_TIME));
}
@Test
public void givenString_whenParseLocalDateTimeAtZone_thenOk() {
ZoneId timeZone = ZoneId.systemDefault();
ZonedDateTime zonedDateTime = LocalDateTime.parse("2011-12-03T10:15:30", DateTimeFormatter.ISO_DATE_TIME).atZone(timeZone);
log.info(zonedDateTime.format(DateTimeFormatter.ISO_ZONED_DATE_TIME));
}
}