diff options
13 files changed, 200 insertions, 187 deletions
diff --git a/JavaLibrary.mk b/JavaLibrary.mk index 75c06dd5d9..6722bfceed 100644 --- a/JavaLibrary.mk +++ b/JavaLibrary.mk @@ -158,6 +158,11 @@ LOCAL_DX_FLAGS := --core-library LOCAL_MODULE_TAGS := optional LOCAL_JAVA_LANGUAGE_VERSION := 1.8 LOCAL_MODULE := core-lambda-stubs +# Deliberately include the sources alongside the .class files to simplify +# distribution +LOCAL_JAVA_RESOURCE_FILES := \ + $(patsubst ojluni/src/lambda/java/%, \ + $(LOCAL_PATH)/ojluni/src/lambda/java:%,$(LOCAL_SRC_FILES)) LOCAL_JAVA_LIBRARIES := core-all LOCAL_NOTICE_FILE := $(LOCAL_PATH)/ojluni/NOTICE LOCAL_CORE_LIBRARY := true diff --git a/harmony-tests/src/test/java/org/apache/harmony/tests/javax/net/ssl/HostnameVerifierTest.java b/harmony-tests/src/test/java/org/apache/harmony/tests/javax/net/ssl/HostnameVerifierTest.java index 44572ab3a5..43e29cf7a5 100644 --- a/harmony-tests/src/test/java/org/apache/harmony/tests/javax/net/ssl/HostnameVerifierTest.java +++ b/harmony-tests/src/test/java/org/apache/harmony/tests/javax/net/ssl/HostnameVerifierTest.java @@ -40,6 +40,104 @@ public class HostnameVerifierTest extends TestCase implements assertFalse(hv.verify("localhost", session)); } + // copied and modified from apache http client test suite. + public void testVerify() throws Exception { + HostnameVerifier verifier = HttpsURLConnection.getDefaultHostnameVerifier(); + CertificateFactory cf = CertificateFactory.getInstance("X.509"); + InputStream in; + X509Certificate x509; + // CN=foo.com, no subjectAlt + in = new ByteArrayInputStream(X509_FOO); + x509 = (X509Certificate) cf.generateCertificate(in); + mySSLSession session = new mySSLSession(new X509Certificate[] {x509}); + assertFalse(verifier.verify("foo.com", session)); + assertFalse(verifier.verify("a.foo.com", session)); + assertFalse(verifier.verify("bar.com", session)); + + // CN=花子.co.jp, no subjectAlt + in = new ByteArrayInputStream(X509_HANAKO); + x509 = (X509Certificate) cf.generateCertificate(in); + session = new mySSLSession(new X509Certificate[] {x509}); + assertFalse(verifier.verify("\u82b1\u5b50.co.jp", session)); + assertFalse(verifier.verify("a.\u82b1\u5b50.co.jp", session)); + + // CN=foo.com, subjectAlt=bar.com + in = new ByteArrayInputStream(X509_FOO_BAR); + x509 = (X509Certificate) cf.generateCertificate(in); + session = new mySSLSession(new X509Certificate[] {x509}); + assertFalse(verifier.verify("foo.com", session)); + assertFalse(verifier.verify("a.foo.com", session)); + assertTrue(verifier.verify("bar.com", session)); + assertFalse(verifier.verify("a.bar.com", session)); + + // CN=foo.com, subjectAlt=bar.com, subjectAlt=花子.co.jp + in = new ByteArrayInputStream(X509_FOO_BAR_HANAKO); + x509 = (X509Certificate) cf.generateCertificate(in); + session = new mySSLSession(new X509Certificate[] {x509}); + assertFalse(verifier.verify("foo.com", session)); + assertFalse(verifier.verify("a.foo.com", session)); + assertTrue(verifier.verify("bar.com", session)); + assertFalse(verifier.verify("a.bar.com", session)); + // The certificate has this name in the altnames section, but Conscrypt drops + // any altnames that are improperly encoded according to RFC 5280, which requires + // non-ASCII characters to be encoded in ASCII via Punycode. + assertFalse(verifier.verify("\u82b1\u5b50.co.jp", session)); + assertFalse(verifier.verify("a.\u82b1\u5b50.co.jp", session)); + + // no CN, subjectAlt=foo.com + in = new ByteArrayInputStream(X509_NO_CNS_FOO); + x509 = (X509Certificate) cf.generateCertificate(in); + session = new mySSLSession(new X509Certificate[] {x509}); + assertTrue(verifier.verify("foo.com", session)); + assertFalse(verifier.verify("a.foo.com", session)); + + // CN=foo.com, CN=bar.com, CN=花子.co.jp, no subjectAlt + in = new ByteArrayInputStream(X509_THREE_CNS_FOO_BAR_HANAKO); + x509 = (X509Certificate) cf.generateCertificate(in); + session = new mySSLSession(new X509Certificate[] {x509}); + assertFalse(verifier.verify("foo.com", session)); + assertFalse(verifier.verify("a.foo.com", session)); + assertFalse(verifier.verify("bar.com", session)); + assertFalse(verifier.verify("a.bar.com", session)); + assertFalse(verifier.verify("\u82b1\u5b50.co.jp", session)); + assertFalse(verifier.verify("a.\u82b1\u5b50.co.jp", session)); + + // CN=*.foo.com, no subjectAlt + in = new ByteArrayInputStream(X509_WILD_FOO); + x509 = (X509Certificate) cf.generateCertificate(in); + session = new mySSLSession(new X509Certificate[] {x509}); + assertFalse(verifier.verify("foo.com", session)); + assertFalse(verifier.verify("www.foo.com", session)); + assertFalse(verifier.verify("\u82b1\u5b50.foo.com", session)); + assertFalse(verifier.verify("a.b.foo.com", session)); + + // CN=*.co.jp, no subjectAlt + in = new ByteArrayInputStream(X509_WILD_CO_JP); + x509 = (X509Certificate) cf.generateCertificate(in); + session = new mySSLSession(new X509Certificate[] {x509}); + assertFalse(verifier.verify("foo.co.jp", session)); + assertFalse(verifier.verify("\u82b1\u5b50.co.jp", session)); + + // CN=*.foo.com, subjectAlt=*.bar.com, subjectAlt=花子.co.jp + in = new ByteArrayInputStream(X509_WILD_FOO_BAR_HANAKO); + x509 = (X509Certificate) cf.generateCertificate(in); + session = new mySSLSession(new X509Certificate[] {x509}); + // try the foo.com variations + assertFalse(verifier.verify("foo.com", session)); + assertFalse(verifier.verify("www.foo.com", session)); + assertFalse(verifier.verify("\u82b1\u5b50.foo.com", session)); + assertFalse(verifier.verify("a.b.foo.com", session)); + assertFalse(verifier.verify("bar.com", session)); + assertTrue(verifier.verify("www.bar.com", session)); + assertFalse(verifier.verify("a.b.bar.com", session)); + // The certificate has this name in the altnames section, but Conscrypt drops + // any altnames that are improperly encoded according to RFC 5280, which requires + // non-ASCII characters to be encoded in ASCII via Punycode. + assertFalse(verifier.verify("\u82b1\u5b50.bar.com", session)); + assertFalse(verifier.verify("\u82b1\u5b50.co.jp", session)); + assertFalse(verifier.verify("a.\u82b1\u5b50.co.jp", session)); + } + public void testSubjectAlt() throws Exception { CertificateFactory cf = CertificateFactory.getInstance("X.509"); InputStream in = new ByteArrayInputStream(X509_MULTIPLE_SUBJECT_ALT); diff --git a/luni/src/test/java/libcore/io/OsTest.java b/luni/src/test/java/libcore/io/OsTest.java index febf6aa97b..760b0dbc5d 100644 --- a/luni/src/test/java/libcore/io/OsTest.java +++ b/luni/src/test/java/libcore/io/OsTest.java @@ -632,16 +632,14 @@ public class OsTest extends TestCase { } // ENOTSUP, Extended attributes are not supported by the filesystem, or are disabled. - // Since kernel version 4.9 (or some other version after 4.4), *xattr() methods - // may set errno to EACCESS instead. This behavior change is likely related to - // https://patchwork.kernel.org/patch/9294421/ which reimplemented getxattr, setxattr, - // and removexattr on top of generic handlers. + final boolean root = (Libcore.os.getuid() == 0); final String path = "/proc/self/stat"; try { Libcore.os.setxattr(path, NAME_TEST, VALUE_CAKE, OsConstants.XATTR_CREATE); fail(); } catch (ErrnoException e) { - assertTrue("Unexpected errno: " + e.errno, e.errno == ENOTSUP || e.errno == EACCES); + // setxattr(2) requires root permission for writing to this file, will get EACCES otherwise. + assertEquals(root ? ENOTSUP : EACCES, e.errno); } try { Libcore.os.getxattr(path, NAME_TEST); @@ -659,7 +657,7 @@ public class OsTest extends TestCase { Libcore.os.removexattr(path, NAME_TEST); fail(); } catch (ErrnoException e) { - assertTrue("Unexpected errno: " + e.errno, e.errno == ENOTSUP || e.errno == EACCES); + assertEquals(ENOTSUP, e.errno); } } diff --git a/luni/src/test/java/libcore/java/net/URLTest.java b/luni/src/test/java/libcore/java/net/URLTest.java index 231e09c134..58bd8cc732 100644 --- a/luni/src/test/java/libcore/java/net/URLTest.java +++ b/luni/src/test/java/libcore/java/net/URLTest.java @@ -409,6 +409,26 @@ public final class URLTest extends TestCase { assertEquals("http://host/a/c", url.toString()); // RI doesn't canonicalize } + public void testPathContainsBackslash() throws Exception { + URL url = new URL("http://host\\path@foo"); + assertEquals("\\path@foo", url.getPath()); + assertEquals("host", url.getHost()); + } + + public void testQueryContainsForwardSlash() throws Exception { + URL url = new URL("http://host?query/foo"); + assertEquals("", url.getPath()); + assertEquals("host", url.getHost()); + assertEquals("query/foo", url.getQuery()); + } + + public void testFragmentContainsForwardSlash() throws Exception { + URL url = new URL("http://host#fragment/foo"); + assertEquals("", url.getPath()); + assertEquals("host", url.getHost()); + assertEquals("fragment/foo", url.getRef()); + } + public void testRelativePathAndFragment() throws Exception { URL base = new URL("http://host/file"); assertEquals("http://host/another#fragment", new URL(base, "another#fragment").toString()); diff --git a/luni/src/test/java/libcore/java/time/chrono/JapaneseChronologyTest.java b/luni/src/test/java/libcore/java/time/chrono/JapaneseChronologyTest.java index 1f36b2c6ed..3c1f0cf561 100644 --- a/luni/src/test/java/libcore/java/time/chrono/JapaneseChronologyTest.java +++ b/luni/src/test/java/libcore/java/time/chrono/JapaneseChronologyTest.java @@ -16,8 +16,6 @@ package libcore.java.time.chrono; import org.junit.Test; -import android.icu.util.JapaneseCalendar; -import java.util.List; import java.time.Instant; import java.time.LocalDate; import java.time.LocalTime; @@ -25,7 +23,6 @@ import java.time.ZoneId; import java.time.ZoneOffset; import java.time.ZonedDateTime; import java.time.chrono.ChronoZonedDateTime; -import java.time.chrono.Era; import java.time.chrono.JapaneseChronology; import java.time.chrono.JapaneseDate; import java.time.chrono.JapaneseEra; @@ -113,14 +110,4 @@ public class JapaneseChronologyTest { assertEquals(true, date.isSupported(ChronoField.YEAR)); assertEquals(true, date.isSupported(ChronoField.YEAR_OF_ERA)); } - - @Test - public void test_eras_isLatestEraConsistency() { - List<Era> japaneseEras = JapaneseChronology.INSTANCE.eras(); - boolean isHeiseiLatestInJavaTime = - japaneseEras.get(japaneseEras.size()-1).getValue() <= JapaneseEra.HEISEI.getValue(); - boolean isHeiseiLatestInIcu = JapaneseCalendar.CURRENT_ERA == JapaneseCalendar.HEISEI; - assertEquals("java.time and ICU4J are not consistent in the latest japanese era", - isHeiseiLatestInJavaTime, isHeiseiLatestInIcu); - } } diff --git a/luni/src/test/java/libcore/javax/net/ssl/SSLEngineTest.java b/luni/src/test/java/libcore/javax/net/ssl/SSLEngineTest.java index d9a7b4fadc..a4d3e5f4c0 100644 --- a/luni/src/test/java/libcore/javax/net/ssl/SSLEngineTest.java +++ b/luni/src/test/java/libcore/javax/net/ssl/SSLEngineTest.java @@ -317,9 +317,49 @@ public class SSLEngineTest extends TestCase { assertEquals(sourceCipherSuite, 2, numUnwrapCalls); } else { assertEquals(sourceCipherSuite, 1, numUnwrapCalls); + assertSendsCorrectlyWhenSplit(sourceBytes, source, dest); } } + private static void assertSendsCorrectlyWhenSplit(final byte[] sourceBytes, SSLEngine source, + SSLEngine dest) throws SSLException { + // Split the input into three to test the version that accepts ByteBuffer[]. Three + // is chosen somewhat arbitrarily as a number larger than the minimum of 2 but small + // enough that it's not unwieldy. + ByteBuffer[] sourceBufs = new ByteBuffer[3]; + int sourceLen = sourceBytes.length; + sourceBufs[0] = ByteBuffer.wrap(sourceBytes, 0, sourceLen / 3); + sourceBufs[1] = ByteBuffer.wrap(sourceBytes, sourceLen / 3, sourceLen / 3); + sourceBufs[2] = ByteBuffer.wrap( + sourceBytes, 2 * (sourceLen / 3), sourceLen - 2 * (sourceLen / 3)); + SSLSession sourceSession = source.getSession(); + ByteBuffer sourceToDest = ByteBuffer.allocate(sourceSession.getPacketBufferSize()); + SSLEngineResult sourceOutRes = source.wrap(sourceBufs, sourceToDest); + sourceToDest.flip(); + + String sourceCipherSuite = source.getSession().getCipherSuite(); + assertEquals(sourceCipherSuite, sourceBytes.length, sourceOutRes.bytesConsumed()); + assertEquals(sourceCipherSuite, HandshakeStatus.NOT_HANDSHAKING, + sourceOutRes.getHandshakeStatus()); + + SSLSession destSession = dest.getSession(); + ByteBuffer destIn = ByteBuffer.allocate(destSession.getApplicationBufferSize()); + + int numUnwrapCalls = 0; + while (destIn.position() != sourceBytes.length) { + SSLEngineResult destRes = dest.unwrap(sourceToDest, destIn); + assertEquals(sourceCipherSuite, HandshakeStatus.NOT_HANDSHAKING, + destRes.getHandshakeStatus()); + numUnwrapCalls++; + } + + destIn.flip(); + byte[] actual = new byte[destIn.remaining()]; + destIn.get(actual); + assertEquals(sourceCipherSuite, Arrays.toString(sourceBytes), Arrays.toString(actual)); + assertEquals(sourceCipherSuite, 3, numUnwrapCalls); + } + public void test_SSLEngine_getEnabledCipherSuites_returnsCopies() throws Exception { TestSSLContext c = TestSSLContext.create(); SSLEngine e = c.clientContext.createSSLEngine(); diff --git a/ojluni/src/main/java/java/net/URLStreamHandler.java b/ojluni/src/main/java/java/net/URLStreamHandler.java index eac8a78ba2..ad25dfcddc 100644 --- a/ojluni/src/main/java/java/net/URLStreamHandler.java +++ b/ojluni/src/main/java/java/net/URLStreamHandler.java @@ -167,12 +167,25 @@ public abstract class URLStreamHandler { if (!isUNCName && (start <= limit - 2) && (spec.charAt(start) == '/') && (spec.charAt(start + 1) == '/')) { start += 2; + // BEGIN Android-changed: Check for all hostname termination chars. http://b/110955991 + /* i = spec.indexOf('/', start); if (i < 0 || i > limit) { i = spec.indexOf('?', start); if (i < 0 || i > limit) i = limit; } + */ + LOOP: for (i = start; i < limit; i++) { + switch (spec.charAt(i)) { + case '/': // Start of path + case '\\': // Start of path - see https://url.spec.whatwg.org/#host-state + case '?': // Start of query + case '#': // Start of fragment + break LOOP; + } + } + // END Android-changed: Check for all hostname termination chars. http://b/110955991 host = authority = spec.substring(start, i); @@ -266,7 +279,9 @@ public abstract class URLStreamHandler { // Parse the file path if any if (start < limit) { - if (spec.charAt(start) == '/') { + // Android-changed: Check for all hostname termination chars. http://b/110955991 + // if (spec.charAt(start) == '/') { + if (spec.charAt(start) == '/' || spec.charAt(start) == '\\') { path = spec.substring(start, limit); } else if (path != null && path.length() > 0) { isRelPath = true; diff --git a/ojluni/src/test/java/time/tck/java/time/chrono/TCKJapaneseChronology.java b/ojluni/src/test/java/time/tck/java/time/chrono/TCKJapaneseChronology.java index 394d6d58e7..2bc1f4c8ce 100644 --- a/ojluni/src/test/java/time/tck/java/time/chrono/TCKJapaneseChronology.java +++ b/ojluni/src/test/java/time/tck/java/time/chrono/TCKJapaneseChronology.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012, 2019, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -111,24 +111,6 @@ import org.testng.annotations.Test; */ @Test public class TCKJapaneseChronology { - - // Android-added: Add a static field to indicate if the device supports the new Japanese era. - /** - * Indicates if the device support newer Japenese Era than Heisei. Old Android releases can - * optionally support new Japanese Era, e.g. Reiwa, and Android test suites, e.g. CTS, can use - * this flag to alter the expected result. This flag can be placed in other classes, but - * TCKJapaneseChronology is picked arbitrarily. - */ - public static final boolean IS_HEISEI_LATEST; - static { - List<Era> japaneseEras = JapaneseChronology.INSTANCE.eras(); - IS_HEISEI_LATEST = - japaneseEras.get(japaneseEras.size()-1).getValue() <= JapaneseEra.HEISEI.getValue(); - } - - - // Year differences from Gregorian years. - private static final int YDIFF_REIWA = 2018; private static final int YDIFF_HEISEI = 1988; private static final int YDIFF_MEIJI = 1867; private static final int YDIFF_SHOWA = 1925; @@ -191,10 +173,6 @@ public class TCKJapaneseChronology { @DataProvider(name="createByEra") Object[][] data_createByEra() { return new Object[][] { - // Android-changed: Old Android releases can optionally support the new Japanese era. - IS_HEISEI_LATEST - ? new Object[] {JapaneseEra.HEISEI, 2020 - YDIFF_HEISEI, 2, 29, 60, LocalDate.of(2020, 2, 29)} - : new Object[] {JapaneseEra.of(3), 2020 - YDIFF_REIWA, 2, 29, 60, LocalDate.of(2020, 2, 29)}, // NEWERA {JapaneseEra.HEISEI, 1996 - YDIFF_HEISEI, 2, 29, 60, LocalDate.of(1996, 2, 29)}, {JapaneseEra.HEISEI, 2000 - YDIFF_HEISEI, 2, 29, 60, LocalDate.of(2000, 2, 29)}, {JapaneseEra.MEIJI, 1874 - YDIFF_MEIJI, 2, 28, 59, LocalDate.of(1874, 2, 28)}, @@ -387,16 +365,8 @@ public class TCKJapaneseChronology { @DataProvider(name="prolepticYear") Object[][] data_prolepticYear() { return new Object[][] { - // Android-changed: Old Android releases can optionally support the new Japanese era. - IS_HEISEI_LATEST - ? new Object[] {2, JapaneseEra.HEISEI, 1, 1 + YDIFF_HEISEI, false} - : new Object[] {3, JapaneseEra.of(3), 1, 1 + YDIFF_REIWA, false}, - IS_HEISEI_LATEST - ? new Object[] {2, JapaneseEra.HEISEI, 102, 102 + YDIFF_HEISEI, false} - : new Object[] {3, JapaneseEra.of(3), 102, 102 + YDIFF_REIWA, true}, - {2, JapaneseEra.HEISEI, 1, 1 + YDIFF_HEISEI, false}, - {2, JapaneseEra.HEISEI, 4, 4 + YDIFF_HEISEI, true}, + {2, JapaneseEra.HEISEI, 100, 100 + YDIFF_HEISEI, true}, {-1, JapaneseEra.MEIJI, 9, 9 + YDIFF_MEIJI, true}, {-1, JapaneseEra.MEIJI, 10, 10 + YDIFF_MEIJI, false}, @@ -573,16 +543,6 @@ public class TCKJapaneseChronology { //----------------------------------------------------------------------- @DataProvider(name="japaneseEras") Object[][] data_japanseseEras() { - // Android-changed: Old Android releases can optionally support the new Japanese era. - if (!IS_HEISEI_LATEST) { - return new Object[][] { - { JapaneseEra.MEIJI, -1, "Meiji"}, - { JapaneseEra.TAISHO, 0, "Taisho"}, - { JapaneseEra.SHOWA, 1, "Showa"}, - { JapaneseEra.HEISEI, 2, "Heisei"}, - { JapaneseEra.of(3), 3, "Reiwa"}, - }; - } return new Object[][] { { JapaneseEra.MEIJI, -1, "Meiji"}, { JapaneseEra.TAISHO, 0, "Taisho"}, @@ -602,7 +562,7 @@ public class TCKJapaneseChronology { @Test public void test_Japanese_badEras() { - int badEras[] = {-1000, -998, -997, -2, 4, 5, 1000}; + int badEras[] = {-1000, -998, -997, -2, 3, 4, 1000}; for (int badEra : badEras) { try { Era era = JapaneseChronology.INSTANCE.eraOf(badEra); @@ -723,10 +683,6 @@ public class TCKJapaneseChronology { {JapaneseChronology.INSTANCE.date(1989, 1, 7), "Japanese Showa 64-01-07"}, {JapaneseChronology.INSTANCE.date(1989, 1, 8), "Japanese Heisei 1-01-08"}, {JapaneseChronology.INSTANCE.date(2012, 12, 6), "Japanese Heisei 24-12-06"}, - // Android-changed: Old Android releases can optionally support the new Japanese era. - IS_HEISEI_LATEST - ? new Object[] {JapaneseChronology.INSTANCE.date(2020, 1, 6), "Japanese Heisei 32-01-06"} - : new Object[] {JapaneseChronology.INSTANCE.date(2020, 1, 6), "Japanese Reiwa 2-01-06"}, }; } diff --git a/ojluni/src/test/java/time/tck/java/time/chrono/TCKJapaneseEra.java b/ojluni/src/test/java/time/tck/java/time/chrono/TCKJapaneseEra.java index 815517c815..de83e1d3bc 100644 --- a/ojluni/src/test/java/time/tck/java/time/chrono/TCKJapaneseEra.java +++ b/ojluni/src/test/java/time/tck/java/time/chrono/TCKJapaneseEra.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012, 2019, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -59,7 +59,6 @@ package tck.java.time.chrono; import static java.time.temporal.ChronoField.ERA; import static org.testng.Assert.assertEquals; import static org.testng.Assert.assertTrue; -import static tck.java.time.chrono.TCKJapaneseChronology.IS_HEISEI_LATEST; import java.time.chrono.Era; import java.time.chrono.JapaneseChronology; @@ -77,16 +76,6 @@ public class TCKJapaneseEra { @DataProvider(name = "JapaneseEras") Object[][] data_of_eras() { - // Android-changed: Old Android releases can optionally support the new Japanese era. - if (!IS_HEISEI_LATEST) { - return new Object[][] { - {JapaneseEra.of(3), "Reiwa", 3}, - {JapaneseEra.HEISEI, "Heisei", 2}, - {JapaneseEra.SHOWA, "Showa", 1}, - {JapaneseEra.TAISHO, "Taisho", 0}, - {JapaneseEra.MEIJI, "Meiji", -1}, - }; - } return new Object[][] { {JapaneseEra.HEISEI, "Heisei", 2}, {JapaneseEra.SHOWA, "Showa", 1}, diff --git a/ojluni/src/test/java/time/tck/java/time/zone/TCKZoneRules.java b/ojluni/src/test/java/time/tck/java/time/zone/TCKZoneRules.java index c1a3f72d0e..67a10c04a1 100644 --- a/ojluni/src/test/java/time/tck/java/time/zone/TCKZoneRules.java +++ b/ojluni/src/test/java/time/tck/java/time/zone/TCKZoneRules.java @@ -942,9 +942,6 @@ public class TCKZoneRules { assertEquals(zdt.plusHours(2).toLocalDateTime(), LocalDateTime.of(2011, 12, 31, 1, 0)); } - // Removal of test for CTS that is dependent on IANA rules data version. Fails >= 2017c - // http://b/68878031 - /* public void test_Apia_jumpForwardOverInternationalDateLine_P12_to_M12() { // transition occurred at 1879-07-04T00:00+12:33:04 ZoneRules test = pacificApia(); @@ -962,7 +959,6 @@ public class TCKZoneRules { ZonedDateTime zdt = ZonedDateTime.of(1879, 7, 4, 23, 0, 0, 0, ZoneId.of("Pacific/Apia")); assertEquals(zdt.plusHours(2).toLocalDateTime(), LocalDateTime.of(1879, 7, 4, 1, 0, 0)); } - */ //------------------------------------------------------------------------- @Test(expectedExceptions=UnsupportedOperationException.class) diff --git a/ojluni/src/test/java/time/test/java/time/chrono/TestJapaneseChronology.java b/ojluni/src/test/java/time/test/java/time/chrono/TestJapaneseChronology.java index 337a8dbc3d..3fbf853231 100644 --- a/ojluni/src/test/java/time/test/java/time/chrono/TestJapaneseChronology.java +++ b/ojluni/src/test/java/time/test/java/time/chrono/TestJapaneseChronology.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2013, 2019, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -28,15 +28,12 @@ package test.java.time.chrono; import java.time.*; import java.time.chrono.*; import java.time.temporal.*; -import java.util.Arrays; import java.util.List; import java.util.Locale; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import static org.testng.Assert.assertEquals; -import static org.testng.Assert.assertTrue; -import static tck.java.time.chrono.TCKJapaneseChronology.IS_HEISEI_LATEST; /** * Tests for the Japanese chronology @@ -48,8 +45,7 @@ public class TestJapaneseChronology { @DataProvider(name="transitions") Object[][] transitionData() { - // Android-changed: Old Android releases can optionally support the new Japanese era. - List<Object[]> data = Arrays.asList(new Object[][] { + return new Object[][] { // Japanese era, yearOfEra, month, dayOfMonth, gregorianYear { JapaneseEra.MEIJI, 6, 1, 1, 1873 }, // Meiji-Taisho transition isn't accurate. 1912-07-30 is the last day of Meiji @@ -62,20 +58,12 @@ public class TestJapaneseChronology { { JapaneseEra.SHOWA, 1, 12, 25, 1926 }, { JapaneseEra.SHOWA, 64, 1, 7, 1989 }, { JapaneseEra.HEISEI, 1, 1, 8, 1989 }, - }); - if (IS_HEISEI_LATEST) { - data.addAll(Arrays.asList(new Object[][] { - { JapaneseEra.HEISEI, 31, 4, 30, 2019 }, - { JapaneseEra.of(3), 1, 5, 1, 2019 }, - })); - } - return data.toArray(new Object[data.size()][]); + }; } @DataProvider(name="day_year_data") Object[][] dayYearData() { - // Android-changed: Old Android releases can optionally support the new Japanese era. - List<Object[]> data = Arrays.asList(new Object[][] { + return new Object[][] { // Japanese era, yearOfEra, dayOfYear, month, dayOfMonth { JapaneseEra.MEIJI, 45, 211, 7, 29 }, { JapaneseEra.TAISHO, 1, 1, 7, 30 }, @@ -86,25 +74,15 @@ public class TestJapaneseChronology { { JapaneseEra.SHOWA, 64, 7, 1, 7 }, { JapaneseEra.HEISEI, 1, 1, 1, 8 }, { JapaneseEra.HEISEI, 2, 8, 1, 8 }, - }); - if (IS_HEISEI_LATEST) { - data.addAll(Arrays.asList(new Object[][] { - { JapaneseEra.HEISEI, 31, 120, 4, 30 }, - { JapaneseEra.of(3), 1, 1, 5, 1 }, - })); - } - return data.toArray(new Object[data.size()][]); + }; } @DataProvider(name="range_data") Object[][] rangeData() { - // Android-changed: Old Android releases can optionally support the new Japanese era. - int maxEra = IS_HEISEI_LATEST ? 2 : 3; - int yearOfLatestEra = IS_HEISEI_LATEST ? 1989 : 2019; return new Object[][] { // field, minSmallest, minLargest, maxSmallest, maxLargest - { ChronoField.ERA, -1, -1, maxEra, maxEra}, - { ChronoField.YEAR_OF_ERA, 1, 1, 15, 999999999-yearOfLatestEra}, // depends on the current era + { ChronoField.ERA, -1, -1, 2, 2}, + { ChronoField.YEAR_OF_ERA, 1, 1, 15, 999999999-1989 }, // depends on the current era { ChronoField.DAY_OF_YEAR, 1, 1, 7, 366}, { ChronoField.YEAR, 1873, 1873, 999999999, 999999999}, }; @@ -127,9 +105,7 @@ public class TestJapaneseChronology { { JapaneseEra.SHOWA, 65, 1, 1 }, { JapaneseEra.HEISEI, 1, 1, 7 }, { JapaneseEra.HEISEI, 1, 2, 29 }, - { JapaneseEra.HEISEI, 31, 5, 1 }, - { JapaneseEra.of(3), 1, 4, 30 }, - { JapaneseEra.of(3), Year.MAX_VALUE, 12, 31 }, + { JapaneseEra.HEISEI, Year.MAX_VALUE, 12, 31 }, }; } @@ -148,10 +124,7 @@ public class TestJapaneseChronology { { JapaneseEra.SHOWA, 65 }, { JapaneseEra.HEISEI, -1 }, { JapaneseEra.HEISEI, 0 }, - { JapaneseEra.HEISEI, 32 }, - { JapaneseEra.of(3), -1 }, - { JapaneseEra.of(3), 0 }, - { JapaneseEra.of(3), Year.MAX_VALUE }, + { JapaneseEra.HEISEI, Year.MAX_VALUE }, }; } @@ -168,22 +141,6 @@ public class TestJapaneseChronology { { JapaneseEra.SHOWA, 64, 8 }, { JapaneseEra.HEISEI, 1, 360 }, { JapaneseEra.HEISEI, 2, 366 }, - { JapaneseEra.HEISEI, 31, 121 }, - { JapaneseEra.of(3), 1, 246 }, - { JapaneseEra.of(3), 2, 367 }, - }; - } - - @DataProvider - Object[][] eraNameData() { - return new Object[][] { - // Japanese era, name, exception - { "Meiji", JapaneseEra.MEIJI, null }, - { "Taisho", JapaneseEra.TAISHO, null }, - { "Showa", JapaneseEra.SHOWA, null }, - { "Heisei", JapaneseEra.HEISEI, null }, - { "Reiwa", JapaneseEra.of(3), null }, - { "NewEra", null, IllegalArgumentException.class}, }; } @@ -235,13 +192,4 @@ public class TestJapaneseChronology { JapaneseDate date = JAPANESE.dateYearDay(era, yearOfEra, dayOfYear); System.out.printf("No DateTimeException with era=%s, year=%d, dayOfYear=%d%n", era, yearOfEra, dayOfYear); } - - @Test(dataProvider="eraNameData") - public void test_eraName(String eraName, JapaneseEra era, Class expectedEx) { - try { - assertEquals(JapaneseEra.valueOf(eraName), era); - } catch (Exception ex) { - assertTrue(expectedEx.isInstance(ex)); - } - } } diff --git a/ojluni/src/test/java/time/test/java/time/chrono/TestUmmAlQuraChronology.java b/ojluni/src/test/java/time/test/java/time/chrono/TestUmmAlQuraChronology.java index e2f2b7740c..ab61c71e69 100644 --- a/ojluni/src/test/java/time/test/java/time/chrono/TestUmmAlQuraChronology.java +++ b/ojluni/src/test/java/time/test/java/time/chrono/TestUmmAlQuraChronology.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2013, 2019, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -33,7 +33,6 @@ import static org.testng.Assert.assertEquals; import static org.testng.Assert.assertFalse; import static org.testng.Assert.assertTrue; import static org.testng.Assert.fail; -import static tck.java.time.chrono.TCKJapaneseChronology.IS_HEISEI_LATEST; import java.time.DateTimeException; import java.time.DayOfWeek; @@ -73,7 +72,6 @@ import org.testng.annotations.Test; /** * Tests for the Umm alQura chronology and data. * Note: The dates used for testing are just a sample of calendar data. - * @bug 8067800 */ @Test public class TestUmmAlQuraChronology { @@ -550,7 +548,6 @@ public class TestUmmAlQuraChronology { assertFalse(HijrahChronology.INSTANCE.isLeapYear(y), "Out of range leap year"); } - // Date samples to convert HijrahDate to LocalDate and vice versa @DataProvider(name="samples") Object[][] data_samples() { @@ -776,11 +773,8 @@ public class TestUmmAlQuraChronology { {HijrahDate.of(1350,5,15), "Japanese Showa 6-09-28"}, {HijrahDate.of(1434,5,1), "Japanese Heisei 25-03-13"}, {HijrahDate.of(1436,1,1), "Japanese Heisei 26-10-25"}, - {HijrahDate.of(1440,8,25), "Japanese Heisei 31-04-30"}, - // Android-changed: Old Android releases can optionally support the new Japanese era. - {HijrahDate.of(1440,8,26), IS_HEISEI_LATEST ? "Japanese Heisei 31-05-01" : "Japanese Reiwa 1-05-01"}, - {HijrahDate.of(1500,6,12), IS_HEISEI_LATEST ? "Japanese Heisei 89-05-05" : "Japanese Reiwa 59-05-05"}, - {HijrahDate.of(1550,3,11), IS_HEISEI_LATEST ? "Japanese Heisei 137-08-11" : "Japanese Reiwa 107-08-11"}, + {HijrahDate.of(1500,6,12), "Japanese Heisei 89-05-05"}, + {HijrahDate.of(1550,3,11), "Japanese Heisei 137-08-11"}, }; } diff --git a/ojluni/src/test/java/time/test/java/time/format/TestNonIsoFormatter.java b/ojluni/src/test/java/time/test/java/time/format/TestNonIsoFormatter.java index df74377912..6609f2c01a 100644 --- a/ojluni/src/test/java/time/test/java/time/format/TestNonIsoFormatter.java +++ b/ojluni/src/test/java/time/test/java/time/format/TestNonIsoFormatter.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2013, 2019, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -20,17 +20,9 @@ * or visit www.oracle.com if you need additional information or have any * questions. */ - -/* - * - * @test - * @bug 8206120 - */ - package test.java.time.format; import static org.testng.Assert.assertEquals; -import static tck.java.time.chrono.TCKJapaneseChronology.IS_HEISEI_LATEST; import java.time.LocalDate; import java.time.chrono.ChronoLocalDate; @@ -45,7 +37,6 @@ import java.time.format.DateTimeFormatter; import java.time.format.DateTimeFormatterBuilder; import java.time.format.DateTimeParseException; import java.time.format.FormatStyle; -import java.time.format.ResolverStyle; import java.time.format.TextStyle; import java.time.temporal.TemporalAccessor; import java.time.temporal.TemporalQueries; @@ -143,19 +134,6 @@ public class TestNonIsoFormatter { }; } - @DataProvider(name="lenient_eraYear") - Object[][] lenientEraYear() { - return new Object[][] { - // Chronology, lenient era/year, strict era/year - { JAPANESE, "Meiji 123", "Heisei 2" }, - // Android-changed: Eras names have been changed in CLDR data. - // { JAPANESE, "Showa 65", "Heisei 2" } - { JAPANESE, "Shōwa 65", "Heisei 2" }, - // Android-changed: Old Android releases can optionally support the new Japanese era. - { JAPANESE, "Heisei 32", IS_HEISEI_LATEST ? "Heisei 32" : "Reiwa 2" }, - }; - } - @Test(dataProvider="format_data") public void test_formatLocalizedDate(Chronology chrono, Locale formatLocale, Locale numberingLocale, ChronoLocalDate date, String expected) { @@ -194,15 +172,4 @@ public class TestNonIsoFormatter { Chronology cal = ta.query(TemporalQueries.chronology()); assertEquals(cal, chrono); } - - @Test(dataProvider="lenient_eraYear") - public void test_lenientEraYear(Chronology chrono, String lenient, String strict) { - String mdStr = "-01-01"; - DateTimeFormatter dtf = new DateTimeFormatterBuilder() - .appendPattern("GGGG y-M-d") - .toFormatter() - .withChronology(chrono); - DateTimeFormatter dtfLenient = dtf.withResolverStyle(ResolverStyle.LENIENT); - assertEquals(LocalDate.parse(lenient+mdStr, dtfLenient), LocalDate.parse(strict+mdStr, dtf)); - } } |