Remove unnecessary final local variables and arguments from javax.net.ssl tests

Change-Id: Ie4cbad9335e37f785edab9a76c42c229a1d40f57

4 files changed, 157 insertions, 157 deletions

diff --git a/luni/src/test/java/javax/net/ssl/SSLContextTest.java b/luni/src/test/java/javax/net/ssl/SSLContextTest.java
index 39a59e3..508aaaf 100644
--- a/luni/src/test/java/javax/net/ssl/SSLContextTest.java
+++ b/luni/src/test/java/javax/net/ssl/SSLContextTest.java
@@ -198,14 +198,14 @@ public class SSLContextTest extends TestCase {
         public final InetAddress host;
         public final int port;
 
-        private Helper(final KeyStore keyStore,
-                       final char[] keyStorePassword,
-                       final String publicAlias,
-                       final String privateAlias,
-                       final SSLContext sslContext,
-                       final SSLServerSocket serverSocket,
-                       final InetAddress host,
-                       final int port) {
+        private Helper(KeyStore keyStore,
+                       char[] keyStorePassword,
+                       String publicAlias,
+                       String privateAlias,
+                       SSLContext sslContext,
+                       SSLServerSocket serverSocket,
+                       InetAddress host,
+                       int port) {
             this.keyStore = keyStore;
             this.keyStorePassword = keyStorePassword;
             this.publicAlias = publicAlias;
@@ -218,9 +218,9 @@ public class SSLContextTest extends TestCase {
 
         public static Helper create() {
             try {
-                final char[] keyStorePassword = null;
-                final String publicAlias = "public";
-                final String privateAlias = "private";
+                char[] keyStorePassword = null;
+                String publicAlias = "public";
+                String privateAlias = "private";
                 return create(createKeyStore(keyStorePassword, publicAlias, privateAlias),
                               null,
                               publicAlias,
@@ -232,18 +232,18 @@ public class SSLContextTest extends TestCase {
             }
         }
 
-        public static Helper create(final KeyStore keyStore,
-                                    final char[] keyStorePassword,
-                                    final String publicAlias,
-                                    final String privateAlias) {
+        public static Helper create(KeyStore keyStore,
+                                    char[] keyStorePassword,
+                                    String publicAlias,
+                                    String privateAlias) {
             try {
-                final SSLContext sslContext = createSSLContext(keyStore, keyStorePassword);
+                SSLContext sslContext = createSSLContext(keyStore, keyStorePassword);
 
-                final SSLServerSocket serverSocket = (SSLServerSocket)
+                SSLServerSocket serverSocket = (SSLServerSocket)
                     sslContext.getServerSocketFactory().createServerSocket(0);
-                final InetSocketAddress sa = (InetSocketAddress) serverSocket.getLocalSocketAddress();
-                final InetAddress host = sa.getAddress();
-                final int port = sa.getPort();
+                InetSocketAddress sa = (InetSocketAddress) serverSocket.getLocalSocketAddress();
+                InetAddress host = sa.getAddress();
+                int port = sa.getPort();
 
                 return new Helper(keyStore, keyStorePassword, publicAlias, privateAlias,
                                   sslContext, serverSocket, host, port);
@@ -274,18 +274,18 @@ public class SSLContextTest extends TestCase {
          * org.bouncycastle.jce.provider.test.SigTest
          * org.bouncycastle.jce.provider.test.CertTest
          */
-        public static KeyStore createKeyStore(final char[] keyStorePassword,
+        public static KeyStore createKeyStore(char[] keyStorePassword,
                                               String publicAlias,
                                               String privateAlias)
                 throws Exception {
 
             // 1.) we make the keys
-            final int keysize = 1024;
-            final KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA");
+            int keysize = 1024;
+            KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA");
             kpg.initialize(keysize, new SecureRandom());
-            final KeyPair kp = kpg.generateKeyPair();
-            final RSAPrivateKey privateKey = (RSAPrivateKey)kp.getPrivate();
-            final RSAPublicKey publicKey  = (RSAPublicKey)kp.getPublic();
+            KeyPair kp = kpg.generateKeyPair();
+            RSAPrivateKey privateKey = (RSAPrivateKey)kp.getPrivate();
+            RSAPublicKey publicKey  = (RSAPublicKey)kp.getPublic();
 
             // 2.) use keys to make certficate
 
@@ -295,17 +295,17 @@ public class SSLContextTest extends TestCase {
             // factory specific format. So here we use Bouncy Castle's
             // X509V3CertificateGenerator and related classes.
 
-            final Hashtable attributes = new Hashtable();
+            Hashtable attributes = new Hashtable();
             attributes.put(X509Principal.CN, InetAddress.getLocalHost().getCanonicalHostName());
-            final X509Principal dn = new X509Principal(attributes);
+            X509Principal dn = new X509Principal(attributes);
 
-            final long millisPerDay = 24 * 60 * 60 * 1000;
-            final long now = System.currentTimeMillis();
-            final Date start = new Date(now - millisPerDay);
-            final Date end = new Date(now + millisPerDay);
-            final BigInteger serial = BigInteger.valueOf(1);
+            long millisPerDay = 24 * 60 * 60 * 1000;
+            long now = System.currentTimeMillis();
+            Date start = new Date(now - millisPerDay);
+            Date end = new Date(now + millisPerDay);
+            BigInteger serial = BigInteger.valueOf(1);
 
-            final X509V3CertificateGenerator x509cg = new X509V3CertificateGenerator();
+            X509V3CertificateGenerator x509cg = new X509V3CertificateGenerator();
             x509cg.setSubjectDN(dn);
             x509cg.setIssuerDN(dn);
             x509cg.setNotBefore(start);
@@ -313,12 +313,12 @@ public class SSLContextTest extends TestCase {
             x509cg.setPublicKey(publicKey);
             x509cg.setSignatureAlgorithm("sha1WithRSAEncryption");
             x509cg.setSerialNumber(serial);
-            final X509Certificate x509c = x509cg.generateX509Certificate(privateKey);
-            final X509Certificate[] x509cc = new X509Certificate[] { x509c };
+            X509Certificate x509c = x509cg.generateX509Certificate(privateKey);
+            X509Certificate[] x509cc = new X509Certificate[] { x509c };
 
 
             // 3.) put certificate and private key to make a key store
-            final KeyStore ks = KeyStore.getInstance("BKS");
+            KeyStore ks = KeyStore.getInstance("BKS");
             ks.load(null, null);
             ks.setKeyEntry(privateAlias, privateKey, keyStorePassword, x509cc);
             ks.setCertificateEntry(publicAlias, x509c);
@@ -332,15 +332,15 @@ public class SSLContextTest extends TestCase {
          */
         public static final SSLContext createSSLContext(final KeyStore keyStore, final char[] keyStorePassword)
                 throws Exception {
-            final String kmfa = KeyManagerFactory.getDefaultAlgorithm();
-            final KeyManagerFactory kmf = KeyManagerFactory.getInstance(kmfa);
+            String kmfa = KeyManagerFactory.getDefaultAlgorithm();
+            KeyManagerFactory kmf = KeyManagerFactory.getInstance(kmfa);
             kmf.init(keyStore, keyStorePassword);
 
-            final String tmfa = TrustManagerFactory.getDefaultAlgorithm();
-            final TrustManagerFactory tmf = TrustManagerFactory.getInstance(tmfa);
+            String tmfa = TrustManagerFactory.getDefaultAlgorithm();
+            TrustManagerFactory tmf = TrustManagerFactory.getInstance(tmfa);
             tmf.init(keyStore);
 
-            final SSLContext context = SSLContext.getInstance("TLS");
+            SSLContext context = SSLContext.getInstance("TLS");
             context.init(kmf.getKeyManagers(), tmf.getTrustManagers(), new SecureRandom());
             return context;
         }
diff --git a/luni/src/test/java/javax/net/ssl/SSLSessionContextTest.java b/luni/src/test/java/javax/net/ssl/SSLSessionContextTest.java
index 38848da..4b4ab6a 100644
--- a/luni/src/test/java/javax/net/ssl/SSLSessionContextTest.java
+++ b/luni/src/test/java/javax/net/ssl/SSLSessionContextTest.java
@@ -31,17 +31,17 @@ public class SSLSessionContextTest extends TestCase {
     }
 
     public void test_SSLSessionContext_getIds() {
-        final SSLContextTest.Helper c = SSLContextTest.Helper.create();
+        SSLContextTest.Helper c = SSLContextTest.Helper.create();
         assertSSLSessionContextSize(0, c.sslContext.getClientSessionContext());
         assertSSLSessionContextSize(0, c.sslContext.getServerSessionContext());
 
-        final SSLSocketTest.Helper s = SSLSocketTest.Helper.create_workaround();
+        SSLSocketTest.Helper s = SSLSocketTest.Helper.create_workaround();
         assertSSLSessionContextSize(1, s.c.sslContext.getClientSessionContext());
         assertSSLSessionContextSize(1, s.c.sslContext.getServerSessionContext());
-        final Enumeration clientIds = s.c.sslContext.getClientSessionContext().getIds();
-        final Enumeration serverIds = s.c.sslContext.getServerSessionContext().getIds();
-        final byte[] clientId = (byte[]) clientIds.nextElement();
-        final byte[] serverId = (byte[]) serverIds.nextElement();
+        Enumeration clientIds = s.c.sslContext.getClientSessionContext().getIds();
+        Enumeration serverIds = s.c.sslContext.getServerSessionContext().getIds();
+        byte[] clientId = (byte[]) clientIds.nextElement();
+        byte[] serverId = (byte[]) serverIds.nextElement();
         assertEquals(32, clientId.length);
         assertEquals(32, serverId.length);
         assertEquals(clientId, serverId);
@@ -49,7 +49,7 @@ public class SSLSessionContextTest extends TestCase {
 
     @KnownFailure("Should throw NullPointerException on getSession(null)")
     public void test_SSLSessionContext_getSession() {
-        final SSLContextTest.Helper c = SSLContextTest.Helper.create();
+        SSLContextTest.Helper c = SSLContextTest.Helper.create();
         try {
             c.sslContext.getClientSessionContext().getSession(null);
             fail();
@@ -58,11 +58,11 @@ public class SSLSessionContextTest extends TestCase {
         assertNull(c.sslContext.getClientSessionContext().getSession(new byte[0]));
         assertNull(c.sslContext.getClientSessionContext().getSession(new byte[1]));
 
-        final SSLSocketTest.Helper s = SSLSocketTest.Helper.create_workaround();
-        final SSLSessionContext client = s.c.sslContext.getClientSessionContext();
-        final SSLSessionContext server = s.c.sslContext.getServerSessionContext();
-        final byte[] clientId = (byte[]) client.getIds().nextElement();
-        final byte[] serverId = (byte[]) server.getIds().nextElement();
+        SSLSocketTest.Helper s = SSLSocketTest.Helper.create_workaround();
+        SSLSessionContext client = s.c.sslContext.getClientSessionContext();
+        SSLSessionContext server = s.c.sslContext.getServerSessionContext();
+        byte[] clientId = (byte[]) client.getIds().nextElement();
+        byte[] serverId = (byte[]) server.getIds().nextElement();
         assertNotNull(client.getSession(clientId));
         assertNotNull(server.getSession(serverId));
         assertEquals(clientId, client.getSession(clientId).getId());
@@ -71,18 +71,18 @@ public class SSLSessionContextTest extends TestCase {
 
     @KnownFailure("Should return 0 for unlimited, not 10 entries")
     public void test_SSLSessionContext_getSessionCacheSize() {
-        final SSLContextTest.Helper c = SSLContextTest.Helper.create();
+        SSLContextTest.Helper c = SSLContextTest.Helper.create();
         assertEquals(0, c.sslContext.getClientSessionContext().getSessionCacheSize());
         assertEquals(0, c.sslContext.getServerSessionContext().getSessionCacheSize());
 
-        final SSLSocketTest.Helper s = SSLSocketTest.Helper.create_workaround();
+        SSLSocketTest.Helper s = SSLSocketTest.Helper.create_workaround();
         assertEquals(0, s.c.sslContext.getClientSessionContext().getSessionCacheSize());
         assertEquals(0, s.c.sslContext.getServerSessionContext().getSessionCacheSize());
     }
 
     @KnownFailure("Should return 0 for unlimited, not 10 entries")
     public void test_SSLSessionContext_setSessionCacheSize_basic() {
-        final SSLContextTest.Helper c = SSLContextTest.Helper.create();
+        SSLContextTest.Helper c = SSLContextTest.Helper.create();
         assertBasicSetSessionCacheSizeBehavior(c.sslContext.getClientSessionContext());
         assertBasicSetSessionCacheSizeBehavior(c.sslContext.getServerSessionContext());
     }
@@ -101,15 +101,15 @@ public class SSLSessionContextTest extends TestCase {
     @KnownFailure("Should return 0 for unlimited, not 10 entries")
     public void test_SSLSessionContext_setSessionCacheSize_dynamic() {
 
-        final SSLSocketTest.Helper s = SSLSocketTest.Helper.create_workaround();
-        final SSLSessionContext client = s.c.sslContext.getClientSessionContext();
-        final SSLSessionContext server = s.c.sslContext.getServerSessionContext();
+        SSLSocketTest.Helper s = SSLSocketTest.Helper.create_workaround();
+        SSLSessionContext client = s.c.sslContext.getClientSessionContext();
+        SSLSessionContext server = s.c.sslContext.getServerSessionContext();
         assertEquals(0, client.getSessionCacheSize());
         assertEquals(0, server.getSessionCacheSize());
         assertSSLSessionContextSize(1, client);
         assertSSLSessionContextSize(1, server);
 
-        final LinkedList<String> uniqueCipherSuites
+        LinkedList<String> uniqueCipherSuites
             = new LinkedList(Arrays.asList(s.server.getEnabledCipherSuites()));
         uniqueCipherSuites.remove(s.client.getSession().getCipherSuite());
 
@@ -178,18 +178,18 @@ public class SSLSessionContextTest extends TestCase {
 
     @KnownFailure("Should return 86400 seconds (1 day), not 0 for unlimited")
     public void test_SSLSessionContext_getSessionTimeout() {
-        final SSLContextTest.Helper c = SSLContextTest.Helper.create();
+        SSLContextTest.Helper c = SSLContextTest.Helper.create();
         assertEquals(86400, c.sslContext.getClientSessionContext().getSessionTimeout());
         assertEquals(86400, c.sslContext.getServerSessionContext().getSessionTimeout());
 
-        final SSLSocketTest.Helper s = SSLSocketTest.Helper.create_workaround();
+        SSLSocketTest.Helper s = SSLSocketTest.Helper.create_workaround();
         assertEquals(86400, s.c.sslContext.getClientSessionContext().getSessionTimeout());
         assertEquals(86400, s.c.sslContext.getServerSessionContext().getSessionTimeout());
     }
 
     @KnownFailure("Should return 86400 seconds (1 day), not 0 for unlimited")
     public void test_SSLSessionContext_setSessionTimeout() throws Exception {
-        final SSLContextTest.Helper c = SSLContextTest.Helper.create();
+        SSLContextTest.Helper c = SSLContextTest.Helper.create();
         assertEquals(86400, c.sslContext.getClientSessionContext().getSessionTimeout());
         assertEquals(86400, c.sslContext.getServerSessionContext().getSessionTimeout());
         c.sslContext.getClientSessionContext().setSessionTimeout(0);
@@ -208,7 +208,7 @@ public class SSLSessionContextTest extends TestCase {
         } catch (IllegalArgumentException e) {
         }
 
-        final SSLSocketTest.Helper s = SSLSocketTest.Helper.create_workaround();
+        SSLSocketTest.Helper s = SSLSocketTest.Helper.create_workaround();
         assertSSLSessionContextSize(1, s.c.sslContext.getClientSessionContext());
         assertSSLSessionContextSize(1, s.c.sslContext.getServerSessionContext());
         Thread.sleep(1 * 1000);
diff --git a/luni/src/test/java/javax/net/ssl/SSLSessionTest.java b/luni/src/test/java/javax/net/ssl/SSLSessionTest.java
index bf0e4d6..52ae279 100644
--- a/luni/src/test/java/javax/net/ssl/SSLSessionTest.java
+++ b/luni/src/test/java/javax/net/ssl/SSLSessionTest.java
@@ -46,10 +46,10 @@ public class SSLSessionTest extends TestCase {
          */
         public final SSLSocketTest.Helper s;
 
-        private Helper(final SSLSession invalid,
-                       final SSLSession server,
-                       final SSLSession client,
-                       final SSLSocketTest.Helper s) {
+        private Helper(SSLSession invalid,
+                       SSLSession server,
+                       SSLSession client,
+                       SSLSocketTest.Helper s) {
             this.invalid = invalid;
             this.server = server;
             this.client = client;
@@ -58,10 +58,10 @@ public class SSLSessionTest extends TestCase {
 
         public static final Helper create() {
             try {
-                final SSLSocketFactory sf = (SSLSocketFactory) SSLSocketFactory.getDefault();
-                final SSLSocket ssl = (SSLSocket) sf.createSocket();
-                final SSLSession invalid = ssl.getSession();
-                final SSLSocketTest.Helper s = SSLSocketTest.Helper.create_workaround();
+                SSLSocketFactory sf = (SSLSocketFactory) SSLSocketFactory.getDefault();
+                SSLSocket ssl = (SSLSocket) sf.createSocket();
+                SSLSession invalid = ssl.getSession();
+                SSLSocketTest.Helper s = SSLSocketTest.Helper.create_workaround();
                 return new Helper(invalid, s.server.getSession(), s.client.getSession(), s);
             } catch (Exception e) {
                 throw new RuntimeException(e);
@@ -71,7 +71,7 @@ public class SSLSessionTest extends TestCase {
 
 
     public void test_SSLSocket_Helper_create() {
-        final Helper s = Helper.create();
+        Helper s = Helper.create();
         assertNotNull(s.invalid);
         assertFalse(s.invalid.isValid());
         assertTrue(s.server.isValid());
@@ -79,7 +79,7 @@ public class SSLSessionTest extends TestCase {
     }
 
     public void test_SSLSession_getApplicationBufferSize() {
-        final Helper s = Helper.create();
+        Helper s = Helper.create();
         assertTrue(s.invalid.getApplicationBufferSize() > 0);
         assertTrue(s.server.getApplicationBufferSize() > 0);
         assertTrue(s.client.getApplicationBufferSize() > 0);
@@ -87,7 +87,7 @@ public class SSLSessionTest extends TestCase {
 
     @KnownFailure("Expected SSL_NULL_WITH_NULL_NULL but received TLS_NULL_WITH_NULL_NULL")
     public void test_SSLSession_getCipherSuite() {
-        final Helper s = Helper.create();
+        Helper s = Helper.create();
         assertNotNull(s.invalid.getCipherSuite());
         assertEquals("SSL_NULL_WITH_NULL_NULL", s.invalid.getCipherSuite());
         assertNotNull(s.server.getCipherSuite());
@@ -97,7 +97,7 @@ public class SSLSessionTest extends TestCase {
     }
 
     public void test_SSLSession_getCreationTime() {
-        final Helper s = Helper.create();
+        Helper s = Helper.create();
         assertTrue(s.invalid.getCreationTime() > 0);
         assertTrue(s.server.getCreationTime() > 0);
         assertTrue(s.client.getCreationTime() > 0);
@@ -105,7 +105,7 @@ public class SSLSessionTest extends TestCase {
     }
 
     public void test_SSLSession_getId() {
-        final Helper s = Helper.create();
+        Helper s = Helper.create();
         assertNotNull(s.invalid.getId());
         assertNotNull(s.server.getId());
         assertNotNull(s.client.getId());
@@ -116,7 +116,7 @@ public class SSLSessionTest extends TestCase {
     }
 
     public void test_SSLSession_getLastAccessedTime() {
-        final Helper s = Helper.create();
+        Helper s = Helper.create();
         assertTrue(s.invalid.getLastAccessedTime() > 0);
         assertTrue(s.server.getLastAccessedTime() > 0);
         assertTrue(s.client.getLastAccessedTime() > 0);
@@ -129,7 +129,7 @@ public class SSLSessionTest extends TestCase {
     }
 
     public void test_SSLSession_getLocalCertificates() throws Exception {
-        final Helper s = Helper.create();
+        Helper s = Helper.create();
         assertNull(s.invalid.getLocalCertificates());
         assertNull(s.client.getLocalCertificates());
         assertNotNull(s.server.getLocalCertificates());
@@ -139,26 +139,26 @@ public class SSLSessionTest extends TestCase {
     }
 
     public void test_SSLSession_getLocalPrincipal() throws Exception {
-        final Helper s = Helper.create();
+        Helper s = Helper.create();
         assertNull(s.invalid.getLocalPrincipal());
         assertNull(s.client.getLocalPrincipal());
         assertNotNull(s.server.getLocalPrincipal());
         assertNotNull(s.server.getLocalPrincipal().getName());
-        final X509Certificate x509certificate = (X509Certificate)
+        X509Certificate x509certificate = (X509Certificate)
             s.s.c.keyStore.getCertificate(s.s.c.publicAlias);
         assertEquals(x509certificate.getSubjectDN().getName(),
                      s.server.getLocalPrincipal().getName());
     }
 
     public void test_SSLSession_getPacketBufferSize() {
-        final Helper s = Helper.create();
+        Helper s = Helper.create();
         assertTrue(s.invalid.getPacketBufferSize() > 0);
         assertTrue(s.server.getPacketBufferSize() > 0);
         assertTrue(s.client.getPacketBufferSize() > 0);
     }
 
     public void test_SSLSession_getPeerCertificateChain() throws Exception {
-        final Helper s = Helper.create();
+        Helper s = Helper.create();
         try {
             s.invalid.getPeerCertificateChain();
             fail();
@@ -176,7 +176,7 @@ public class SSLSessionTest extends TestCase {
     }
 
     public void test_SSLSession_getPeerCertificates() throws Exception {
-        final Helper s = Helper.create();
+        Helper s = Helper.create();
         try {
             s.invalid.getPeerCertificates();
             fail();
@@ -194,21 +194,21 @@ public class SSLSessionTest extends TestCase {
     }
 
     public void test_SSLSession_getPeerHost() {
-        final Helper s = Helper.create();
+        Helper s = Helper.create();
         assertNull(s.invalid.getPeerHost());
         assertNotNull(s.server.getPeerHost());
         assertNotNull(s.client.getPeerHost());
     }
 
     public void test_SSLSession_getPeerPort() {
-        final Helper s = Helper.create();
+        Helper s = Helper.create();
         assertEquals(-1, s.invalid.getPeerPort());
         assertTrue(s.server.getPeerPort() > 0);
         assertEquals(s.s.c.port, s.client.getPeerPort());
     }
 
     public void test_SSLSession_getPeerPrincipal() throws Exception {
-        final Helper s = Helper.create();
+        Helper s = Helper.create();
         try {
             s.invalid.getPeerPrincipal();
             fail();
@@ -221,7 +221,7 @@ public class SSLSessionTest extends TestCase {
         }
         assertNotNull(s.client.getPeerPrincipal());
         assertNotNull(s.client.getPeerPrincipal().getName());
-        final X509Certificate x509certificate = (X509Certificate)
+        X509Certificate x509certificate = (X509Certificate)
             s.s.c.keyStore.getCertificate(s.s.c.publicAlias);
         assertEquals(x509certificate.getSubjectDN().getName(),
                      s.client.getPeerPrincipal().getName());
@@ -229,7 +229,7 @@ public class SSLSessionTest extends TestCase {
     }
 
     public void test_SSLSession_getProtocol() {
-        final Helper s = Helper.create();
+        Helper s = Helper.create();
         assertNotNull(s.invalid.getProtocol());
         assertEquals("NONE", s.invalid.getProtocol());
         assertNotNull(s.server.getProtocol());
@@ -239,7 +239,7 @@ public class SSLSessionTest extends TestCase {
     }
 
     public void test_SSLSession_getSessionContext() {
-        final Helper s = Helper.create();
+        Helper s = Helper.create();
         assertNull(s.invalid.getSessionContext());
         assertNotNull(s.server.getSessionContext());
         assertNotNull(s.client.getSessionContext());
@@ -252,7 +252,7 @@ public class SSLSessionTest extends TestCase {
     }
 
     public void test_SSLSession_getValue() {
-        final Helper s = Helper.create();
+        Helper s = Helper.create();
         try {
             s.invalid.getValue(null);
         } catch (IllegalArgumentException e) {
@@ -261,13 +261,13 @@ public class SSLSessionTest extends TestCase {
     }
 
     public void test_SSLSession_getValueNames() {
-        final Helper s = Helper.create();
+        Helper s = Helper.create();
         assertNotNull(s.invalid.getValueNames());
         assertEquals(0, s.invalid.getValueNames().length);
     }
 
     public void test_SSLSession_invalidate() {
-        final Helper s = Helper.create();
+        Helper s = Helper.create();
         assertFalse(s.invalid.isValid());
         s.invalid.invalidate();
         assertFalse(s.invalid.isValid());
@@ -285,16 +285,16 @@ public class SSLSessionTest extends TestCase {
     }
 
     public void test_SSLSession_isValid() {
-        final Helper s = Helper.create();
+        Helper s = Helper.create();
         assertFalse(s.invalid.isValid());
         assertTrue(s.server.isValid());
         assertTrue(s.client.isValid());
     }
 
     public void test_SSLSession_putValue() {
-        final Helper s = Helper.create();
-        final String key = "KEY";
-        final String value = "VALUE";
+        Helper s = Helper.create();
+        String key = "KEY";
+        String value = "VALUE";
         assertNull(s.invalid.getValue(key));
         assertEquals(0, s.invalid.getValueNames().length);
         s.invalid.putValue(key, value);
@@ -304,9 +304,9 @@ public class SSLSessionTest extends TestCase {
     }
 
     public void test_SSLSession_removeValue() {
-        final Helper s = Helper.create();
-        final String key = "KEY";
-        final String value = "VALUE";
+        Helper s = Helper.create();
+        String key = "KEY";
+        String value = "VALUE";
         s.invalid.putValue(key, value);
         assertEquals(1, s.invalid.getValueNames().length);
         assertEquals(key, s.invalid.getValueNames()[0]);
diff --git a/luni/src/test/java/javax/net/ssl/SSLSocketTest.java b/luni/src/test/java/javax/net/ssl/SSLSocketTest.java
index e5ad54d..c6026d9 100644
--- a/luni/src/test/java/javax/net/ssl/SSLSocketTest.java
+++ b/luni/src/test/java/javax/net/ssl/SSLSocketTest.java
@@ -46,25 +46,25 @@ import junit.framework.TestCase;
 public class SSLSocketTest extends TestCase {
 
     public void test_SSLSocket_getSupportedCipherSuites() throws Exception {
-        final SSLSocketFactory sf = (SSLSocketFactory) SSLSocketFactory.getDefault();
-        final SSLSocket ssl = (SSLSocket) sf.createSocket();
-        final String[] cs = ssl.getSupportedCipherSuites();
+        SSLSocketFactory sf = (SSLSocketFactory) SSLSocketFactory.getDefault();
+        SSLSocket ssl = (SSLSocket) sf.createSocket();
+        String[] cs = ssl.getSupportedCipherSuites();
         assertNotNull(cs);
         assertTrue(cs.length != 0);
     }
 
     public void test_SSLSocket_getEnabledCipherSuites() throws Exception {
-        final SSLSocketFactory sf = (SSLSocketFactory) SSLSocketFactory.getDefault();
-        final SSLSocket ssl = (SSLSocket) sf.createSocket();
-        final String[] cs = ssl.getEnabledCipherSuites();
+        SSLSocketFactory sf = (SSLSocketFactory) SSLSocketFactory.getDefault();
+        SSLSocket ssl = (SSLSocket) sf.createSocket();
+        String[] cs = ssl.getEnabledCipherSuites();
         assertNotNull(cs);
         assertTrue(cs.length != 0);
     }
 
     @KnownFailure("Should support disabling all cipher suites")
     public void test_SSLSocket_setEnabledCipherSuites() throws Exception {
-        final SSLSocketFactory sf = (SSLSocketFactory) SSLSocketFactory.getDefault();
-        final SSLSocket ssl = (SSLSocket) sf.createSocket();
+        SSLSocketFactory sf = (SSLSocketFactory) SSLSocketFactory.getDefault();
+        SSLSocket ssl = (SSLSocket) sf.createSocket();
 
         try {
             ssl.setEnabledCipherSuites(null);
@@ -88,25 +88,25 @@ public class SSLSocketTest extends TestCase {
     }
 
     public void test_SSLSocket_getSupportedProtocols() throws Exception {
-        final SSLSocketFactory sf = (SSLSocketFactory) SSLSocketFactory.getDefault();
-        final SSLSocket ssl = (SSLSocket) sf.createSocket();
-        final String[] p = ssl.getSupportedProtocols();
+        SSLSocketFactory sf = (SSLSocketFactory) SSLSocketFactory.getDefault();
+        SSLSocket ssl = (SSLSocket) sf.createSocket();
+        String[] p = ssl.getSupportedProtocols();
         assertNotNull(p);
         assertTrue(p.length != 0);
     }
 
     public void test_SSLSocket_getEnabledProtocols() throws Exception {
-        final SSLSocketFactory sf = (SSLSocketFactory) SSLSocketFactory.getDefault();
-        final SSLSocket ssl = (SSLSocket) sf.createSocket();
-        final String[] p = ssl.getEnabledProtocols();
+        SSLSocketFactory sf = (SSLSocketFactory) SSLSocketFactory.getDefault();
+        SSLSocket ssl = (SSLSocket) sf.createSocket();
+        String[] p = ssl.getEnabledProtocols();
         assertNotNull(p);
         assertTrue(p.length != 0);
     }
 
     @KnownFailure("Should thow IllegalArgumentException not NullPointerException on null enabled protocols argument")
     public void test_SSLSocket_setEnabledProtocols() throws Exception {
-        final SSLSocketFactory sf = (SSLSocketFactory) SSLSocketFactory.getDefault();
-        final SSLSocket ssl = (SSLSocket) sf.createSocket();
+        SSLSocketFactory sf = (SSLSocketFactory) SSLSocketFactory.getDefault();
+        SSLSocket ssl = (SSLSocket) sf.createSocket();
 
         try {
             ssl.setEnabledProtocols(null);
@@ -130,9 +130,9 @@ public class SSLSocketTest extends TestCase {
 
     @KnownFailure("session of unconnected socket should not be valid")
     public void test_SSLSocket_getSession() throws Exception {
-        final SSLSocketFactory sf = (SSLSocketFactory) SSLSocketFactory.getDefault();
-        final SSLSocket ssl = (SSLSocket) sf.createSocket();
-        final SSLSession session = ssl.getSession();
+        SSLSocketFactory sf = (SSLSocketFactory) SSLSocketFactory.getDefault();
+        SSLSocket ssl = (SSLSocket) sf.createSocket();
+        SSLSession session = ssl.getSession();
         assertNotNull(session);
         assertFalse(session.isValid());
     }
@@ -140,7 +140,7 @@ public class SSLSocketTest extends TestCase {
     @KnownFailure("Implementation should not start handshake in ServerSocket.accept")
     public void test_SSLSocket_startHandshake() throws Exception {
         final SSLContextTest.Helper c = SSLContextTest.Helper.create();
-        final SSLSocket client = (SSLSocket) c.sslContext.getSocketFactory().createSocket(c.host, c.port);
+        SSLSocket client = (SSLSocket) c.sslContext.getSocketFactory().createSocket(c.host, c.port);
         if (!SSLContextTest.IS_RI) {
             /*
              * The following hangs in accept in the Dalvik
@@ -158,7 +158,7 @@ public class SSLSocketTest extends TestCase {
             fail();
         }
         final SSLSocket server = (SSLSocket) c.serverSocket.accept();
-        final Thread thread = new Thread(new Runnable () {
+        Thread thread = new Thread(new Runnable () {
             public void run() {
                 try {
                     server.startHandshake();
@@ -195,10 +195,10 @@ public class SSLSocketTest extends TestCase {
     @KnownFailure("local certificates should be null as it should not have been requested by server")
     public void test_SSLSocket_startHandshake_workaround() throws Exception {
         final SSLContextTest.Helper c = SSLContextTest.Helper.create();
-        final Thread thread = new Thread(new Runnable () {
+        Thread thread = new Thread(new Runnable () {
             public void run() {
                 try {
-                    final SSLSocket server = (SSLSocket) c.serverSocket.accept();
+                    SSLSocket server = (SSLSocket) c.serverSocket.accept();
                     server.startHandshake();
                     assertNotNull(server.getSession());
                     try {
@@ -219,7 +219,7 @@ public class SSLSocketTest extends TestCase {
             }
         });
         thread.start();
-        final SSLSocket client = (SSLSocket) c.sslContext.getSocketFactory().createSocket(c.host, c.port);
+        SSLSocket client = (SSLSocket) c.sslContext.getSocketFactory().createSocket(c.host, c.port);
         client.startHandshake();
         assertNotNull(client.getSession());
         assertNull(client.getSession().getLocalCertificates());
@@ -234,7 +234,7 @@ public class SSLSocketTest extends TestCase {
     @KnownFailure("Should throw SSLException on server, not IOException on client")
     public void test_SSLSocket_startHandshake_noKeyStore_workaround() throws Exception {
         final SSLContextTest.Helper c = SSLContextTest.Helper.create(null, null, null, null);
-        final Thread thread = new Thread(new Runnable () {
+        Thread thread = new Thread(new Runnable () {
             public void run() {
                 try {
                     c.serverSocket.accept();
@@ -248,7 +248,7 @@ public class SSLSocketTest extends TestCase {
             }
         });
         thread.start();
-        final SSLSocket client = (SSLSocket) c.sslContext.getSocketFactory().createSocket(c.host, c.port);
+        SSLSocket client = (SSLSocket) c.sslContext.getSocketFactory().createSocket(c.host, c.port);
         if (!SSLContextTest.IS_RI) {
             client.startHandshake();
         }
@@ -261,10 +261,10 @@ public class SSLSocketTest extends TestCase {
     @KnownFailure("local certificates should be null as it should not have been requested by server")
     public void test_SSLSocket_HandshakeCompletedListener_workaround() throws Exception {
         final SSLContextTest.Helper c = SSLContextTest.Helper.create();
-        final Thread thread = new Thread(new Runnable () {
+        Thread thread = new Thread(new Runnable () {
             public void run() {
                 try {
-                    final SSLSocket server = (SSLSocket) c.serverSocket.accept();
+                    SSLSocket server = (SSLSocket) c.serverSocket.accept();
                     server.startHandshake();
                 } catch (RuntimeException e) {
                     throw e;
@@ -276,7 +276,7 @@ public class SSLSocketTest extends TestCase {
         thread.start();
         final SSLSocket client = (SSLSocket) c.sslContext.getSocketFactory().createSocket(c.host, c.port);
         client.addHandshakeCompletedListener(new HandshakeCompletedListener() {
-            public void handshakeCompleted(final HandshakeCompletedEvent event) {
+            public void handshakeCompleted(HandshakeCompletedEvent event) {
                 try {
                     SSLSession session = event.getSession();
                     String cipherSuite = event.getCipherSuite();
@@ -309,7 +309,7 @@ public class SSLSocketTest extends TestCase {
                     assertTrue(Arrays.asList(client.getEnabledCipherSuites()).contains(cipherSuite));
                     assertTrue(Arrays.asList(c.serverSocket.getEnabledCipherSuites()).contains(cipherSuite));
 
-                    final Enumeration e = c.keyStore.aliases();
+                    Enumeration e = c.keyStore.aliases();
                     Certificate certificate = null;
                     Key key = null;
                     while (e.hasMoreElements()) {
@@ -329,7 +329,7 @@ public class SSLSocketTest extends TestCase {
                     assertNotNull(key);
 
                     assertTrue(X509Certificate.class.isAssignableFrom(certificate.getClass()));
-                    final X509Certificate x509certificate = (X509Certificate) certificate;
+                    X509Certificate x509certificate = (X509Certificate) certificate;
 
                     assertNull(localCertificates);
 
@@ -370,10 +370,10 @@ public class SSLSocketTest extends TestCase {
      */
     public void test_SSLSocket_getUseClientMode_workaround() throws Exception {
         final SSLContextTest.Helper c = SSLContextTest.Helper.create();
-        final Thread thread = new Thread(new Runnable () {
+        Thread thread = new Thread(new Runnable () {
             public void run() {
                 try {
-                    final SSLSocket server = (SSLSocket) c.serverSocket.accept();
+                    SSLSocket server = (SSLSocket) c.serverSocket.accept();
                     assertFalse(server.getUseClientMode());
                 } catch (RuntimeException e) {
                     throw e;
@@ -383,7 +383,7 @@ public class SSLSocketTest extends TestCase {
             }
         });
         thread.start();
-        final SSLSocket client = (SSLSocket) c.sslContext.getSocketFactory().createSocket(c.host, c.port);
+        SSLSocket client = (SSLSocket) c.sslContext.getSocketFactory().createSocket(c.host, c.port);
         if (!SSLContextTest.IS_RI) {
             client.startHandshake();
         }
@@ -422,10 +422,10 @@ public class SSLSocketTest extends TestCase {
         final SSLContextTest.Helper c = SSLContextTest.Helper.create();
         final SSLProtocolException[] sslProtocolException = new SSLProtocolException[1];
         final SocketTimeoutException[] socketTimeoutException = new SocketTimeoutException[1];
-        final Thread thread = new Thread(new Runnable () {
+        Thread thread = new Thread(new Runnable () {
             public void run() {
                 try {
-                    final SSLSocket server = (SSLSocket) c.serverSocket.accept();
+                    SSLSocket server = (SSLSocket) c.serverSocket.accept();
                     if (!serverClientMode) {
                         server.setSoTimeout(1 * 1000);
                         if (!SSLContextTest.IS_RI) {
@@ -447,7 +447,7 @@ public class SSLSocketTest extends TestCase {
             }
         });
         thread.start();
-        final SSLSocket client = (SSLSocket) c.sslContext.getSocketFactory().createSocket(c.host, c.port);
+        SSLSocket client = (SSLSocket) c.sslContext.getSocketFactory().createSocket(c.host, c.port);
         if (!clientClientMode) {
             client.setSoTimeout(1 * 1000);
             if (!SSLContextTest.IS_RI) {
@@ -471,10 +471,10 @@ public class SSLSocketTest extends TestCase {
      */
     public void test_SSLSocket_clientAuth_workaround() throws Exception {
         final SSLContextTest.Helper c = SSLContextTest.Helper.create();
-        final Thread thread = new Thread(new Runnable () {
+        Thread thread = new Thread(new Runnable () {
             public void run() {
                 try {
-                    final SSLSocket server = (SSLSocket) c.serverSocket.accept();
+                    SSLSocket server = (SSLSocket) c.serverSocket.accept();
                     assertFalse(server.getWantClientAuth());
                     assertFalse(server.getNeedClientAuth());
 
@@ -503,7 +503,7 @@ public class SSLSocketTest extends TestCase {
             }
         });
         thread.start();
-        final SSLSocket client = (SSLSocket) c.sslContext.getSocketFactory().createSocket(c.host, c.port);
+        SSLSocket client = (SSLSocket) c.sslContext.getSocketFactory().createSocket(c.host, c.port);
         client.startHandshake();
         assertNotNull(client.getSession().getLocalCertificates());
         assertEquals(1, client.getSession().getLocalCertificates().length);
@@ -516,10 +516,10 @@ public class SSLSocketTest extends TestCase {
      */
     public void test_SSLSocket_getEnableSessionCreation_workaround() throws Exception {
         final SSLContextTest.Helper c = SSLContextTest.Helper.create();
-        final Thread thread = new Thread(new Runnable () {
+        Thread thread = new Thread(new Runnable () {
             public void run() {
                 try {
-                    final SSLSocket server = (SSLSocket) c.serverSocket.accept();
+                    SSLSocket server = (SSLSocket) c.serverSocket.accept();
                     assertTrue(server.getEnableSessionCreation());
                 } catch (RuntimeException e) {
                     throw e;
@@ -529,7 +529,7 @@ public class SSLSocketTest extends TestCase {
             }
         });
         thread.start();
-        final SSLSocket client = (SSLSocket) c.sslContext.getSocketFactory().createSocket(c.host, c.port);
+        SSLSocket client = (SSLSocket) c.sslContext.getSocketFactory().createSocket(c.host, c.port);
         assertTrue(client.getEnableSessionCreation());
         if (!SSLContextTest.IS_RI) {
             client.startHandshake();
@@ -543,10 +543,10 @@ public class SSLSocketTest extends TestCase {
     @KnownFailure("Server side session creation disabling does not work, should throw SSLException, not fail")
     public void test_SSLSocket_setEnableSessionCreation_server_workaround() throws Exception {
         final SSLContextTest.Helper c = SSLContextTest.Helper.create();
-        final Thread thread = new Thread(new Runnable () {
+        Thread thread = new Thread(new Runnable () {
             public void run() {
                 try {
-                    final SSLSocket server = (SSLSocket) c.serverSocket.accept();
+                    SSLSocket server = (SSLSocket) c.serverSocket.accept();
                     server.setEnableSessionCreation(false);
                     try {
                         server.startHandshake();
@@ -561,7 +561,7 @@ public class SSLSocketTest extends TestCase {
             }
         });
         thread.start();
-        final SSLSocket client = (SSLSocket) c.sslContext.getSocketFactory().createSocket(c.host, c.port);
+        SSLSocket client = (SSLSocket) c.sslContext.getSocketFactory().createSocket(c.host, c.port);
         try {
             client.startHandshake();
             fail();
@@ -576,10 +576,10 @@ public class SSLSocketTest extends TestCase {
     @KnownFailure("Should throw SSLException on server, not IOException")
     public void test_SSLSocket_setEnableSessionCreation_client_workaround() throws Exception {
         final SSLContextTest.Helper c = SSLContextTest.Helper.create();
-        final Thread thread = new Thread(new Runnable () {
+        Thread thread = new Thread(new Runnable () {
             public void run() {
                 try {
-                    final SSLSocket server = (SSLSocket) c.serverSocket.accept();
+                    SSLSocket server = (SSLSocket) c.serverSocket.accept();
                     try {
                         server.startHandshake();
                         fail();
@@ -593,7 +593,7 @@ public class SSLSocketTest extends TestCase {
             }
         });
         thread.start();
-        final SSLSocket client = (SSLSocket) c.sslContext.getSocketFactory().createSocket(c.host, c.port);
+        SSLSocket client = (SSLSocket) c.sslContext.getSocketFactory().createSocket(c.host, c.port);
         client.setEnableSessionCreation(false);
         try {
             client.startHandshake();
@@ -617,9 +617,9 @@ public class SSLSocketTest extends TestCase {
         public final SSLSocket server;
         public final SSLSocket client;
 
-        private Helper (final SSLContextTest.Helper c,
-                        final SSLSocket server,
-                        final SSLSocket client) {
+        private Helper (SSLContextTest.Helper c,
+                        SSLSocket server,
+                        SSLSocket client) {
             this.c = c;
             this.server = server;
             this.client = client;
@@ -630,8 +630,8 @@ public class SSLSocketTest extends TestCase {
          * be written to non-workaround form when possible
          */
         public static Helper create_workaround () {
-            final SSLContextTest.Helper c = SSLContextTest.Helper.create();
-            final SSLSocket[] sockets = connect_workaround(c, null);
+            SSLContextTest.Helper c = SSLContextTest.Helper.create();
+            SSLSocket[] sockets = connect_workaround(c, null);
             return new Helper(c, sockets[0], sockets[1]);
         }
 
@@ -644,7 +644,7 @@ public class SSLSocketTest extends TestCase {
                                                       String[] clientCipherSuites) {
             try {
                 final SSLSocket[] server = new SSLSocket[1];
-                final Thread thread = new Thread(new Runnable () {
+                Thread thread = new Thread(new Runnable () {
                     public void run() {
                         try {
                             server[0] = (SSLSocket) c.serverSocket.accept();
@@ -657,7 +657,7 @@ public class SSLSocketTest extends TestCase {
                     }
                 });
                 thread.start();
-                final SSLSocket client = (SSLSocket)
+                SSLSocket client = (SSLSocket)
                     c.sslContext.getSocketFactory().createSocket(c.host, c.port);
                 if (clientCipherSuites != null) {
                     client.setEnabledCipherSuites(clientCipherSuites);