Java Code Examples for java.time.format.DateTimeFormatter#format()

@Test(dataProvider = "signStyle")
public void test_signStyle(LocalDate localDate, SignStyle style, Class<?> expectedEx, String expectedStr) {
    DateTimeFormatterBuilder builder = new DateTimeFormatterBuilder();
    DateTimeFormatter formatter = builder.appendValue(ChronoField.YEAR, 2, 4, style)
                                         .toFormatter();
    formatter = formatter.withZone(ZoneOffset.UTC);
    if (expectedEx == null) {
        String output = formatter.format(localDate);
        assertEquals(output, expectedStr);
    } else {
        try {
            formatter.format(localDate);
            fail();
        } catch (Exception ex) {
            assertTrue(expectedEx.isInstance(ex));
        }
    }
}
 

@Test(dataProvider="printText")
public void test_appendText2arg_format(TemporalField field, TextStyle style, int value, String expected) throws Exception {
    DateTimeFormatter f = builder.appendText(field, style).toFormatter(Locale.ENGLISH);
    LocalDateTime dt = LocalDateTime.of(2010, 1, 1, 0, 0);
    dt = dt.with(field, value);
    String text = f.format(dt);
    assertEquals(text, expected);
}
 

@Override
public String format(@Nullable Object value, Locale locale) {
    if (value == null) {
        return "";
    }

    FormatStrings formatStrings = AppBeans.get(FormatStringsRegistry.class).getFormatStrings(locale);
    if (formatStrings == null) {
        return format(value);
    }

    DateTimeFormatter formatter = getDateTimeFormatter(formatStrings, locale);
    //noinspection unchecked
    return formatter.format((TemporalAccessor) value);
}
 

@Test(dataProvider="printText")
public void test_appendText2arg_format(TemporalField field, TextStyle style, int value, String expected) throws Exception {
    DateTimeFormatter f = builder.appendText(field, style).toFormatter(Locale.ENGLISH);
    LocalDateTime dt = LocalDateTime.of(2010, 1, 1, 0, 0);
    dt = dt.with(field, value);
    String text = f.format(dt);
    assertEquals(text, expected);
}
 

@Override
public Object getValueAt(int rowIndex, int columnIndex) {
    if (_dataTable.getColumns().get(columnIndex).getDataType() == DataType.DATE){
        DateTimeFormatter format = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        return format.format((LocalDateTime)_dataTable.getValue(rowIndex, columnIndex));
    } else 
        return _dataTable.getValue(rowIndex, columnIndex);
}
 

private String makeSnapshotReleaseString ()
{
    if ( this.snapshotBuildId == null || this.snapshotBuildId.isEmpty () )
    {
        final DateTimeFormatter formatter = DateTimeFormatter.ofPattern ( "yyyyMMddHHmm", Locale.ROOT );
        return this.snapshotReleasePrefix + formatter.format ( Instant.now ().atOffset ( ZoneOffset.UTC ) );
    }
    else
    {
        return this.snapshotReleasePrefix + this.snapshotBuildId;
    }
}
 

@Test(dataProvider = "LocalWeekBasedYearPatterns")
public void test_print_WeekBasedYear(String pattern, String expectedText, LocalDate date) {
    DateTimeFormatter dtf = DateTimeFormatter.ofPattern(pattern, locale);
    String result = dtf.format(date);
    WeekFields weekDef = WeekFields.of(locale);
    assertEquals(result, expectedText, "Incorrect formatting for " + pattern + ", weekDef: " + weekDef);
}
 

@Test(dataProvider = "LocalWeekBasedYearPatterns")
public void test_print_WeekBasedYear(String pattern, String expectedText, LocalDate date) {
    DateTimeFormatter dtf = DateTimeFormatter.ofPattern(pattern, locale);
    String result = dtf.format(date);
    WeekFields weekDef = WeekFields.of(locale);
    assertEquals(result, expectedText, "Incorrect formatting for " + pattern + ", weekDef: " + weekDef);
}
 

@SuppressWarnings("deprecation")
@Test(dataProvider="date")
public void test_date_print(LocalDate date, FormatStyle dateStyle, int dateStyleOld, Locale locale) {
    DateFormat old = DateFormat.getDateInstance(dateStyleOld, locale);
    Date oldDate = new Date(date.getYear() - 1900, date.getMonthValue() - 1, date.getDayOfMonth());
    String text = old.format(oldDate);

    DateTimeFormatter f = builder.appendLocalized(dateStyle, null).toFormatter(locale);
    String formatted = f.format(date);
    assertEquals(formatted, text);
}
 

@SuppressWarnings("deprecation")
@Test(dataProvider="time")
public void test_time_print(LocalTime time, FormatStyle timeStyle, int timeStyleOld, Locale locale) {
    DateFormat old = DateFormat.getTimeInstance(timeStyleOld, locale);
    Date oldDate = new Date(1970, 0, 0, time.getHour(), time.getMinute(), time.getSecond());
    String text = old.format(oldDate);

    DateTimeFormatter f = builder.appendLocalized(null, timeStyle).toFormatter(locale);
    String formatted = f.format(time);
    assertEquals(formatted, text);
}
 

public static String formatDetailedDateTime(long timestamp) {
    ZonedDateTime zonedDateTime = ZonedDateTime.ofInstant(Instant.ofEpochMilli(timestamp), ZoneOffset.systemDefault());
    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd-MMM-yyyy HH:mm:ss XXX");
    return formatter.format(zonedDateTime);
}
 

@Test(dataProvider="print_DayOfWeekData")
public void test_formatDayOfWeek(Locale locale, String pattern, String expected, DayOfWeek dayOfWeek) {
    DateTimeFormatter formatter = getPatternFormatter(pattern).withLocale(locale);
    String text = formatter.format(dayOfWeek);
    assertEquals(text, expected);
}
 

