Fix for J-324 - Replaced ForwardingExecutorService with custom implementation since the class is not present in repackaged (release version of) Guava.

Change-Id: I9007c6b714ccbba64553d2927fa17bd2001062e0
Signed-off-by: Michal Gajdos <[email protected]>

Author: Michal Gajdos

tests/e2e/src/test/java/org/glassfish/jersey/tests/e2e/ExecutorServiceProviderTest.java

@@ -39,11 +39,16 @@
  */
 package org.glassfish.jersey.tests.e2e;
 
+import java.util.Collection;
 import java.util.List;
 import java.util.Set;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 import javax.ws.rs.GET;
@@ -71,7 +76,6 @@
 import static org.junit.Assert.assertEquals;
 
 import jersey.repackaged.com.google.common.collect.Sets;
-import jersey.repackaged.com.google.common.util.concurrent.ForwardingExecutorService;
 import jersey.repackaged.com.google.common.util.concurrent.ThreadFactoryBuilder;
 
 /**
@@ -158,7 +162,7 @@ public void dispose(final ExecutorService executorService) {
             executorService.shutdownNow();
         }
 
-        private class CustomExecutorService extends ForwardingExecutorService {
+        private class CustomExecutorService implements ExecutorService {
 
             private final ExecutorService delegate;
             private final AtomicBoolean isCleanedUp;
@@ -174,21 +178,68 @@ public CustomExecutorService() {
                 executors.add(this);
             }
 
-            @Override
-            protected ExecutorService delegate() {
-                return delegate;
-            }
-
             @Override
             public void shutdown() {
                 tryCleanUp();
-                super.shutdown();
+                delegate.shutdown();
             }
 
             @Override
             public List<Runnable> shutdownNow() {
                 tryCleanUp();
-                return super.shutdownNow();
+                return delegate.shutdownNow();
+            }
+
+            @Override
+            public boolean isShutdown() {
+                return delegate.isShutdown();
+            }
+
+            @Override
+            public boolean isTerminated() {
+                return delegate.isTerminated();
+            }
+
+            @Override
+            public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
+                return delegate.awaitTermination(timeout, unit);
+            }
+
+            @Override
+            public <T> Future<T> submit(Callable<T> task) {
+                return delegate.submit(task);
+            }
+
+            @Override
+            public <T> Future<T> submit(Runnable task, T result) {
+                return delegate.submit(task, result);
+            }
+
+            @Override
+            public Future<?> submit(Runnable task) {
+                return delegate.submit(task);
+            }
+
+            @Override
+            public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException {
+                return delegate.invokeAll(tasks);
+            }
+
+            @Override
+            public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
+                    throws InterruptedException {
+                return delegate.invokeAll(tasks, timeout, unit);
+            }
+
+            @Override
+            public <T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException {
+                return delegate.invokeAny(tasks);
+            }
+
+            @Override
+            public <T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
+                    throws InterruptedException, ExecutionException, TimeoutException {
+                return delegate.invokeAny(tasks, timeout, unit);
             }
 
             private void tryCleanUp() {
@@ -197,6 +248,11 @@ private void tryCleanUp() {
                     executorReleaseCount++;
                 }
             }
+
+            @Override
+            public void execute(Runnable command) {
+                delegate.execute(command);
+            }
         }
     }