From dd303ca9af64bda1a503d9918ec17a61e9b06e6d Mon Sep 17 00:00:00 2001 From: Neil Fuller Date: Wed, 23 Sep 2015 17:01:32 +0100 Subject: Patch for awaitNanos() for coarse-grained clocks If System.nanoTime() returns the same value twice in awaitNanos() then (remaining == initialNanos) will be true but the code will conclude that a (less likely) overflow occurred. Bug: 24284239 (cherry-picked from commit 8fc2ac0fa8eb47ce607f8412e469d4f680b6ef85) Change-Id: I3b9d573ea822e18f4c1849c8ab66071e66274a50 --- .../java/util/concurrent/locks/AbstractQueuedLongSynchronizer.java | 5 ++++- .../java/java/util/concurrent/locks/AbstractQueuedSynchronizer.java | 5 ++++- 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/luni/src/main/java/java/util/concurrent/locks/AbstractQueuedLongSynchronizer.java b/luni/src/main/java/java/util/concurrent/locks/AbstractQueuedLongSynchronizer.java index 47a02a9e4..a74fb2469 100644 --- a/luni/src/main/java/java/util/concurrent/locks/AbstractQueuedLongSynchronizer.java +++ b/luni/src/main/java/java/util/concurrent/locks/AbstractQueuedLongSynchronizer.java @@ -1838,7 +1838,10 @@ public abstract class AbstractQueuedLongSynchronizer if (interruptMode != 0) reportInterruptAfterWait(interruptMode); long remaining = deadline - System.nanoTime(); // avoid overflow - return (remaining < initialNanos) ? remaining : Long.MIN_VALUE; + // BEGIN android-note Changed from < to <= http://b/24284239 + // return (remaining < initialNanos) ? remaining : Long.MIN_VALUE; + return (remaining <= initialNanos) ? remaining : Long.MIN_VALUE; + // END android-note } /** diff --git a/luni/src/main/java/java/util/concurrent/locks/AbstractQueuedSynchronizer.java b/luni/src/main/java/java/util/concurrent/locks/AbstractQueuedSynchronizer.java index bfe88e596..8823b6fe6 100644 --- a/luni/src/main/java/java/util/concurrent/locks/AbstractQueuedSynchronizer.java +++ b/luni/src/main/java/java/util/concurrent/locks/AbstractQueuedSynchronizer.java @@ -2062,7 +2062,10 @@ public abstract class AbstractQueuedSynchronizer if (interruptMode != 0) reportInterruptAfterWait(interruptMode); long remaining = deadline - System.nanoTime(); // avoid overflow - return (remaining < initialNanos) ? remaining : Long.MIN_VALUE; + // BEGIN android-note Changed from < to <= http://b/24284239 + // return (remaining < initialNanos) ? remaining : Long.MIN_VALUE; + return (remaining <= initialNanos) ? remaining : Long.MIN_VALUE; + // END android-note } /** -- cgit v1.2.3 From ef2d585bdcf12e6ba1aa1ded6a5cf80e4a79b568 Mon Sep 17 00:00:00 2001 From: Kenny Root Date: Mon, 14 Sep 2015 03:35:13 -0700 Subject: Add more debugging to the DigestTest This test sometimes fails, but we don't know what the coefficient of variation is on the test results. Add this to the debug output so we can see if there is just some wild swing during testing. Also add a few rounds of warm-up as well. Bug: 24011092 Change-Id: Ic58f106f68eb93976e3f030e2f23e0156fe84be8 (cherry picked from commit 5fe1cd001f38fba460ac0ce5c15b85250e400f25) --- .../bouncycastle/crypto/digests/DigestTest.java | 33 +++++---- .../test/java/tests/util/SummaryStatistics.java | 82 ++++++++++++++++++++++ 2 files changed, 103 insertions(+), 12 deletions(-) create mode 100644 support/src/test/java/tests/util/SummaryStatistics.java diff --git a/luni/src/test/java/com/android/org/bouncycastle/crypto/digests/DigestTest.java b/luni/src/test/java/com/android/org/bouncycastle/crypto/digests/DigestTest.java index 870821416..fce8507d2 100644 --- a/luni/src/test/java/com/android/org/bouncycastle/crypto/digests/DigestTest.java +++ b/luni/src/test/java/com/android/org/bouncycastle/crypto/digests/DigestTest.java @@ -19,6 +19,7 @@ package com.android.org.bouncycastle.crypto.digests; import junit.framework.TestCase; import com.android.org.bouncycastle.crypto.Digest; import com.android.org.bouncycastle.crypto.ExtendedDigest; +import tests.util.SummaryStatistics; /** * Implements unit tests for our JNI wrapper around OpenSSL. We use the @@ -36,6 +37,7 @@ public class DigestTest extends TestCase { * @param newDigest The new digest implementation, provided by OpenSSL */ public void doTestMessageDigest(Digest oldDigest, Digest newDigest) { + final int WARMUP = 10; final int ITERATIONS = 100; byte[] data = new byte[1024]; @@ -54,27 +56,31 @@ public class DigestTest extends TestCase { data[i] = (byte)i; } - long oldTime = 0; - long newTime = 0; + SummaryStatistics oldTime = new SummaryStatistics(); + SummaryStatistics newTime = new SummaryStatistics(); - for (int j = 0; j < ITERATIONS; j++) { - long t0 = System.currentTimeMillis(); + for (int j = 0; j < ITERATIONS + WARMUP; j++) { + long t0 = System.nanoTime(); for (int i = 0; i < 4; i++) { oldDigest.update(data, 0, data.length); } int oldLength = oldDigest.doFinal(oldHash, 0); - long t1 = System.currentTimeMillis(); + long t1 = System.nanoTime(); - oldTime = oldTime + (t1 - t0); + if (j >= WARMUP) { + oldTime.add(t1 - t0); + } - long t2 = System.currentTimeMillis(); + long t2 = System.nanoTime(); for (int i = 0; i < 4; i++) { newDigest.update(data, 0, data.length); } int newLength = newDigest.doFinal(newHash, 0); - long t3 = System.currentTimeMillis(); + long t3 = System.nanoTime(); - newTime = newTime + (t3 - t2); + if (j >= WARMUP) { + newTime.add(t3 - t2); + } assertEquals("Hash sizes must be equal", oldLength, newLength); @@ -83,10 +89,13 @@ public class DigestTest extends TestCase { } } - System.out.println("Time for " + ITERATIONS + " x old hash processing: " + oldTime + " ms"); - System.out.println("Time for " + ITERATIONS + " x new hash processing: " + newTime + " ms"); + System.out.println("Time for " + ITERATIONS + " x old hash processing: " + + oldTime.toString()); + System.out.println("Time for " + ITERATIONS + " x new hash processing: " + + newTime.toString()); - assertTrue("New hash should be faster", newTime < oldTime); + assertTrue("New hash should be faster:\nold=" + oldTime.toString() + "\nnew=" + + newTime.toString(), newTime.mean() < oldTime.mean()); } /** diff --git a/support/src/test/java/tests/util/SummaryStatistics.java b/support/src/test/java/tests/util/SummaryStatistics.java new file mode 100644 index 000000000..4ce0a0409 --- /dev/null +++ b/support/src/test/java/tests/util/SummaryStatistics.java @@ -0,0 +1,82 @@ +/* + * Copyright 2015 The Android Open Source Project + * + * Licensed 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 tests.util; + +public class SummaryStatistics { + /** The number of values seen. */ + private int numValues; + + /** Sum of the values. */ + private double sum; + + /** Sum of the squares of the values added. */ + private double squaresSum; + + /** The previously added value. */ + private double lastValue; + + public SummaryStatistics() { + } + + private double square(double value) { + return value * value; + } + + /** Add a new value to the values seen. */ + public void add(double value) { + sum += value - lastValue; + squaresSum += square(value) - square(lastValue); + numValues++; + lastValue = value; + } + + /** Mean of the values seen. */ + public double mean() { + return sum / numValues; + } + + /** Variance of the values seen. */ + public double var() { + return (squaresSum / numValues) - square(mean()); + } + + /** Standard deviation of the values seen. */ + public double stddev() { + return Math.sqrt(var()); + } + + /** Coefficient of variation of the values seen. */ + public double coeffVar() { + return stddev() / mean(); + } + + public String toString() { + StringBuilder sb = new StringBuilder("SummaryStatistics{"); + sb.append("n="); + sb.append(numValues); + sb.append(",mean="); + sb.append(mean()); + sb.append(",var="); + sb.append(var()); + sb.append(",stddev="); + sb.append(stddev()); + sb.append(",coeffVar="); + sb.append(coeffVar()); + sb.append('}'); + return sb.toString(); + } +} -- cgit v1.2.3 From 36363b0d43f12432837ab936b85973f08e74a299 Mon Sep 17 00:00:00 2001 From: zhulin0910 Date: Thu, 24 Sep 2015 14:21:45 +0800 Subject: Fix time calculation in test_SSLSession_getLastAccessedTime [root cause] Time precision in NativeCrypto SSL_SESSION_get_time is second, ignore millisecond. Then, assertTrue( Math.abs(s.server.getLastAccessedTime() - s.client.getLastAccessedTime()) < 1 * 1000); is not rigorous. [changes] modify diff time of s.server.getLastAccessedTime() and s.client.getLastAccessedTime() <= 1*1000 Bug: https://code.google.com/p/android/issues/detail?id=183898 (cherry picked from commit 3f49882b1d3316e37d8312d707c29261d14ece65) Change-Id: Ib0d5eb512f717f1fd88818eac5bf8ef0e5cbac6b --- luni/src/test/java/libcore/javax/net/ssl/SSLSessionTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/luni/src/test/java/libcore/javax/net/ssl/SSLSessionTest.java b/luni/src/test/java/libcore/javax/net/ssl/SSLSessionTest.java index a434d9468..bc2b626c4 100644 --- a/luni/src/test/java/libcore/javax/net/ssl/SSLSessionTest.java +++ b/luni/src/test/java/libcore/javax/net/ssl/SSLSessionTest.java @@ -99,7 +99,7 @@ public class SSLSessionTest extends TestCase { assertTrue("s.server.getLastAccessedTime()=" + s.server.getLastAccessedTime() + " " + "s.client.getLastAccessedTime()=" + s.client.getLastAccessedTime(), Math.abs(s.server.getLastAccessedTime() - - s.client.getLastAccessedTime()) < 1 * 1000); + - s.client.getLastAccessedTime()) <= 1 * 1000); assertTrue(s.server.getLastAccessedTime() >= s.server.getCreationTime()); assertTrue(s.client.getLastAccessedTime() >= -- cgit v1.2.3 From 161ab7af0434978ad3a9512293a032861a18e16e Mon Sep 17 00:00:00 2001 From: Mathieu Chartier Date: Wed, 2 Dec 2015 13:53:46 -0800 Subject: Change FinalizeTest to use helper function Old way kept the object live in a vreg. Bug: 25851249 (cherry picked from commit cf3d432790a78b7d81da656f9a666f3d1ce4962c) Change-Id: I3cefd317e23c602c6c74dd866f0831161ef10962 (cherry picked from commit 8210c23a598b363e89d6cd32dedeeae673bf9212) --- luni/src/test/java/libcore/java/lang/ref/FinalizeTest.java | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/luni/src/test/java/libcore/java/lang/ref/FinalizeTest.java b/luni/src/test/java/libcore/java/lang/ref/FinalizeTest.java index ef303bda8..d71b5b045 100644 --- a/luni/src/test/java/libcore/java/lang/ref/FinalizeTest.java +++ b/luni/src/test/java/libcore/java/lang/ref/FinalizeTest.java @@ -69,13 +69,18 @@ public final class FinalizeTest extends TestCase { static class X {} - // http://b/issue?id=2136462 - public void testBackFromTheDead() throws Exception { + // Helper function since we do not want a vreg to keep the allocated object live. + // For b/25851249 + private void exceptionInConstructor() { try { new ConstructionFails(); } catch (AssertionError expected) { } + } + // http://b/issue?id=2136462 + public void testBackFromTheDead() throws Exception { + exceptionInConstructor(); FinalizationTester.induceFinalization(); assertTrue("object whose constructor threw was not finalized", ConstructionFails.finalized); } -- cgit v1.2.3 From e7bdc26218b2f0fa323778de1ff1449f4c5f5a52 Mon Sep 17 00:00:00 2001 From: Kenny Root Date: Wed, 6 Jan 2016 10:02:28 -0800 Subject: Check for RFC 5746 TLS extension RFC 5746 allows you to either include a signaling cipher suite or a TLS extension. However, since TLS API has no way to indicate or check that a certain TLS extension is used, we insert it into the cipher suites we see to check against the enabled cipher suites. (cherry picked from commit 81885494e46596c796cdcb5037b91d92915b65a7) Bug: 24602368 Change-Id: I06422b9a90f47bb5ffa10ef614233d856773d336 --- .../test/java/libcore/javax/net/ssl/SSLSocketTest.java | 18 +++++++++++++++++- .../java/libcore/tlswire/handshake/HelloExtension.java | 3 ++- 2 files changed, 19 insertions(+), 2 deletions(-) diff --git a/luni/src/test/java/libcore/javax/net/ssl/SSLSocketTest.java b/luni/src/test/java/libcore/javax/net/ssl/SSLSocketTest.java index bf2d0f895..11dfb3d6d 100644 --- a/luni/src/test/java/libcore/javax/net/ssl/SSLSocketTest.java +++ b/luni/src/test/java/libcore/javax/net/ssl/SSLSocketTest.java @@ -1559,7 +1559,23 @@ public class SSLSocketTest extends TestCase { @Override public void run(SSLSocketFactory sslSocketFactory) throws Exception { ClientHello clientHello = captureTlsHandshakeClientHello(sslSocketFactory); - String[] cipherSuites = new String[clientHello.cipherSuites.size()]; + final String[] cipherSuites; + + // RFC 5746 allows you to send an empty "renegotiation_info" extension *or* + // a special signaling cipher suite. The TLS API has no way to check or + // indicate that a certain TLS extension should be used. + HelloExtension renegotiationInfoExtension = clientHello.findExtensionByType( + HelloExtension.TYPE_RENEGOTIATION_INFO); + if (renegotiationInfoExtension != null && + renegotiationInfoExtension.data.length == 1 && + renegotiationInfoExtension.data[0] == 0) { + cipherSuites = new String[clientHello.cipherSuites.size() + 1]; + cipherSuites[clientHello.cipherSuites.size()] = + StandardNames.CIPHER_SUITE_SECURE_RENEGOTIATION; + } else { + cipherSuites = new String[clientHello.cipherSuites.size()]; + } + for (int i = 0; i < clientHello.cipherSuites.size(); i++) { CipherSuite cipherSuite = clientHello.cipherSuites.get(i); cipherSuites[i] = cipherSuite.getAndroidName(); diff --git a/support/src/test/java/libcore/tlswire/handshake/HelloExtension.java b/support/src/test/java/libcore/tlswire/handshake/HelloExtension.java index 5741072a7..a648cdf5d 100644 --- a/support/src/test/java/libcore/tlswire/handshake/HelloExtension.java +++ b/support/src/test/java/libcore/tlswire/handshake/HelloExtension.java @@ -31,6 +31,7 @@ public class HelloExtension { public static final int TYPE_SERVER_NAME = 0; public static final int TYPE_PADDING = 21; public static final int TYPE_SESSION_TICKET = 35; + public static final int TYPE_RENEGOTIATION_INFO = 65281; private static final Map TYPE_TO_NAME = new HashMap(); static { @@ -60,7 +61,7 @@ public class HelloExtension { TYPE_TO_NAME.put(13172, "next_protocol_negotiation"); TYPE_TO_NAME.put(30031, "Channel ID (old)"); TYPE_TO_NAME.put(30032, "Channel ID (new)"); - TYPE_TO_NAME.put(65281, "renegotiation_info"); + TYPE_TO_NAME.put(TYPE_RENEGOTIATION_INFO, "renegotiation_info"); } public int type; -- cgit v1.2.3