@Test(dataProvider="patternPrint")
public void test_appendPattern_patternPrint(String input, Temporal temporal, String expected) throws Exception {
    DateTimeFormatter f = builder.appendPattern(input).toFormatter(Locale.UK);
    String test = f.format(temporal);
    assertEquals(test, expected);
}
 

@Test(dataProvider = "every10minutes")
public void testStartScheduledScan(Instant now)
        throws Exception {
    DateTimeFormatter format = DateTimeFormatter.ofPattern("HH:mmX");
    String timeOfDay = format.format(now.atZone(ZoneOffset.UTC));

    ScanDestination destination = ScanDestination.to(URI.create("s3://bucket/path/to/root"));

    ScheduledDailyScanUpload scanUpload =
            new ScheduledDailyScanUpload("daily", timeOfDay, DateTimeFormatter.ofPattern("'test'-yyyyMMddHHmmss").withZone(ZoneOffset.UTC),
                    destination, DateTimeFormatter.ofPattern("yyyyMMddHHmmss").withZone(ZoneOffset.UTC),
                    ImmutableList.of("placement1"), 1, true, false, 1000000, Duration.ofMinutes(10));

    ScanUploader.ScanAndUploadBuilder builder = mock(ScanUploader.ScanAndUploadBuilder.class);
    ScanUploader scanUploader = mock(ScanUploader.class);
    when(scanUploader.scanAndUpload(anyString(), any(ScanOptions.class))).thenReturn(builder);
    StashRequestManager stashRequestManager = mock(StashRequestManager.class);
    ScanCountListener scanCountListener = mock(ScanCountListener.class);

    Clock clock = Clock.fixed(Instant.ofEpochMilli(now.toEpochMilli()), ZoneId.systemDefault());

    ScanUploadSchedulingService.DelegateSchedulingService service =
            new ScanUploadSchedulingService.DelegateSchedulingService(scanUploader, stashRequestManager, ImmutableList.<ScheduledDailyScanUpload>of(), scanCountListener, clock);

    service.startScheduledScan(scanUpload, now);

    String expectedScanId = DateTimeFormatter.ofPattern("'test'-yyyyMMddHHmmss").withZone(ZoneOffset.UTC).format(now);
    ScanDestination expectedDestination = ScanDestination.to(
            URI.create("s3://bucket/path/to/root/" + DateTimeFormatter.ofPattern("yyyyMMddHHmmss").withZone(ZoneOffset.UTC).format(now)));

    // Called once to to verify the scan does not exist
    verify(scanUploader).getStatus(expectedScanId);

    verify(scanUploader).scanAndUpload(expectedScanId,
            new ScanOptions("placement1")
                    .addDestination(expectedDestination)
                    .setMaxConcurrentSubRangeScans(1)
                    .setScanByAZ(true));

    verify(builder).start();
    
    verifyNoMoreInteractions(scanUploader);
}
 

/**
 * Formats this year-month using the specified formatter.
 * <p>
 * This year-month will be passed to the formatter to produce a string.
 *
 * @param formatter  the formatter to use, not null
 * @return the formatted year-month string, not null
 * @throws DateTimeException if an error occurs during printing
 */
public String format(DateTimeFormatter formatter) {
    Objects.requireNonNull(formatter, "formatter");
    return formatter.format(this);
}
 

/**
 * Formats this date-time using the specified formatter.
 * <p>
 * This date-time will be passed to the formatter to produce a string.
 * <p>
 * The default implementation must behave as follows:
 * <pre>
 *  return formatter.format(this);
 * </pre>
 *
 * @param formatter  the formatter to use, not null
 * @return the formatted date-time string, not null
 * @throws DateTimeException if an error occurs during printing
 */
default String format(DateTimeFormatter formatter) {
    Objects.requireNonNull(formatter, "formatter");
    return formatter.format(this);
}
 

/**
 * Formats this date-time using the specified formatter.
 * <p>
 * This date-time will be passed to the formatter to produce a string.
 *
 * @param formatter  the formatter to use, not null
 * @return the formatted date-time string, not null
 * @throws DateTimeException if an error occurs during printing
 */
public String format(DateTimeFormatter formatter) {
    Objects.requireNonNull(formatter, "formatter");
    return formatter.format(this);
}
 

/**
 * Formats this time using the specified formatter.
 * <p>
 * This time will be passed to the formatter to produce a string.
 *
 * @param formatter  the formatter to use, not null
 * @return the formatted time string, not null
 * @throws DateTimeException if an error occurs during printing
 */
public String format(DateTimeFormatter formatter) {
    Objects.requireNonNull(formatter, "formatter");
    return formatter.format(this);
}
 

/**
 * Formats this date using the specified formatter.
 * <p>
 * This date will be passed to the formatter to produce a string.
 * <p>
 * The default implementation must behave as follows:
 * <pre>
 *  return formatter.format(this);
 * </pre>
 *
 * @param formatter  the formatter to use, not null
 * @return the formatted date string, not null
 * @throws DateTimeException if an error occurs during printing
 */
default String format(DateTimeFormatter formatter) {
    Objects.requireNonNull(formatter, "formatter");
    return formatter.format(this);
}
 

/**
 * Formats this month-day using the specified formatter.
 * <p>
 * This month-day will be passed to the formatter to produce a string.
 *
 * @param formatter  the formatter to use, not null
 * @return the formatted month-day string, not null
 * @throws DateTimeException if an error occurs during printing
 */
public String format(DateTimeFormatter formatter) {
    Objects.requireNonNull(formatter, "formatter");
    return formatter.format(this);
}