all: fix lint

Author: dapengzhang0

alts/src/test/java/io/grpc/alts/HandshakerServiceChannelTest.java

@@ -37,7 +37,7 @@
 public final class HandshakerServiceChannelTest {
   @Rule
   public final GrpcCleanupRule grpcCleanup = new GrpcCleanupRule();
-  private Server server = grpcCleanup.register(
+  private final Server server = grpcCleanup.register(
       ServerBuilder.forPort(0)
         .addService(new SimpleServiceGrpc.SimpleServiceImplBase() {
           @Override

alts/src/test/java/io/grpc/alts/internal/TsiFrameHandlerTest.java

@@ -87,7 +87,8 @@ public void writeAndFlush_shouldBeIgnoredAfterClose() throws InterruptedExceptio
     try {
       channel.checkException();
     } catch (Exception e) {
-      throw new AssertionError("Any attempt after close should be ignored without out exception");
+      throw new AssertionError(
+          "Any attempt after close should be ignored without out exception", e);
     }
   }
 

core/src/main/java/io/grpc/Codec.java

@@ -32,7 +32,7 @@ public interface Codec extends Compressor, Decompressor {
    * A gzip compressor and decompressor.  In the future this will likely support other
    * compression methods, such as compression level.
    */
-  public static final class Gzip implements Codec {
+  final class Gzip implements Codec {
     @Override
     public String getMessageEncoding() {
       return "gzip";
@@ -53,15 +53,15 @@ public InputStream decompress(InputStream is) throws IOException {
    * The "identity", or "none" codec.  This codec is special in that it can be used to explicitly
    * disable Call compression on a Channel that by default compresses.
    */
-  public static final class Identity implements Codec {
+  final class Identity implements Codec {
     /**
      * Special sentinel codec indicating that no compression should be used.  Users should use
      * reference equality to see if compression is disabled.
      */
     public static final Codec NONE = new Identity();
 
     @Override
-    public InputStream decompress(InputStream is) throws IOException {
+    public InputStream decompress(InputStream is) {
       return is;
     }
 
@@ -71,7 +71,7 @@ public String getMessageEncoding() {
     }
 
     @Override
-    public OutputStream compress(OutputStream os) throws IOException {
+    public OutputStream compress(OutputStream os) {
       return os;
     }
 

examples/src/test/java/io/grpc/examples/authentication/AuthClientTest.java

@@ -16,15 +16,25 @@
 
 package io.grpc.examples.authentication;
 
-import io.grpc.*;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import io.grpc.Metadata;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptors;
 import io.grpc.examples.helloworld.GreeterGrpc;
 import io.grpc.examples.helloworld.HelloReply;
 import io.grpc.examples.helloworld.HelloRequest;
 import io.grpc.inprocess.InProcessChannelBuilder;
 import io.grpc.inprocess.InProcessServerBuilder;
 import io.grpc.ServerCall.Listener;
 import io.grpc.ServerInterceptor;
+import io.grpc.stub.StreamObserver;
 import io.grpc.testing.GrpcCleanupRule;
+import java.io.IOException;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
@@ -33,13 +43,6 @@
 import org.mockito.ArgumentCaptor;
 import org.mockito.Matchers;
 
-import java.io.IOException;
-
-import static org.junit.Assert.assertEquals;
-import static org.mockito.AdditionalAnswers.delegatesTo;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-
 /**
  * Unit tests for {@link AuthClient} testing the default and non-default tokens
  *
@@ -55,13 +58,13 @@ public class AuthClientTest {
   public final GrpcCleanupRule grpcCleanup = new GrpcCleanupRule();
 
   private final ServerInterceptor mockServerInterceptor = mock(ServerInterceptor.class, delegatesTo(
-          new ServerInterceptor() {
-            @Override
-            public <ReqT, RespT> Listener<ReqT> interceptCall(
-                    ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next) {
-              return next.startCall(call, headers);
-            }
-          }));
+      new ServerInterceptor() {
+        @Override
+        public <ReqT, RespT> Listener<ReqT> interceptCall(
+            ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next) {
+          return next.startCall(call, headers);
+        }
+      }));
 
   private AuthClient client;
 
@@ -73,64 +76,63 @@ public void setUp() throws IOException {
 
     // Create a server, add service, start, and register for automatic graceful shutdown.
     grpcCleanup.register(InProcessServerBuilder.forName(serverName).directExecutor()
-            .addService(ServerInterceptors.intercept(new GreeterGrpc.GreeterImplBase() {
+        .addService(ServerInterceptors.intercept(
+            new GreeterGrpc.GreeterImplBase() {
 
               @Override
-              public void sayHello(io.grpc.examples.helloworld.HelloRequest request,
-                                   io.grpc.stub.StreamObserver<io.grpc.examples.helloworld.HelloReply> responseObserver) {
-                HelloReply reply = HelloReply.newBuilder().setMessage("AuthClientTest user=" + request.getName()).build();
+              public void sayHello(
+                  HelloRequest request, StreamObserver<HelloReply> responseObserver) {
+                HelloReply reply = HelloReply.newBuilder()
+                    .setMessage("AuthClientTest user=" + request.getName()).build();
                 responseObserver.onNext(reply);
                 responseObserver.onCompleted();
               }
-            }, mockServerInterceptor))
-            .build().start());
+            },
+            mockServerInterceptor))
+        .build().start());
 
     // Create an AuthClient using the in-process channel;
     client = new AuthClient(InProcessChannelBuilder.forName(serverName).directExecutor());
   }
 
   /**
-   * Test default JWT token used
-   *
-   * @throws Exception
+   * Test default JWT token used.
    */
   @Test
-  public void defaultTokenDeliveredToServer() throws Exception {
+  public void defaultTokenDeliveredToServer() {
     ArgumentCaptor<Metadata> metadataCaptor = ArgumentCaptor.forClass(Metadata.class);
     ArgumentCaptor<HelloRequest> requestCaptor = ArgumentCaptor.forClass(HelloRequest.class);
 
     String retVal = client.greet("default token test");
 
     verify(mockServerInterceptor).interceptCall(
-            Matchers.<ServerCall<HelloRequest, HelloReply>>any(),
-            metadataCaptor.capture(),
-            Matchers.<ServerCallHandler<HelloRequest, HelloReply>>any());
+        Matchers.<ServerCall<HelloRequest, HelloReply>>any(),
+        metadataCaptor.capture(),
+        Matchers.<ServerCallHandler<HelloRequest, HelloReply>>any());
     assertEquals(
-            "my-default-token",
-            metadataCaptor.getValue().get(Constant.JWT_METADATA_KEY));
+        "my-default-token",
+        metadataCaptor.getValue().get(Constant.JWT_METADATA_KEY));
     assertEquals("AuthClientTest user=default token test", retVal);
   }
 
   /**
-   * Test non-default JWT token used
-   *
-   * @throws Exception
+   * Test non-default JWT token used.
    */
   @Test
-  public void nonDefaultTokenDeliveredToServer() throws Exception {
+  public void nonDefaultTokenDeliveredToServer() {
     ArgumentCaptor<Metadata> metadataCaptor = ArgumentCaptor.forClass(Metadata.class);
     ArgumentCaptor<HelloRequest> requestCaptor = ArgumentCaptor.forClass(HelloRequest.class);
 
     client.setTokenValue("non-default-token");
     String retVal = client.greet("non default token test");
 
     verify(mockServerInterceptor).interceptCall(
-            Matchers.<ServerCall<HelloRequest, HelloReply>>any(),
-            metadataCaptor.capture(),
-            Matchers.<ServerCallHandler<HelloRequest, HelloReply>>any());
+        Matchers.<ServerCall<HelloRequest, HelloReply>>any(),
+        metadataCaptor.capture(),
+        Matchers.<ServerCallHandler<HelloRequest, HelloReply>>any());
     assertEquals(
-            "non-default-token",
-            metadataCaptor.getValue().get(Constant.JWT_METADATA_KEY));
+        "non-default-token",
+        metadataCaptor.getValue().get(Constant.JWT_METADATA_KEY));
     assertEquals("AuthClientTest user=non default token test", retVal);
   }
 }

okhttp/src/main/java/io/grpc/okhttp/OkHttpClientTransport.java

@@ -182,7 +182,7 @@ private static Map<ErrorCode, Status> buildErrorCodeToStatusMap() {
   private int maxConcurrentStreams = 0;
   @SuppressWarnings("JdkObsolete") // Usage is bursty; want low memory usage when empty
   @GuardedBy("lock")
-  private LinkedList<OkHttpClientStream> pendingStreams = new LinkedList<>();
+  private final LinkedList<OkHttpClientStream> pendingStreams = new LinkedList<>();
   private final ConnectionSpec connectionSpec;
   private FrameWriter testFrameWriter;
   private ScheduledExecutorService scheduler;

okhttp/src/test/java/io/grpc/okhttp/AsyncSinkTest.java

@@ -51,11 +51,11 @@
 @RunWith(JUnit4.class)
 public class AsyncSinkTest {
 
-  private Socket socket = mock(Socket.class);
-  private Sink mockedSink = mock(VoidSink.class, CALLS_REAL_METHODS);
-  private QueueingExecutor queueingExecutor = new QueueingExecutor();
-  private TransportExceptionHandler exceptionHandler = mock(TransportExceptionHandler.class);
-  private AsyncSink sink =
+  private final Socket socket = mock(Socket.class);
+  private final Sink mockedSink = mock(VoidSink.class, CALLS_REAL_METHODS);
+  private final QueueingExecutor queueingExecutor = new QueueingExecutor();
+  private final TransportExceptionHandler exceptionHandler = mock(TransportExceptionHandler.class);
+  private final AsyncSink sink =
       AsyncSink.sink(new SerializingExecutor(queueingExecutor), exceptionHandler);
 
   @Before
@@ -236,7 +236,7 @@ public void write_callSinkIfBufferIsLargerThanSegmentSize() throws IOException {
     // flush should write everything.
     sink.flush();
     queueingExecutor.runAll();
-    verify(mockedSink).write(any(Buffer.class),eq((long) payloadSize - completeSegmentBytes));
+    verify(mockedSink).write(any(Buffer.class), eq((long) payloadSize - completeSegmentBytes));
     verify(mockedSink).flush();
   }
 

okhttp/src/test/java/io/grpc/okhttp/ExceptionHandlingFrameWriterTest.java

@@ -35,10 +35,10 @@
 @RunWith(JUnit4.class)
 public class ExceptionHandlingFrameWriterTest {
 
-  private FrameWriter mockedFrameWriter = mock(FrameWriter.class);
-  private TransportExceptionHandler transportExceptionHandler =
+  private final FrameWriter mockedFrameWriter = mock(FrameWriter.class);
+  private final TransportExceptionHandler transportExceptionHandler =
       mock(TransportExceptionHandler.class);
-  private ExceptionHandlingFrameWriter exceptionHandlingFrameWriter =
+  private final ExceptionHandlingFrameWriter exceptionHandlingFrameWriter =
       new ExceptionHandlingFrameWriter(transportExceptionHandler, mockedFrameWriter);
 
   @Test

okhttp/src/test/java/io/grpc/okhttp/OkHttpClientTransportTest.java

@@ -2117,7 +2117,7 @@ private static TransportStats getTransportStats(InternalInstrumented<SocketStats
   private static class MockFrameWriter implements FrameWriter {
 
     private Socket socket;
-    private Queue<Buffer> capturedBuffer;
+    private final Queue<Buffer> capturedBuffer;
 
     public MockFrameWriter(Socket socket, Queue<Buffer> capturedBuffer) {
       // Sets a socket to close. Some tests assumes that FrameWriter will close underlying sink

protobuf-lite/src/main/java/io/grpc/protobuf/lite/ProtoInputStream.java

@@ -61,7 +61,7 @@ public int drainTo(OutputStream target) throws IOException {
   }
 
   @Override
-  public int read() throws IOException {
+  public int read() {
     if (message != null) {
       partial = new ByteArrayInputStream(message.toByteArray());
       message = null;