tall sonar:sonar

diff --git a/src/com/dimosr/service/CircuitBreakingServiceCall.java b/src/com/dimosr/service/CircuitBreakingServiceCall.java
index 4296ab9..9dc6786 100644
--- a/src/com/dimosr/service/CircuitBreakingServiceCall.java
+++ b/src/com/dimosr/service/CircuitBreakingServiceCall.java
@@ -41,7 +41,7 @@ class CircuitBreakingServiceCall<REQUEST, RESPONSE> implements ServiceCall<REQUE
             RESPONSE response = serviceCall.call(request);
             circuitBreaker.updateState(CircuitBreaker.RequestResult.SUCCESS);
             return response;
-        } catch(Throwable e) {
+        } catch(Exception e) {
             circuitBreaker.updateState(CircuitBreaker.RequestResult.FAILURE);
             throw e;
         }
@@ -87,17 +87,15 @@ class CircuitBreakingServiceCall<REQUEST, RESPONSE> implements ServiceCall<REQUE
                 halfOpenRequestQueue.addItem(requestResult);
 
                 if (state == CircuitBreakerState.HALF_OPEN) {
-                    if(halfOpenRequestQueue.isFull()) {
-                        if (halfOpenRequestQueue.getOccurences(RequestResult.SUCCESS) >= consecutiveSuccessfulRequestsToClose) {
+                    if(allSamplingRequestsCompleted()) {
+                        if (allSamplingRequestsSuccessful()) {
                             closeCircuit();
                         } else {
                             openCircuit();
                         }
                     }
-                } else if (state == CircuitBreakerState.CLOSED) {
-                    if (closedRequestQueue.getOccurences(RequestResult.FAILURE) >= failingRequestsToOpen) {
+                } else if (state == CircuitBreakerState.CLOSED && moreFailuresThanAcceptable()) {
                         openCircuit();
-                    }
                 }
             }
         }
@@ -106,6 +104,18 @@ class CircuitBreakingServiceCall<REQUEST, RESPONSE> implements ServiceCall<REQUE
             return clock.millis() - lastOpenedTimestamp > openDurationInMilliseconds;
         }
 
+        private boolean moreFailuresThanAcceptable() {
+            return closedRequestQueue.getOccurences(RequestResult.FAILURE) >= failingRequestsToOpen;
+        }
+
+        private boolean allSamplingRequestsCompleted() {
+            return halfOpenRequestQueue.isFull();
+        }
+
+        private boolean allSamplingRequestsSuccessful() {
+            return halfOpenRequestQueue.getOccurences(RequestResult.SUCCESS) >= consecutiveSuccessfulRequestsToClose;
+        }
+
         private void openCircuit() {
             state = CircuitBreakerState.OPEN;
             lastOpenedTimestamp = clock.millis();
diff --git a/src/com/dimosr/service/RetryableServiceCall.java b/src/com/dimosr/service/RetryableServiceCall.java
index 6b40053..7e080c0 100644
--- a/src/com/dimosr/service/RetryableServiceCall.java
+++ b/src/com/dimosr/service/RetryableServiceCall.java
@@ -4,9 +4,11 @@ import com.dimosr.service.core.ServiceCall;
 import com.dimosr.service.exceptions.MaximumRetriesException;
 import com.dimosr.service.exceptions.RetryableException;
 import com.dimosr.service.util.Sleeper;
+import com.google.common.collect.Lists;
 
 import java.time.Duration;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 
 /**
@@ -20,8 +22,7 @@ class RetryableServiceCall<REQUEST, RESPONSE> implements ServiceCall<REQUEST, RE
 
     private final Sleeper sleeper;
 
-    private final List<Class> retryableExceptions = new ArrayList<>();
-    {retryableExceptions.add(RetryableException.class);}
+    private final List<Class> retryableExceptions = Lists.newArrayList(RetryableException.class);
 
     /**
      * A ServiceCall that will be retried, when the underlying serviceCall throws a RetryableException
@@ -68,13 +69,14 @@ class RetryableServiceCall<REQUEST, RESPONSE> implements ServiceCall<REQUEST, RE
         while(retriesMade <= maxRetries) {
             try {
                 return serviceCall.call(request);
-            } catch(Throwable exception) {
+            } catch(Exception exception) {
                 if(isRetryable(exception)) {
                     finalException = exception;
                     try {
                         Duration backoff = retryingPolicy.getRetryBackoff(retriesMade+1);
                         sleeper.sleep(backoff.toMillis());
                     } catch (InterruptedException e) {
+                        Thread.currentThread().interrupt();
                         throw new MaximumRetriesException("ServiceCall interrupted while retrying", e);
                     }
                     retriesMade++;
diff --git a/src/com/dimosr/service/RetryingPolicy.java b/src/com/dimosr/service/RetryingPolicy.java
index ec8a0f3..7a54064 100644
--- a/src/com/dimosr/service/RetryingPolicy.java
+++ b/src/com/dimosr/service/RetryingPolicy.java
@@ -49,7 +49,7 @@ class RetryingPolicy {
                 Duration linearBackoff = backoffInterval.multipliedBy(retry);
                 return linearBackoff;
             case EXPONENTIAL_BACKOFF:
-                Duration exponentialBackoff = backoffInterval.multipliedBy((long) Math.pow(2, retry-1));
+                Duration exponentialBackoff = backoffInterval.multipliedBy((long) Math.pow(2.0, retry-1));
                 return exponentialBackoff;
             default:
                 throw new IllegalArgumentException("Invalid backoff policy: " + backoffPolicy);