diff --git a/buildSrc/src/main/groovy/org/elasticsearch/gradle/BuildPlugin.groovy b/buildSrc/src/main/groovy/org/elasticsearch/gradle/BuildPlugin.groovy index 27e792d6638f8..f34f59f1bef6d 100644 --- a/buildSrc/src/main/groovy/org/elasticsearch/gradle/BuildPlugin.groovy +++ b/buildSrc/src/main/groovy/org/elasticsearch/gradle/BuildPlugin.groovy @@ -842,6 +842,12 @@ class BuildPlugin implements Plugin { if ((ext.get('runtimeJavaVersion') as JavaVersion) >= JavaVersion.VERSION_1_9) { test.jvmArgs '--illegal-access=warn' } + //TODO remove once jvm.options are added to test system properties + if ((ext.get('runtimeJavaVersion') as JavaVersion) == JavaVersion.VERSION_1_8) { + test.systemProperty ('java.locale.providers','SPI,JRE') + } else if ((ext.get('runtimeJavaVersion') as JavaVersion) >= JavaVersion.VERSION_1_9) { + test.systemProperty ('java.locale.providers','SPI,COMPAT') + } } test.jvmArgumentProviders.add(nonInputProperties) @@ -876,6 +882,7 @@ class BuildPlugin implements Plugin { 'tests.security.manager': 'true', 'jna.nosys': 'true' + // ignore changing test seed when build is passed -Dignore.tests.seed for cacheability experimentation if (System.getProperty('ignore.tests.seed') != null) { nonInputProperties.systemProperty('tests.seed', project.property('testSeed')) diff --git a/server/src/main/java/org/elasticsearch/common/time/DateFormatters.java b/server/src/main/java/org/elasticsearch/common/time/DateFormatters.java index 288da5cff271f..26ec15559b803 100644 --- a/server/src/main/java/org/elasticsearch/common/time/DateFormatters.java +++ b/server/src/main/java/org/elasticsearch/common/time/DateFormatters.java @@ -37,7 +37,6 @@ import java.time.temporal.ChronoField; import java.time.temporal.IsoFields; import java.time.temporal.TemporalAccessor; -import java.time.temporal.TemporalAdjusters; import java.time.temporal.TemporalQueries; import java.time.temporal.TemporalQuery; import java.time.temporal.WeekFields; @@ -53,6 +52,7 @@ import static java.time.temporal.ChronoField.SECOND_OF_MINUTE; public class DateFormatters { + public static final WeekFields WEEK_FIELDS = WeekFields.of(DayOfWeek.MONDAY,4); private static final DateTimeFormatter TIME_ZONE_FORMATTER_NO_COLON = new DateTimeFormatterBuilder() .appendOffset("+HHmm", "Z") @@ -946,14 +946,14 @@ public class DateFormatters { * Returns a formatter for a four digit weekyear */ private static final DateFormatter STRICT_WEEKYEAR = new JavaDateFormatter("strict_weekyear", new DateTimeFormatterBuilder() - .appendValue(WeekFields.ISO.weekBasedYear(), 4, 10, SignStyle.EXCEEDS_PAD) + .appendValue(WEEK_FIELDS.weekBasedYear(), 4, 10, SignStyle.EXCEEDS_PAD) .toFormatter(Locale.ROOT) .withResolverStyle(ResolverStyle.STRICT)); private static final DateTimeFormatter STRICT_WEEKYEAR_WEEK_FORMATTER = new DateTimeFormatterBuilder() - .appendValue(WeekFields.ISO.weekBasedYear(), 4, 10, SignStyle.EXCEEDS_PAD) + .appendValue(WEEK_FIELDS.weekBasedYear(), 4, 10, SignStyle.EXCEEDS_PAD) .appendLiteral("-W") - .appendValue(WeekFields.ISO.weekOfWeekBasedYear(), 2, 2, SignStyle.NOT_NEGATIVE) + .appendValue(WEEK_FIELDS.weekOfWeekBasedYear(), 2, 2, SignStyle.NOT_NEGATIVE) .toFormatter(Locale.ROOT) .withResolverStyle(ResolverStyle.STRICT); @@ -972,7 +972,7 @@ public class DateFormatters { new DateTimeFormatterBuilder() .append(STRICT_WEEKYEAR_WEEK_FORMATTER) .appendLiteral("-") - .appendValue(WeekFields.ISO.dayOfWeek()) + .appendValue(WEEK_FIELDS.dayOfWeek()) .toFormatter(Locale.ROOT) .withResolverStyle(ResolverStyle.STRICT)); @@ -1162,7 +1162,7 @@ public class DateFormatters { * Returns a formatter for a four digit weekyear. (YYYY) */ private static final DateFormatter WEEK_YEAR = new JavaDateFormatter("week_year", - new DateTimeFormatterBuilder().appendValue(WeekFields.ISO.weekBasedYear()).toFormatter(Locale.ROOT) + new DateTimeFormatterBuilder().appendValue(WEEK_FIELDS.weekBasedYear()).toFormatter(Locale.ROOT) .withResolverStyle(ResolverStyle.STRICT)); /* @@ -1591,9 +1591,9 @@ public class DateFormatters { */ private static final DateFormatter WEEKYEAR_WEEK = new JavaDateFormatter("weekyear_week", STRICT_WEEKYEAR_WEEK_FORMATTER, new DateTimeFormatterBuilder() - .appendValue(WeekFields.ISO.weekBasedYear()) + .appendValue(WEEK_FIELDS.weekBasedYear()) .appendLiteral("-W") - .appendValue(WeekFields.ISO.weekOfWeekBasedYear()) + .appendValue(WEEK_FIELDS.weekOfWeekBasedYear()) .toFormatter(Locale.ROOT) .withResolverStyle(ResolverStyle.STRICT) ); @@ -1606,15 +1606,15 @@ public class DateFormatters { new DateTimeFormatterBuilder() .append(STRICT_WEEKYEAR_WEEK_FORMATTER) .appendLiteral("-") - .appendValue(WeekFields.ISO.dayOfWeek()) + .appendValue(WEEK_FIELDS.dayOfWeek()) .toFormatter(Locale.ROOT) .withResolverStyle(ResolverStyle.STRICT), new DateTimeFormatterBuilder() - .appendValue(WeekFields.ISO.weekBasedYear()) + .appendValue(WEEK_FIELDS.weekBasedYear()) .appendLiteral("-W") - .appendValue(WeekFields.ISO.weekOfWeekBasedYear()) + .appendValue(WEEK_FIELDS.weekOfWeekBasedYear()) .appendLiteral("-") - .appendValue(WeekFields.ISO.dayOfWeek()) + .appendValue(WEEK_FIELDS.dayOfWeek()) .toFormatter(Locale.ROOT) .withResolverStyle(ResolverStyle.STRICT) ); @@ -1858,7 +1858,7 @@ public static ZonedDateTime from(TemporalAccessor accessor) { } else if (isLocalDateSet) { return localDate.atStartOfDay(zoneId); } else if (isLocalTimeSet) { - return of(getLocaldate(accessor), localTime, zoneId); + return of(getLocalDate(accessor), localTime, zoneId); } else if (accessor.isSupported(ChronoField.YEAR) || accessor.isSupported(ChronoField.YEAR_OF_ERA) ) { if (accessor.isSupported(MONTH_OF_YEAR)) { return getFirstOfMonth(accessor).atStartOfDay(zoneId); @@ -1868,19 +1868,9 @@ public static ZonedDateTime from(TemporalAccessor accessor) { } } else if (accessor.isSupported(MONTH_OF_YEAR)) { // missing year, falling back to the epoch and then filling - return getLocaldate(accessor).atStartOfDay(zoneId); - } else if (accessor.isSupported(WeekFields.ISO.weekBasedYear())) { - if (accessor.isSupported(WeekFields.ISO.weekOfWeekBasedYear())) { - return Year.of(accessor.get(WeekFields.ISO.weekBasedYear())) - .atDay(1) - .with(WeekFields.ISO.weekOfWeekBasedYear(), accessor.getLong(WeekFields.ISO.weekOfWeekBasedYear())) - .atStartOfDay(zoneId); - } else { - return Year.of(accessor.get(WeekFields.ISO.weekBasedYear())) - .atDay(1) - .with(TemporalAdjusters.firstInMonth(DayOfWeek.MONDAY)) - .atStartOfDay(zoneId); - } + return getLocalDate(accessor).atStartOfDay(zoneId); + } else if (accessor.isSupported(WEEK_FIELDS.weekBasedYear())) { + return localDateFromWeekBasedDate(accessor).atStartOfDay(zoneId); } // we should not reach this piece of code, everything being parsed we should be able to @@ -1888,6 +1878,19 @@ public static ZonedDateTime from(TemporalAccessor accessor) { throw new IllegalArgumentException("temporal accessor [" + accessor + "] cannot be converted to zoned date time"); } + private static LocalDate localDateFromWeekBasedDate(TemporalAccessor accessor) { + if (accessor.isSupported(WEEK_FIELDS.weekOfWeekBasedYear())) { + return LocalDate.ofEpochDay(0) + .with(WEEK_FIELDS.weekBasedYear(), accessor.get(WEEK_FIELDS.weekBasedYear())) + .with(WEEK_FIELDS.weekOfWeekBasedYear(), accessor.get(WEEK_FIELDS.weekOfWeekBasedYear())) + .with(ChronoField.DAY_OF_WEEK, WEEK_FIELDS.getFirstDayOfWeek().getValue()); + } else { + return LocalDate.ofEpochDay(0) + .with(WEEK_FIELDS.weekBasedYear(), accessor.get(WEEK_FIELDS.weekBasedYear())) + .with(ChronoField.DAY_OF_WEEK, WEEK_FIELDS.getFirstDayOfWeek().getValue()); + } + } + /** * extending the java.time.temporal.TemporalQueries.LOCAL_DATE implementation to also create local dates * when YearOfEra was used instead of Year. @@ -1915,9 +1918,11 @@ public String toString() { } }; - private static LocalDate getLocaldate(TemporalAccessor accessor) { - int year = getYear(accessor); - if (accessor.isSupported(MONTH_OF_YEAR)) { + private static LocalDate getLocalDate(TemporalAccessor accessor) { + if (accessor.isSupported(WEEK_FIELDS.weekBasedYear())) { + return localDateFromWeekBasedDate(accessor); + } else if (accessor.isSupported(MONTH_OF_YEAR)) { + int year = getYear(accessor); if (accessor.isSupported(DAY_OF_MONTH)) { return LocalDate.of(year, accessor.get(MONTH_OF_YEAR), accessor.get(DAY_OF_MONTH)); } else { diff --git a/server/src/main/java/org/elasticsearch/common/time/IsoCalendarDataProvider.java b/server/src/main/java/org/elasticsearch/common/time/IsoCalendarDataProvider.java new file mode 100644 index 0000000000000..36a93049adeb8 --- /dev/null +++ b/server/src/main/java/org/elasticsearch/common/time/IsoCalendarDataProvider.java @@ -0,0 +1,41 @@ +/* + * Licensed to Elasticsearch under one or more contributor + * license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright + * ownership. Elasticsearch licenses this file to you under + * the Apache License, Version 2.0 (the "License"); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.elasticsearch.common.time; + +import java.util.Calendar; +import java.util.Locale; +import java.util.spi.CalendarDataProvider; + +public class IsoCalendarDataProvider extends CalendarDataProvider { + + @Override + public int getFirstDayOfWeek(Locale locale) { + return Calendar.MONDAY; + } + + @Override + public int getMinimalDaysInFirstWeek(Locale locale) { + return 4; + } + + @Override + public Locale[] getAvailableLocales() { + return new Locale[]{Locale.ROOT}; + } +} diff --git a/server/src/main/java/org/elasticsearch/script/JodaCompatibleZonedDateTime.java b/server/src/main/java/org/elasticsearch/script/JodaCompatibleZonedDateTime.java index 2c09456ed4302..1370f988ac7d1 100644 --- a/server/src/main/java/org/elasticsearch/script/JodaCompatibleZonedDateTime.java +++ b/server/src/main/java/org/elasticsearch/script/JodaCompatibleZonedDateTime.java @@ -23,6 +23,7 @@ import org.elasticsearch.common.SuppressForbidden; import org.elasticsearch.common.logging.DeprecationLogger; import org.elasticsearch.common.time.DateFormatter; +import org.elasticsearch.common.time.DateFormatters; import org.elasticsearch.common.time.DateUtils; import org.joda.time.DateTime; @@ -50,7 +51,6 @@ import java.time.temporal.TemporalQuery; import java.time.temporal.TemporalUnit; import java.time.temporal.ValueRange; -import java.time.temporal.WeekFields; import java.util.Locale; import java.util.Objects; @@ -474,14 +474,14 @@ public int getSecondOfMinute() { @Deprecated public int getWeekOfWeekyear() { - logDeprecatedMethod("getWeekOfWeekyear()", "get(WeekFields.ISO.weekOfWeekBasedYear())"); - return dt.get(WeekFields.ISO.weekOfWeekBasedYear()); + logDeprecatedMethod("getWeekOfWeekyear()", "get(DateFormatters.WEEK_FIELDS.weekOfWeekBasedYear())"); + return dt.get(DateFormatters.WEEK_FIELDS.weekOfWeekBasedYear()); } @Deprecated public int getWeekyear() { - logDeprecatedMethod("getWeekyear()", "get(WeekFields.ISO.weekBasedYear())"); - return dt.get(WeekFields.ISO.weekBasedYear()); + logDeprecatedMethod("getWeekyear()", "get(DateFormatters.WEEK_FIELDS.weekBasedYear())"); + return dt.get(DateFormatters.WEEK_FIELDS.weekBasedYear()); } @Deprecated diff --git a/server/src/main/resources/META-INF/services/java.util.spi.CalendarDataProvider b/server/src/main/resources/META-INF/services/java.util.spi.CalendarDataProvider new file mode 100644 index 0000000000000..6e006ccf815f8 --- /dev/null +++ b/server/src/main/resources/META-INF/services/java.util.spi.CalendarDataProvider @@ -0,0 +1 @@ +org.elasticsearch.common.time.IsoCalendarDataProvider \ No newline at end of file diff --git a/server/src/test/java/org/elasticsearch/common/joda/JavaJodaTimeDuellingTests.java b/server/src/test/java/org/elasticsearch/common/joda/JavaJodaTimeDuellingTests.java index 81f98d3ad752b..49e069ceb6f5a 100644 --- a/server/src/test/java/org/elasticsearch/common/joda/JavaJodaTimeDuellingTests.java +++ b/server/src/test/java/org/elasticsearch/common/joda/JavaJodaTimeDuellingTests.java @@ -37,9 +37,9 @@ import java.time.temporal.TemporalAccessor; import java.util.Locale; +import static org.hamcrest.CoreMatchers.equalTo; import static org.hamcrest.Matchers.containsString; import static org.hamcrest.Matchers.is; -import static org.hamcrest.core.IsEqual.equalTo; public class JavaJodaTimeDuellingTests extends ESTestCase { @Override diff --git a/server/src/test/java/org/elasticsearch/common/time/DateFormattersTests.java b/server/src/test/java/org/elasticsearch/common/time/DateFormattersTests.java index c5956e5c29a23..6b6c792d0a1d3 100644 --- a/server/src/test/java/org/elasticsearch/common/time/DateFormattersTests.java +++ b/server/src/test/java/org/elasticsearch/common/time/DateFormattersTests.java @@ -19,6 +19,7 @@ package org.elasticsearch.common.time; +import org.elasticsearch.bootstrap.JavaVersion; import org.elasticsearch.test.ESTestCase; import java.time.Clock; @@ -40,6 +41,35 @@ public class DateFormattersTests extends ESTestCase { + public void testWeekBasedDates() { + assumeFalse("won't work in jdk8 " + + "because SPI mechanism is not looking at classpath - needs ISOCalendarDataProvider in jre's ext/libs", + JavaVersion.current().equals(JavaVersion.parse("8"))); + + // as per WeekFields.ISO first week starts on Monday and has minimum 4 days + DateFormatter dateFormatter = DateFormatters.forPattern("YYYY-ww"); + + // first week of 2016 starts on Monday 2016-01-04 as previous week in 2016 has only 3 days + assertThat(DateFormatters.from(dateFormatter.parse("2016-01")) , + equalTo(ZonedDateTime.of(2016,01,04, 0,0,0,0,ZoneOffset.UTC))); + + // first week of 2015 starts on Monday 2014-12-29 because 4days belong to 2019 + assertThat(DateFormatters.from(dateFormatter.parse("2015-01")) , + equalTo(ZonedDateTime.of(2014,12,29, 0,0,0,0,ZoneOffset.UTC))); + + + // as per WeekFields.ISO first week starts on Monday and has minimum 4 days + dateFormatter = DateFormatters.forPattern("YYYY"); + + // first week of 2016 starts on Monday 2016-01-04 as previous week in 2016 has only 3 days + assertThat(DateFormatters.from(dateFormatter.parse("2016")) , + equalTo(ZonedDateTime.of(2016,01,04, 0,0,0,0,ZoneOffset.UTC))); + + // first week of 2015 starts on Monday 2014-12-29 because 4days belong to 2019 + assertThat(DateFormatters.from(dateFormatter.parse("2015")) , + equalTo(ZonedDateTime.of(2014,12,29, 0,0,0,0,ZoneOffset.UTC))); + } + // this is not in the duelling tests, because the epoch millis parser in joda time drops the milliseconds after the comma // but is able to parse the rest // as this feature is supported it also makes sense to make it exact diff --git a/server/src/test/java/org/elasticsearch/common/time/JavaDateMathParserTests.java b/server/src/test/java/org/elasticsearch/common/time/JavaDateMathParserTests.java index 34903e024d05d..1852ef639a42d 100644 --- a/server/src/test/java/org/elasticsearch/common/time/JavaDateMathParserTests.java +++ b/server/src/test/java/org/elasticsearch/common/time/JavaDateMathParserTests.java @@ -20,6 +20,7 @@ package org.elasticsearch.common.time; import org.elasticsearch.ElasticsearchParseException; +import org.elasticsearch.bootstrap.JavaVersion; import org.elasticsearch.test.ESTestCase; import java.time.Instant; @@ -50,6 +51,24 @@ public void testOverridingLocaleOrZoneAndCompositeRoundUpParser() { assertDateEquals(gotMillis, "297276785531", "297276785531"); } + public void testWeekDates() { + assumeFalse("won't work in jdk8 " + + "because SPI mechanism is not looking at classpath - needs ISOCalendarDataProvider in jre's ext/libs", + JavaVersion.current().equals(JavaVersion.parse("8"))); + + DateFormatter formatter = DateFormatter.forPattern("YYYY-ww"); + assertDateMathEquals(formatter.toDateMathParser(), "2016-01", "2016-01-04T23:59:59.999Z", 0, true, ZoneOffset.UTC); + + formatter = DateFormatter.forPattern("YYYY"); + assertDateMathEquals(formatter.toDateMathParser(), "2016", "2016-01-04T23:59:59.999Z", 0, true, ZoneOffset.UTC); + + formatter = DateFormatter.forPattern("YYYY-ww"); + assertDateMathEquals(formatter.toDateMathParser(), "2015-01", "2014-12-29T23:59:59.999Z", 0, true, ZoneOffset.UTC); + + formatter = DateFormatter.forPattern("YYYY"); + assertDateMathEquals(formatter.toDateMathParser(), "2015", "2014-12-29T23:59:59.999Z", 0, true, ZoneOffset.UTC); + } + public void testBasicDates() { assertDateMathEquals("2014-05-30", "2014-05-30T00:00:00.000"); assertDateMathEquals("2014-05-30T20", "2014-05-30T20:00:00.000"); diff --git a/server/src/test/java/org/elasticsearch/index/mapper/DateFieldMapperTests.java b/server/src/test/java/org/elasticsearch/index/mapper/DateFieldMapperTests.java index 38b3d5a2f1ff2..76484ab39d22c 100644 --- a/server/src/test/java/org/elasticsearch/index/mapper/DateFieldMapperTests.java +++ b/server/src/test/java/org/elasticsearch/index/mapper/DateFieldMapperTests.java @@ -235,7 +235,7 @@ public void testChangeLocale() throws IOException { mapper.parse(new SourceToParse("test", "type", "1", BytesReference .bytes(XContentFactory.jsonBuilder() .startObject() - .field("field", "Mi., 06 Dez. 2000 02:55:00 -0800") + .field("field", "Mi, 06 Dez 2000 02:55:00 -0800") .endObject()), XContentType.JSON)); } diff --git a/server/src/test/java/org/elasticsearch/script/JodaCompatibleZonedDateTimeTests.java b/server/src/test/java/org/elasticsearch/script/JodaCompatibleZonedDateTimeTests.java index 4750ee36b0bd6..9ed651bf70a41 100644 --- a/server/src/test/java/org/elasticsearch/script/JodaCompatibleZonedDateTimeTests.java +++ b/server/src/test/java/org/elasticsearch/script/JodaCompatibleZonedDateTimeTests.java @@ -213,12 +213,12 @@ public void testSecondOfMinute() { public void testWeekOfWeekyear() { assertMethodDeprecation(() -> assertThat(javaTime.getWeekOfWeekyear(), equalTo(jodaTime.getWeekOfWeekyear())), - "getWeekOfWeekyear()", "get(WeekFields.ISO.weekOfWeekBasedYear())"); + "getWeekOfWeekyear()", "get(DateFormatters.WEEK_FIELDS.weekOfWeekBasedYear())"); } public void testWeekyear() { assertMethodDeprecation(() -> assertThat(javaTime.getWeekyear(), equalTo(jodaTime.getWeekyear())), - "getWeekyear()", "get(WeekFields.ISO.weekBasedYear())"); + "getWeekyear()", "get(DateFormatters.WEEK_FIELDS.weekBasedYear())"); } public void testYearOfCentury() { diff --git a/server/src/test/java/org/elasticsearch/search/query/SearchQueryIT.java b/server/src/test/java/org/elasticsearch/search/query/SearchQueryIT.java index 37688645f1d7d..3ef3e28ade0d2 100644 --- a/server/src/test/java/org/elasticsearch/search/query/SearchQueryIT.java +++ b/server/src/test/java/org/elasticsearch/search/query/SearchQueryIT.java @@ -1678,21 +1678,21 @@ public void testRangeQueryWithLocaleMapping() throws Exception { .endObject().endObject().endObject())); indexRandom(true, - client().prepareIndex("test", "type1", "1").setSource("date_field", "Mi., 06 Dez. 2000 02:55:00 -0800"), - client().prepareIndex("test", "type1", "2").setSource("date_field", "Do., 07 Dez. 2000 02:55:00 -0800") + client().prepareIndex("test", "type1", "1").setSource("date_field", "Mi, 06 Dez 2000 02:55:00 -0800"), + client().prepareIndex("test", "type1", "2").setSource("date_field", "Do, 07 Dez 2000 02:55:00 -0800") ); SearchResponse searchResponse = client().prepareSearch("test") .setQuery(QueryBuilders.rangeQuery("date_field") - .gte("Di., 05 Dez. 2000 02:55:00 -0800") - .lte("Do., 07 Dez. 2000 00:00:00 -0800")) + .gte("Di, 05 Dez 2000 02:55:00 -0800") + .lte("Do, 07 Dez 2000 00:00:00 -0800")) .get(); assertHitCount(searchResponse, 1L); searchResponse = client().prepareSearch("test") .setQuery(QueryBuilders.rangeQuery("date_field") - .gte("Di., 05 Dez. 2000 02:55:00 -0800") - .lte("Fr., 08 Dez. 2000 00:00:00 -0800")) + .gte("Di, 05 Dez 2000 02:55:00 -0800") + .lte("Fr, 08 Dez 2000 00:00:00 -0800")) .get(); assertHitCount(searchResponse, 2L); } diff --git a/x-pack/plugin/core/src/test/java/org/elasticsearch/license/LicenseServiceTests.java b/x-pack/plugin/core/src/test/java/org/elasticsearch/license/LicenseServiceTests.java index 1f65efc630915..57394e647c9ea 100644 --- a/x-pack/plugin/core/src/test/java/org/elasticsearch/license/LicenseServiceTests.java +++ b/x-pack/plugin/core/src/test/java/org/elasticsearch/license/LicenseServiceTests.java @@ -17,23 +17,11 @@ /** * Due to changes in JDK9 where locale data is used from CLDR, the licence message will differ in jdk 8 and jdk9+ * https://openjdk.java.net/jeps/252 + * We run ES with -Djava.locale.providers=SPI,COMPAT and same option has to be applied when running this test from IDE */ public class LicenseServiceTests extends ESTestCase { - public void testLogExpirationWarningOnJdk9AndNewer() { - assumeTrue("this is for JDK9+", JavaVersion.current().compareTo(JavaVersion.parse("9")) >= 0); - - long time = LocalDate.of(2018, 11, 15).atStartOfDay(ZoneOffset.UTC).toInstant().toEpochMilli(); - final boolean expired = randomBoolean(); - final String message = LicenseService.buildExpirationMessage(time, expired).toString(); - if (expired) { - assertThat(message, startsWith("LICENSE [EXPIRED] ON [THU, NOV 15, 2018].\n")); - } else { - assertThat(message, startsWith("License [will expire] on [Thu, Nov 15, 2018].\n")); - } - } - - public void testLogExpirationWarningOnJdk8() { + public void testLogExpirationWarning() { assumeTrue("this is for JDK8 only", JavaVersion.current().equals(JavaVersion.parse("8"))); long time = LocalDate.of(2018, 11, 15).atStartOfDay(ZoneOffset.UTC).toInstant().toEpochMilli(); @@ -45,5 +33,4 @@ public void testLogExpirationWarningOnJdk8() { assertThat(message, startsWith("License [will expire] on [Thursday, November 15, 2018].\n")); } } - } diff --git a/x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/filestructurefinder/TimestampFormatFinderTests.java b/x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/filestructurefinder/TimestampFormatFinderTests.java index 7c5d6833efbb2..a0327183a16bc 100644 --- a/x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/filestructurefinder/TimestampFormatFinderTests.java +++ b/x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/filestructurefinder/TimestampFormatFinderTests.java @@ -430,7 +430,6 @@ public void testGuessIsDayFirstFromMatchesMultipleFormats() { } public void testGuessIsDayFirstFromLocale() { - TimestampFormatFinder timestampFormatFinder = new TimestampFormatFinder(explanation, true, true, true, NOOP_TIMEOUT_CHECKER); // Locale fallback is the only way to decide diff --git a/x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/expression/function/scalar/datetime/NonIsoDateTimeProcessor.java b/x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/expression/function/scalar/datetime/NonIsoDateTimeProcessor.java index 7f916be31bdb1..785a815a45c2a 100644 --- a/x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/expression/function/scalar/datetime/NonIsoDateTimeProcessor.java +++ b/x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/expression/function/scalar/datetime/NonIsoDateTimeProcessor.java @@ -10,14 +10,12 @@ import org.elasticsearch.common.io.stream.StreamOutput; import java.io.IOException; -import java.time.LocalDateTime; +import java.time.DayOfWeek; import java.time.ZoneId; import java.time.ZonedDateTime; import java.time.temporal.ChronoField; -import java.util.Calendar; -import java.util.Locale; +import java.time.temporal.WeekFields; import java.util.Objects; -import java.util.TimeZone; import java.util.function.Function; public class NonIsoDateTimeProcessor extends BaseDateTimeProcessor { @@ -30,15 +28,7 @@ public enum NonIsoDateTimeExtractor { return dayOfWeek == 8 ? 1 : dayOfWeek; }), WEEK_OF_YEAR(zdt -> { - // by ISO 8601 standard, the first week of a year is the first week with a majority (4 or more) of its days in January. - // Other Locales may have their own standards (see Arabic or Japanese calendars). - LocalDateTime ld = zdt.toLocalDateTime(); - Calendar cal = Calendar.getInstance(TimeZone.getTimeZone(zdt.getZone()), Locale.ROOT); - cal.clear(); - cal.set(ld.get(ChronoField.YEAR), ld.get(ChronoField.MONTH_OF_YEAR) - 1, ld.get(ChronoField.DAY_OF_MONTH), - ld.get(ChronoField.HOUR_OF_DAY), ld.get(ChronoField.MINUTE_OF_HOUR), ld.get(ChronoField.SECOND_OF_MINUTE)); - - return cal.get(Calendar.WEEK_OF_YEAR); + return zdt.get(WeekFields.of(DayOfWeek.SUNDAY, 1).weekOfWeekBasedYear()); }); private final Function apply; diff --git a/x-pack/plugin/sql/src/test/java/org/elasticsearch/xpack/sql/expression/function/scalar/datetime/NonIsoDateTimeProcessorTests.java b/x-pack/plugin/sql/src/test/java/org/elasticsearch/xpack/sql/expression/function/scalar/datetime/NonIsoDateTimeProcessorTests.java index a2ee6796f668d..a1971cecad1d5 100644 --- a/x-pack/plugin/sql/src/test/java/org/elasticsearch/xpack/sql/expression/function/scalar/datetime/NonIsoDateTimeProcessorTests.java +++ b/x-pack/plugin/sql/src/test/java/org/elasticsearch/xpack/sql/expression/function/scalar/datetime/NonIsoDateTimeProcessorTests.java @@ -16,7 +16,6 @@ import static org.elasticsearch.xpack.sql.util.DateUtils.UTC; public class NonIsoDateTimeProcessorTests extends AbstractSqlWireSerializingTestCase { - public static NonIsoDateTimeProcessor randomNonISODateTimeProcessor() { return new NonIsoDateTimeProcessor(randomFrom(NonIsoDateTimeExtractor.values()), UTC); @@ -45,6 +44,8 @@ protected ZoneId instanceZoneId(NonIsoDateTimeProcessor instance) { public void testNonISOWeekOfYearInUTC() { NonIsoDateTimeProcessor proc = new NonIsoDateTimeProcessor(NonIsoDateTimeExtractor.WEEK_OF_YEAR, UTC); + // 1 Jan 1988 is Friday - under Sunday,1 rule it is the first week of the year (under ISO rule it would be 53 of the previous year + // hence the 5th Jan 1988 Tuesday is the second week of a year assertEquals(2, proc.process(dateTime(568372930000L))); //1988-01-05T09:22:10Z[UTC] assertEquals(6, proc.process(dateTime(981278530000L))); //2001-02-04T09:22:10Z[UTC] assertEquals(7, proc.process(dateTime(224241730000L))); //1977-02-08T09:22:10Z[UTC] @@ -94,4 +95,4 @@ public void testNonISODayOfWeekInNonUTCTimeZone() { assertEquals(6, proc.process(dateTime(333451330000L))); assertEquals(5, proc.process(dateTime(874660930000L))); } -} \ No newline at end of file +}