killbill-memoizeit

invoice: reformat code No functional change besides fixing

6/13/2012 2:42:24 PM

Changes

invoice/pom.xml 7(+4 -3)

Details

invoice/pom.xml 7(+4 -3)

diff --git a/invoice/pom.xml b/invoice/pom.xml
index d2ee9d0..b3528fe 100644
--- a/invoice/pom.xml
+++ b/invoice/pom.xml
@@ -8,7 +8,8 @@
     OR CONDITIONS OF ANY KIND, either express or implied. See the ~ License for 
     the specific language governing permissions and limitations ~ under the License. -->
 
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <parent>
         <groupId>com.ning.billing</groupId>
@@ -33,7 +34,7 @@
             <groupId>com.ning.billing</groupId>
             <artifactId>killbill-util</artifactId>
         </dependency>
-         <dependency>
+        <dependency>
             <groupId>org.jdbi</groupId>
             <artifactId>jdbi</artifactId>
         </dependency>
@@ -67,7 +68,7 @@
             <groupId>org.skife.config</groupId>
             <artifactId>config-magic</artifactId>
         </dependency>
-       <!-- TEST SCOPE -->
+        <!-- TEST SCOPE -->
         <dependency>
             <groupId>com.ning.billing</groupId>
             <artifactId>killbill-util</artifactId>
diff --git a/invoice/src/main/java/com/ning/billing/invoice/api/DefaultInvoiceService.java b/invoice/src/main/java/com/ning/billing/invoice/api/DefaultInvoiceService.java
index 9b80d9c..f0c3d0c 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/api/DefaultInvoiceService.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/api/DefaultInvoiceService.java
@@ -33,7 +33,7 @@ public class DefaultInvoiceService implements InvoiceService {
     private final Bus eventBus;
 
     @Inject
-    public DefaultInvoiceService(InvoiceListener invoiceListener, Bus eventBus, NextBillingDateNotifier dateNotifier) {
+    public DefaultInvoiceService(final InvoiceListener invoiceListener, final Bus eventBus, final NextBillingDateNotifier dateNotifier) {
         this.invoiceListener = invoiceListener;
         this.eventBus = eventBus;
         this.dateNotifier = dateNotifier;
diff --git a/invoice/src/main/java/com/ning/billing/invoice/api/invoice/DefaultInvoicePaymentApi.java b/invoice/src/main/java/com/ning/billing/invoice/api/invoice/DefaultInvoicePaymentApi.java
index 2283a39..fca4789 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/api/invoice/DefaultInvoicePaymentApi.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/api/invoice/DefaultInvoicePaymentApi.java
@@ -21,17 +21,17 @@ import java.math.BigDecimal;
 import java.util.List;
 import java.util.UUID;
 
-import com.ning.billing.invoice.api.InvoiceApiException;
-import com.ning.billing.util.callcontext.CallContext;
 import org.joda.time.DateTime;
 
 import com.google.inject.Inject;
 import com.ning.billing.catalog.api.Currency;
 import com.ning.billing.invoice.api.Invoice;
+import com.ning.billing.invoice.api.InvoiceApiException;
 import com.ning.billing.invoice.api.InvoicePayment;
 import com.ning.billing.invoice.api.InvoicePaymentApi;
 import com.ning.billing.invoice.dao.InvoiceDao;
 import com.ning.billing.invoice.model.DefaultInvoicePayment;
+import com.ning.billing.util.callcontext.CallContext;
 
 public class DefaultInvoicePaymentApi implements InvoicePaymentApi {
     private final InvoiceDao dao;
@@ -39,81 +39,81 @@ public class DefaultInvoicePaymentApi implements InvoicePaymentApi {
     @Inject
     public DefaultInvoicePaymentApi(final InvoiceDao dao) {
         this.dao = dao;
-     }
+    }
 
     @Override
-    public void notifyOfPaymentAttempt(InvoicePayment invoicePayment, CallContext context) {
+    public void notifyOfPaymentAttempt(final InvoicePayment invoicePayment, final CallContext context) {
         dao.notifyOfPaymentAttempt(invoicePayment, context);
     }
 
-	@Override
-	public List<Invoice> getAllInvoicesByAccount(UUID accountId) {
-		return dao.getAllInvoicesByAccount(accountId);
-	}
- 
+    @Override
+    public List<Invoice> getAllInvoicesByAccount(final UUID accountId) {
+        return dao.getAllInvoicesByAccount(accountId);
+    }
+
     @Override
     public Invoice getInvoice(final UUID invoiceId) {
         return dao.getById(invoiceId);
     }
 
     @Override
-    public Invoice getInvoiceForPaymentAttemptId(UUID paymentAttemptId) {
-        UUID invoiceIdStr = dao.getInvoiceIdByPaymentAttemptId(paymentAttemptId);
+    public Invoice getInvoiceForPaymentAttemptId(final UUID paymentAttemptId) {
+        final UUID invoiceIdStr = dao.getInvoiceIdByPaymentAttemptId(paymentAttemptId);
         return invoiceIdStr == null ? null : dao.getById(invoiceIdStr);
     }
 
     @Override
-    public InvoicePayment getInvoicePayment(UUID paymentAttemptId) {
+    public InvoicePayment getInvoicePayment(final UUID paymentAttemptId) {
         return dao.getInvoicePayment(paymentAttemptId);
     }
 
     @Override
-    public void notifyOfPaymentAttempt(UUID invoiceId, BigDecimal amount, Currency currency, UUID paymentAttemptId, DateTime paymentAttemptDate, CallContext context) {
-        InvoicePayment invoicePayment = new DefaultInvoicePayment(paymentAttemptId, invoiceId, paymentAttemptDate, amount, currency);
+    public void notifyOfPaymentAttempt(final UUID invoiceId, final BigDecimal amount, final Currency currency, final UUID paymentAttemptId, final DateTime paymentAttemptDate, final CallContext context) {
+        final InvoicePayment invoicePayment = new DefaultInvoicePayment(paymentAttemptId, invoiceId, paymentAttemptDate, amount, currency);
         dao.notifyOfPaymentAttempt(invoicePayment, context);
     }
 
     @Override
-    public void notifyOfPaymentAttempt(UUID invoiceId, UUID paymentAttemptId, DateTime paymentAttemptDate, CallContext context) {
-        InvoicePayment invoicePayment = new DefaultInvoicePayment(paymentAttemptId, invoiceId, paymentAttemptDate);
+    public void notifyOfPaymentAttempt(final UUID invoiceId, final UUID paymentAttemptId, final DateTime paymentAttemptDate, final CallContext context) {
+        final InvoicePayment invoicePayment = new DefaultInvoicePayment(paymentAttemptId, invoiceId, paymentAttemptDate);
         dao.notifyOfPaymentAttempt(invoicePayment, context);
     }
 
     @Override
-    public void processChargeback(UUID invoicePaymentId, BigDecimal amount, CallContext context) throws InvoiceApiException {
+    public void processChargeback(final UUID invoicePaymentId, final BigDecimal amount, final CallContext context) throws InvoiceApiException {
         dao.postChargeback(invoicePaymentId, amount, context);
     }
 
     @Override
-    public void processChargeback(UUID invoicePaymentId, CallContext context) throws InvoiceApiException {
+    public void processChargeback(final UUID invoicePaymentId, final CallContext context) throws InvoiceApiException {
         // use the invoicePaymentId to get the amount remaining on the payment
         // (preventing charge backs totalling more than the payment)
-        BigDecimal amount = dao.getRemainingAmountPaid(invoicePaymentId);
+        final BigDecimal amount = dao.getRemainingAmountPaid(invoicePaymentId);
         processChargeback(invoicePaymentId, amount, context);
     }
 
     @Override
-    public BigDecimal getRemainingAmountPaid(UUID invoicePaymentId) {
+    public BigDecimal getRemainingAmountPaid(final UUID invoicePaymentId) {
         return dao.getRemainingAmountPaid(invoicePaymentId);
     }
 
     @Override
-    public List<InvoicePayment> getChargebacksByAccountId(UUID accountId) {
+    public List<InvoicePayment> getChargebacksByAccountId(final UUID accountId) {
         return dao.getChargebacksByAccountId(accountId);
     }
 
     @Override
-    public List<InvoicePayment> getChargebacksByPaymentAttemptId(UUID paymentAttemptId) {
+    public List<InvoicePayment> getChargebacksByPaymentAttemptId(final UUID paymentAttemptId) {
         return dao.getChargebacksByPaymentAttemptId(paymentAttemptId);
     }
 
     @Override
-    public InvoicePayment getChargebackById(UUID chargebackId) throws InvoiceApiException {
+    public InvoicePayment getChargebackById(final UUID chargebackId) throws InvoiceApiException {
         return dao.getChargebackById(chargebackId);
     }
 
     @Override
-    public UUID getAccountIdFromInvoicePaymentId(UUID invoicePaymentId) throws InvoiceApiException {
+    public UUID getAccountIdFromInvoicePaymentId(final UUID invoicePaymentId) throws InvoiceApiException {
         return dao.getAccountIdFromInvoicePaymentId(invoicePaymentId);
     }
-}
\ No newline at end of file
+}
diff --git a/invoice/src/main/java/com/ning/billing/invoice/api/migration/DefaultInvoiceMigrationApi.java b/invoice/src/main/java/com/ning/billing/invoice/api/migration/DefaultInvoiceMigrationApi.java
index bea87a7..9e9b95c 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/api/migration/DefaultInvoiceMigrationApi.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/api/migration/DefaultInvoiceMigrationApi.java
@@ -19,10 +19,6 @@ package com.ning.billing.invoice.api.migration;
 import java.math.BigDecimal;
 import java.util.UUID;
 
-import com.ning.billing.util.callcontext.CallContext;
-import com.ning.billing.util.callcontext.CallOrigin;
-import com.ning.billing.util.callcontext.UserType;
-import com.ning.billing.util.callcontext.DefaultCallContextFactory;
 import org.joda.time.DateTime;
 
 import com.google.inject.Inject;
@@ -32,26 +28,30 @@ import com.ning.billing.invoice.api.InvoiceItem;
 import com.ning.billing.invoice.api.InvoiceMigrationApi;
 import com.ning.billing.invoice.dao.DefaultInvoiceDao;
 import com.ning.billing.invoice.model.MigrationInvoiceItem;
+import com.ning.billing.util.callcontext.CallContext;
+import com.ning.billing.util.callcontext.CallOrigin;
+import com.ning.billing.util.callcontext.DefaultCallContextFactory;
+import com.ning.billing.util.callcontext.UserType;
 import com.ning.billing.util.clock.Clock;
 
 public class DefaultInvoiceMigrationApi implements InvoiceMigrationApi {
-	
-	private DefaultInvoiceDao dao;
-	private Clock clock;
-
-	@Inject
-	public DefaultInvoiceMigrationApi(DefaultInvoiceDao dao, Clock clock) {
-		this.dao = dao;
-		this.clock = clock;
-	}
-
-	@Override
-	public UUID createMigrationInvoice(UUID accountId, DateTime targetDate, BigDecimal balance, Currency currency) {
-        CallContext context = new DefaultCallContextFactory(clock).createMigrationCallContext("Migration", CallOrigin.INTERNAL, UserType.MIGRATION, clock.getUTCNow(), clock.getUTCNow());
-		Invoice migrationInvoice = new MigrationInvoice(accountId, clock.getUTCNow(), targetDate, currency);
-		InvoiceItem migrationInvoiceItem = new MigrationInvoiceItem(migrationInvoice.getId(), accountId, targetDate, balance, currency );
-		migrationInvoice.addInvoiceItem(migrationInvoiceItem);
-		dao.create(migrationInvoice, context);
-		return migrationInvoice.getId();
-	}
+
+    private final DefaultInvoiceDao dao;
+    private final Clock clock;
+
+    @Inject
+    public DefaultInvoiceMigrationApi(final DefaultInvoiceDao dao, final Clock clock) {
+        this.dao = dao;
+        this.clock = clock;
+    }
+
+    @Override
+    public UUID createMigrationInvoice(final UUID accountId, final DateTime targetDate, final BigDecimal balance, final Currency currency) {
+        final CallContext context = new DefaultCallContextFactory(clock).createMigrationCallContext("Migration", CallOrigin.INTERNAL, UserType.MIGRATION, clock.getUTCNow(), clock.getUTCNow());
+        final Invoice migrationInvoice = new MigrationInvoice(accountId, clock.getUTCNow(), targetDate, currency);
+        final InvoiceItem migrationInvoiceItem = new MigrationInvoiceItem(migrationInvoice.getId(), accountId, targetDate, balance, currency);
+        migrationInvoice.addInvoiceItem(migrationInvoiceItem);
+        dao.create(migrationInvoice, context);
+        return migrationInvoice.getId();
+    }
 }
diff --git a/invoice/src/main/java/com/ning/billing/invoice/api/migration/MigrationInvoice.java b/invoice/src/main/java/com/ning/billing/invoice/api/migration/MigrationInvoice.java
index 6627982..a23bd01 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/api/migration/MigrationInvoice.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/api/migration/MigrationInvoice.java
@@ -16,14 +16,15 @@
 
 package com.ning.billing.invoice.api.migration;
 
-import com.ning.billing.catalog.api.Currency;
-import com.ning.billing.invoice.model.DefaultInvoice;
+import java.util.UUID;
+
 import org.joda.time.DateTime;
 
-import java.util.UUID;
+import com.ning.billing.catalog.api.Currency;
+import com.ning.billing.invoice.model.DefaultInvoice;
 
 public class MigrationInvoice extends DefaultInvoice {
-    public MigrationInvoice(UUID accountId, DateTime invoiceDate, DateTime targetDate, Currency currency) {
+    public MigrationInvoice(final UUID accountId, final DateTime invoiceDate, final DateTime targetDate, final Currency currency) {
         super(UUID.randomUUID(), accountId, null, invoiceDate, targetDate, currency, true);
     }
 }
diff --git a/invoice/src/main/java/com/ning/billing/invoice/api/test/DefaultInvoiceTestApi.java b/invoice/src/main/java/com/ning/billing/invoice/api/test/DefaultInvoiceTestApi.java
index ec0ca88..5c17e3d 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/api/test/DefaultInvoiceTestApi.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/api/test/DefaultInvoiceTestApi.java
@@ -25,7 +25,7 @@ public class DefaultInvoiceTestApi implements InvoiceTestApi {
     private final InvoiceDao invoiceDao;
 
     @Inject
-    public DefaultInvoiceTestApi(InvoiceDao invoiceDao) {
+    public DefaultInvoiceTestApi(final InvoiceDao invoiceDao) {
         this.invoiceDao = invoiceDao;
     }
 
diff --git a/invoice/src/main/java/com/ning/billing/invoice/api/user/DefaultEmptyInvoiceEvent.java b/invoice/src/main/java/com/ning/billing/invoice/api/user/DefaultEmptyInvoiceEvent.java
index 97b32ae..60e9014 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/api/user/DefaultEmptyInvoiceEvent.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/api/user/DefaultEmptyInvoiceEvent.java
@@ -18,22 +18,22 @@ package com.ning.billing.invoice.api.user;
 
 import java.util.UUID;
 
+import org.joda.time.DateTime;
+
 import com.fasterxml.jackson.annotation.JsonCreator;
 import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.fasterxml.jackson.annotation.JsonProperty;
-import org.joda.time.DateTime;
-
 import com.ning.billing.invoice.api.EmptyInvoiceEvent;
 
 public class DefaultEmptyInvoiceEvent implements EmptyInvoiceEvent {
     private final UUID accountId;
     private final DateTime processingDate;
     private final UUID userToken;
-    
+
     @JsonCreator
     public DefaultEmptyInvoiceEvent(@JsonProperty("accountId") final UUID accountId,
-            @JsonProperty("processingDate") final DateTime processingDate,
-            @JsonProperty("userToken") final UUID userToken) {
+                                    @JsonProperty("processingDate") final DateTime processingDate,
+                                    @JsonProperty("userToken") final UUID userToken) {
         super();
         this.accountId = accountId;
         this.processingDate = processingDate;
@@ -73,31 +73,40 @@ public class DefaultEmptyInvoiceEvent implements EmptyInvoiceEvent {
     }
 
     @Override
-    public boolean equals(Object obj) {
-        if (this == obj)
+    public boolean equals(final Object obj) {
+        if (this == obj) {
             return true;
-        if (obj == null)
+        }
+        if (obj == null) {
             return false;
-        if (getClass() != obj.getClass())
+        }
+        if (getClass() != obj.getClass()) {
             return false;
-        DefaultEmptyInvoiceEvent other = (DefaultEmptyInvoiceEvent) obj;
+        }
+        final DefaultEmptyInvoiceEvent other = (DefaultEmptyInvoiceEvent) obj;
         if (accountId == null) {
-            if (other.accountId != null)
+            if (other.accountId != null) {
                 return false;
-        } else if (!accountId.equals(other.accountId))
+            }
+        } else if (!accountId.equals(other.accountId)) {
             return false;
+        }
         if (processingDate == null) {
-            if (other.processingDate != null)
+            if (other.processingDate != null) {
                 return false;
-        } else if (processingDate.compareTo(other.processingDate) != 0)
+            }
+        } else if (processingDate.compareTo(other.processingDate) != 0) {
             return false;
+        }
         if (userToken == null) {
-            if (other.userToken != null)
+            if (other.userToken != null) {
                 return false;
-        } else if (!userToken.equals(other.userToken))
+            }
+        } else if (!userToken.equals(other.userToken)) {
             return false;
+        }
         return true;
     }
-    
-    
+
+
 }
diff --git a/invoice/src/main/java/com/ning/billing/invoice/api/user/DefaultInvoiceCreationEvent.java b/invoice/src/main/java/com/ning/billing/invoice/api/user/DefaultInvoiceCreationEvent.java
index 7ba10fb..6a3cf86 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/api/user/DefaultInvoiceCreationEvent.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/api/user/DefaultInvoiceCreationEvent.java
@@ -19,16 +19,16 @@ package com.ning.billing.invoice.api.user;
 import java.math.BigDecimal;
 import java.util.UUID;
 
+import org.joda.time.DateTime;
+
 import com.fasterxml.jackson.annotation.JsonCreator;
 import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.fasterxml.jackson.annotation.JsonProperty;
-import org.joda.time.DateTime;
-
 import com.ning.billing.catalog.api.Currency;
 import com.ning.billing.invoice.api.InvoiceCreationEvent;
 
 public class DefaultInvoiceCreationEvent implements InvoiceCreationEvent {
-	
+
     private final UUID invoiceId;
     private final UUID accountId;
     private final BigDecimal amountOwed;
@@ -37,12 +37,12 @@ public class DefaultInvoiceCreationEvent implements InvoiceCreationEvent {
     private final UUID userToken;
 
     @JsonCreator
-    public DefaultInvoiceCreationEvent(@JsonProperty("invoiceId") UUID invoiceId,
-            @JsonProperty("accountId") UUID accountId,
-            @JsonProperty("amountOwed") BigDecimal amountOwed,
-            @JsonProperty("currency") Currency currency,
-            @JsonProperty("invoiceCreationDate") DateTime invoiceCreationDate,
-            @JsonProperty("userToken") UUID userToken) {
+    public DefaultInvoiceCreationEvent(@JsonProperty("invoiceId") final UUID invoiceId,
+                                       @JsonProperty("accountId") final UUID accountId,
+                                       @JsonProperty("amountOwed") final BigDecimal amountOwed,
+                                       @JsonProperty("currency") final Currency currency,
+                                       @JsonProperty("invoiceCreationDate") final DateTime invoiceCreationDate,
+                                       @JsonProperty("userToken") final UUID userToken) {
         this.invoiceId = invoiceId;
         this.accountId = accountId;
         this.amountOwed = amountOwed;
@@ -52,15 +52,15 @@ public class DefaultInvoiceCreationEvent implements InvoiceCreationEvent {
     }
 
     @JsonIgnore
-	@Override
-	public BusEventType getBusEventType() {
-		return BusEventType.INVOICE_CREATION;
-	}
+    @Override
+    public BusEventType getBusEventType() {
+        return BusEventType.INVOICE_CREATION;
+    }
 
-	@Override
-	public UUID getUserToken() {
-		return userToken;
-	}
+    @Override
+    public UUID getUserToken() {
+        return userToken;
+    }
 
     @Override
     public UUID getInvoiceId() {
@@ -105,7 +105,7 @@ public class DefaultInvoiceCreationEvent implements InvoiceCreationEvent {
         result = prime
                 * result
                 + ((invoiceCreationDate == null) ? 0 : invoiceCreationDate
-                        .hashCode());
+                .hashCode());
         result = prime * result
                 + ((invoiceId == null) ? 0 : invoiceId.hashCode());
         result = prime * result
@@ -114,43 +114,57 @@ public class DefaultInvoiceCreationEvent implements InvoiceCreationEvent {
     }
 
     @Override
-    public boolean equals(Object obj) {
-        if (this == obj)
+    public boolean equals(final Object obj) {
+        if (this == obj) {
             return true;
-        if (obj == null)
+        }
+        if (obj == null) {
             return false;
-        if (getClass() != obj.getClass())
+        }
+        if (getClass() != obj.getClass()) {
             return false;
-        DefaultInvoiceCreationEvent other = (DefaultInvoiceCreationEvent) obj;
+        }
+        final DefaultInvoiceCreationEvent other = (DefaultInvoiceCreationEvent) obj;
         if (accountId == null) {
-            if (other.accountId != null)
+            if (other.accountId != null) {
                 return false;
-        } else if (!accountId.equals(other.accountId))
+            }
+        } else if (!accountId.equals(other.accountId)) {
             return false;
+        }
         if (amountOwed == null) {
-            if (other.amountOwed != null)
+            if (other.amountOwed != null) {
                 return false;
-        } else if (!amountOwed.equals(other.amountOwed))
+            }
+        } else if (!amountOwed.equals(other.amountOwed)) {
             return false;
-        if (currency != other.currency)
+        }
+        if (currency != other.currency) {
             return false;
+        }
         if (invoiceCreationDate == null) {
-            if (other.invoiceCreationDate != null)
+            if (other.invoiceCreationDate != null) {
                 return false;
-        } else if (invoiceCreationDate.compareTo(other.invoiceCreationDate) != 0)
+            }
+        } else if (invoiceCreationDate.compareTo(other.invoiceCreationDate) != 0) {
             return false;
+        }
         if (invoiceId == null) {
-            if (other.invoiceId != null)
+            if (other.invoiceId != null) {
                 return false;
-        } else if (!invoiceId.equals(other.invoiceId))
+            }
+        } else if (!invoiceId.equals(other.invoiceId)) {
             return false;
+        }
         if (userToken == null) {
-            if (other.userToken != null)
+            if (other.userToken != null) {
                 return false;
-        } else if (!userToken.equals(other.userToken))
+            }
+        } else if (!userToken.equals(other.userToken)) {
             return false;
+        }
         return true;
     }
-    
-    
+
+
 }
diff --git a/invoice/src/main/java/com/ning/billing/invoice/api/user/DefaultInvoiceUserApi.java b/invoice/src/main/java/com/ning/billing/invoice/api/user/DefaultInvoiceUserApi.java
index 7a231a4..e6dc189 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/api/user/DefaultInvoiceUserApi.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/api/user/DefaultInvoiceUserApi.java
@@ -20,19 +20,19 @@ import java.math.BigDecimal;
 import java.util.List;
 import java.util.UUID;
 
-import com.ning.billing.catalog.api.Currency;
-import com.ning.billing.invoice.api.InvoiceItem;
-import com.ning.billing.util.api.TagApiException;
-import com.ning.billing.util.callcontext.CallContext;
 import org.joda.time.DateTime;
 
 import com.google.inject.Inject;
+import com.ning.billing.catalog.api.Currency;
 import com.ning.billing.invoice.InvoiceDispatcher;
 import com.ning.billing.invoice.api.Invoice;
 import com.ning.billing.invoice.api.InvoiceApiException;
+import com.ning.billing.invoice.api.InvoiceItem;
 import com.ning.billing.invoice.api.InvoicePayment;
 import com.ning.billing.invoice.api.InvoiceUserApi;
 import com.ning.billing.invoice.dao.InvoiceDao;
+import com.ning.billing.util.api.TagApiException;
+import com.ning.billing.util.callcontext.CallContext;
 
 public class DefaultInvoiceUserApi implements InvoiceUserApi {
     private final InvoiceDao dao;
@@ -55,15 +55,15 @@ public class DefaultInvoiceUserApi implements InvoiceUserApi {
     }
 
     @Override
-    public void notifyOfPaymentAttempt(InvoicePayment invoicePayment, CallContext context) {
+    public void notifyOfPaymentAttempt(final InvoicePayment invoicePayment, final CallContext context) {
         dao.notifyOfPaymentAttempt(invoicePayment, context);
     }
 
     @Override
-	public BigDecimal getAccountBalance(UUID accountId) {
-		BigDecimal result = dao.getAccountBalance(accountId);
-		return result == null ? BigDecimal.ZERO : result;
-	}
+    public BigDecimal getAccountBalance(final UUID accountId) {
+        final BigDecimal result = dao.getAccountBalance(accountId);
+        return result == null ? BigDecimal.ZERO : result;
+    }
 
     @Override
     public Invoice getInvoice(final UUID invoiceId) {
@@ -75,12 +75,12 @@ public class DefaultInvoiceUserApi implements InvoiceUserApi {
         return dao.getUnpaidInvoicesByAccountId(accountId, upToDate);
     }
 
-	@Override
-	public Invoice triggerInvoiceGeneration(final UUID accountId,
-			final DateTime targetDate, final boolean dryRun,
-            final CallContext context) throws InvoiceApiException {
-		return dispatcher.processAccount(accountId, targetDate, dryRun, context);
-	}
+    @Override
+    public Invoice triggerInvoiceGeneration(final UUID accountId,
+                                            final DateTime targetDate, final boolean dryRun,
+                                            final CallContext context) throws InvoiceApiException {
+        return dispatcher.processAccount(accountId, targetDate, dryRun, context);
+    }
 
     @Override
     public void tagInvoiceAsWrittenOff(final UUID invoiceId, final CallContext context) throws TagApiException {
@@ -99,7 +99,7 @@ public class DefaultInvoiceUserApi implements InvoiceUserApi {
 
     @Override
     public InvoiceItem insertCredit(final UUID accountId, final BigDecimal amount, final DateTime effectiveDate,
-                             final Currency currency, final CallContext context) throws InvoiceApiException {
+                                    final Currency currency, final CallContext context) throws InvoiceApiException {
         return dao.insertCredit(accountId, amount, effectiveDate, currency, context);
     }
 }
diff --git a/invoice/src/main/java/com/ning/billing/invoice/dao/CreditInvoiceItemSqlDao.java b/invoice/src/main/java/com/ning/billing/invoice/dao/CreditInvoiceItemSqlDao.java
index d60e813..7f31b7b 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/dao/CreditInvoiceItemSqlDao.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/dao/CreditInvoiceItemSqlDao.java
@@ -16,12 +16,17 @@
 
 package com.ning.billing.invoice.dao;
 
-import com.ning.billing.catalog.api.Currency;
-import com.ning.billing.invoice.api.InvoiceItem;
-import com.ning.billing.invoice.model.CreditInvoiceItem;
-import com.ning.billing.util.callcontext.CallContext;
-import com.ning.billing.util.callcontext.CallContextBinder;
-import com.ning.billing.util.entity.dao.EntitySqlDao;
+import java.lang.annotation.Annotation;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.math.BigDecimal;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.List;
+import java.util.UUID;
+
 import org.joda.time.DateTime;
 import org.skife.jdbi.v2.SQLStatement;
 import org.skife.jdbi.v2.StatementContext;
@@ -36,16 +41,12 @@ import org.skife.jdbi.v2.sqlobject.customizers.RegisterMapper;
 import org.skife.jdbi.v2.sqlobject.stringtemplate.ExternalizedSqlViaStringTemplate3;
 import org.skife.jdbi.v2.tweak.ResultSetMapper;
 
-import java.lang.annotation.Annotation;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-import java.math.BigDecimal;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.util.List;
-import java.util.UUID;
+import com.ning.billing.catalog.api.Currency;
+import com.ning.billing.invoice.api.InvoiceItem;
+import com.ning.billing.invoice.model.CreditInvoiceItem;
+import com.ning.billing.util.callcontext.CallContext;
+import com.ning.billing.util.callcontext.CallContextBinder;
+import com.ning.billing.util.entity.dao.EntitySqlDao;
 
 @ExternalizedSqlViaStringTemplate3
 @RegisterMapper(CreditInvoiceItemSqlDao.CreditInvoiceItemMapper.class)
@@ -66,7 +67,7 @@ public interface CreditInvoiceItemSqlDao extends EntitySqlDao<InvoiceItem> {
     @SqlBatch
     void create(@CreditInvoiceItemBinder final List<InvoiceItem> items, @CallContextBinder final CallContext context);
 
-    @SqlBatch(transactional=false)
+    @SqlBatch(transactional = false)
     void batchCreateFromTransaction(@CreditInvoiceItemBinder final List<InvoiceItem> items, @CallContextBinder final CallContext context);
 
     @BindingAnnotation(CreditInvoiceItemBinder.CreditInvoiceItemBinderFactory.class)
@@ -74,9 +75,9 @@ public interface CreditInvoiceItemSqlDao extends EntitySqlDao<InvoiceItem> {
     @Target({ElementType.PARAMETER})
     public @interface CreditInvoiceItemBinder {
         public static class CreditInvoiceItemBinderFactory implements BinderFactory {
-            public Binder build(Annotation annotation) {
+            public Binder build(final Annotation annotation) {
                 return new Binder<CreditInvoiceItemBinder, CreditInvoiceItem>() {
-                    public void bind(SQLStatement q, CreditInvoiceItemBinder bind, CreditInvoiceItem item) {
+                    public void bind(final SQLStatement q, final CreditInvoiceItemBinder bind, final CreditInvoiceItem item) {
                         q.bind("id", item.getId().toString());
                         q.bind("invoiceId", item.getInvoiceId().toString());
                         q.bind("accountId", item.getAccountId().toString());
@@ -88,15 +89,16 @@ public interface CreditInvoiceItemSqlDao extends EntitySqlDao<InvoiceItem> {
             }
         }
     }
+
     public class CreditInvoiceItemMapper implements ResultSetMapper<InvoiceItem> {
         @Override
-        public InvoiceItem map(int index, ResultSet result, StatementContext ctx) throws SQLException {
-            UUID id = UUID.fromString(result.getString("id"));
-            UUID invoiceId = UUID.fromString(result.getString("invoice_id"));
-            UUID accountId = UUID.fromString(result.getString("account_id"));
-            DateTime creditDate = new DateTime(result.getTimestamp("credit_date"));
-            BigDecimal amount = result.getBigDecimal("amount");
-            Currency currency = Currency.valueOf(result.getString("currency"));
+        public InvoiceItem map(final int index, final ResultSet result, final StatementContext ctx) throws SQLException {
+            final UUID id = UUID.fromString(result.getString("id"));
+            final UUID invoiceId = UUID.fromString(result.getString("invoice_id"));
+            final UUID accountId = UUID.fromString(result.getString("account_id"));
+            final DateTime creditDate = new DateTime(result.getTimestamp("credit_date"));
+            final BigDecimal amount = result.getBigDecimal("amount");
+            final Currency currency = Currency.valueOf(result.getString("currency"));
             return new CreditInvoiceItem(id, invoiceId, accountId, creditDate, amount, currency);
         }
     }
diff --git a/invoice/src/main/java/com/ning/billing/invoice/dao/DefaultInvoiceDao.java b/invoice/src/main/java/com/ning/billing/invoice/dao/DefaultInvoiceDao.java
index b3145b5..22ddb71 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/dao/DefaultInvoiceDao.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/dao/DefaultInvoiceDao.java
@@ -52,7 +52,6 @@ public class DefaultInvoiceDao implements InvoiceDao {
     private final InvoicePaymentSqlDao invoicePaymentSqlDao;
     private final CreditInvoiceItemSqlDao creditInvoiceItemSqlDao;
     private final TagUserApi tagUserApi;
-
     private final NextBillingDatePoster nextBillingDatePoster;
 
     @Inject
@@ -140,7 +139,6 @@ public class DefaultInvoiceDao implements InvoiceDao {
 
     @Override
     public void create(final Invoice invoice, final CallContext context) {
-
         invoiceSqlDao.inTransaction(new Transaction<Void, InvoiceSqlDao>() {
             @Override
             public Void inTransaction(final InvoiceSqlDao transactional, final TransactionStatus status) throws Exception {
diff --git a/invoice/src/main/java/com/ning/billing/invoice/dao/FixedPriceInvoiceItemSqlDao.java b/invoice/src/main/java/com/ning/billing/invoice/dao/FixedPriceInvoiceItemSqlDao.java
index d4fa5ee..e191023 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/dao/FixedPriceInvoiceItemSqlDao.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/dao/FixedPriceInvoiceItemSqlDao.java
@@ -27,7 +27,6 @@ import java.sql.SQLException;
 import java.util.List;
 import java.util.UUID;
 
-import com.ning.billing.util.entity.dao.EntitySqlDao;
 import org.joda.time.DateTime;
 import org.skife.jdbi.v2.SQLStatement;
 import org.skife.jdbi.v2.StatementContext;
@@ -47,6 +46,7 @@ import com.ning.billing.invoice.api.InvoiceItem;
 import com.ning.billing.invoice.model.FixedPriceInvoiceItem;
 import com.ning.billing.util.callcontext.CallContext;
 import com.ning.billing.util.callcontext.CallContextBinder;
+import com.ning.billing.util.entity.dao.EntitySqlDao;
 
 @ExternalizedSqlViaStringTemplate3()
 @RegisterMapper(FixedPriceInvoiceItemSqlDao.FixedPriceInvoiceItemMapper.class)
@@ -70,7 +70,7 @@ public interface FixedPriceInvoiceItemSqlDao extends EntitySqlDao<InvoiceItem> {
     @SqlBatch
     void create(@FixedPriceInvoiceItemBinder final List<InvoiceItem> items, @CallContextBinder final CallContext context);
 
-    @SqlBatch(transactional=false)
+    @SqlBatch(transactional = false)
     void batchCreateFromTransaction(@FixedPriceInvoiceItemBinder final List<InvoiceItem> items, @CallContextBinder final CallContext context);
 
     @BindingAnnotation(FixedPriceInvoiceItemBinder.FixedPriceInvoiceItemBinderFactory.class)
@@ -78,9 +78,9 @@ public interface FixedPriceInvoiceItemSqlDao extends EntitySqlDao<InvoiceItem> {
     @Target({ElementType.PARAMETER})
     public @interface FixedPriceInvoiceItemBinder {
         public static class FixedPriceInvoiceItemBinderFactory implements BinderFactory {
-            public Binder build(Annotation annotation) {
+            public Binder build(final Annotation annotation) {
                 return new Binder<FixedPriceInvoiceItemBinder, FixedPriceInvoiceItem>() {
-                    public void bind(SQLStatement q, FixedPriceInvoiceItemBinder bind, FixedPriceInvoiceItem item) {
+                    public void bind(final SQLStatement q, final FixedPriceInvoiceItemBinder bind, final FixedPriceInvoiceItem item) {
                         q.bind("id", item.getId().toString());
                         q.bind("accountId", item.getAccountId().toString());
                         q.bind("invoiceId", item.getInvoiceId().toString());
@@ -100,21 +100,21 @@ public interface FixedPriceInvoiceItemSqlDao extends EntitySqlDao<InvoiceItem> {
 
     public static class FixedPriceInvoiceItemMapper implements ResultSetMapper<InvoiceItem> {
         @Override
-        public FixedPriceInvoiceItem map(int index, ResultSet result, StatementContext context) throws SQLException {
-            UUID id = UUID.fromString(result.getString("id"));
-            UUID invoiceId = UUID.fromString(result.getString("invoice_id"));
-            UUID accountId = UUID.fromString(result.getString("account_id"));
-            UUID bundleId = result.getString("bundle_id") == null ? null :UUID.fromString(result.getString("bundle_id"));
-            UUID subscriptionId = result.getString("subscription_id") == null ? null : UUID.fromString(result.getString("subscription_id"));
-            String planName = result.getString("plan_name");
-            String phaseName = result.getString("phase_name");
-            DateTime startDate = new DateTime(result.getTimestamp("start_date"));
-            DateTime endDate = new DateTime(result.getTimestamp("end_date"));
-            BigDecimal amount = result.getBigDecimal("amount");
-            Currency currency = Currency.valueOf(result.getString("currency"));
+        public FixedPriceInvoiceItem map(final int index, final ResultSet result, final StatementContext context) throws SQLException {
+            final UUID id = UUID.fromString(result.getString("id"));
+            final UUID invoiceId = UUID.fromString(result.getString("invoice_id"));
+            final UUID accountId = UUID.fromString(result.getString("account_id"));
+            final UUID bundleId = result.getString("bundle_id") == null ? null : UUID.fromString(result.getString("bundle_id"));
+            final UUID subscriptionId = result.getString("subscription_id") == null ? null : UUID.fromString(result.getString("subscription_id"));
+            final String planName = result.getString("plan_name");
+            final String phaseName = result.getString("phase_name");
+            final DateTime startDate = new DateTime(result.getTimestamp("start_date"));
+            final DateTime endDate = new DateTime(result.getTimestamp("end_date"));
+            final BigDecimal amount = result.getBigDecimal("amount");
+            final Currency currency = Currency.valueOf(result.getString("currency"));
 
             return new FixedPriceInvoiceItem(id, invoiceId, accountId, bundleId, subscriptionId, planName, phaseName,
-                                            startDate, endDate, amount, currency);
+                                             startDate, endDate, amount, currency);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/invoice/src/main/java/com/ning/billing/invoice/dao/InvoiceDao.java b/invoice/src/main/java/com/ning/billing/invoice/dao/InvoiceDao.java
index 20c3c53..fe82d6c 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/dao/InvoiceDao.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/dao/InvoiceDao.java
@@ -16,6 +16,12 @@
 
 package com.ning.billing.invoice.dao;
 
+import java.math.BigDecimal;
+import java.util.List;
+import java.util.UUID;
+
+import org.joda.time.DateTime;
+
 import com.ning.billing.catalog.api.Currency;
 import com.ning.billing.invoice.api.Invoice;
 import com.ning.billing.invoice.api.InvoiceApiException;
@@ -23,11 +29,6 @@ import com.ning.billing.invoice.api.InvoiceItem;
 import com.ning.billing.invoice.api.InvoicePayment;
 import com.ning.billing.util.api.TagApiException;
 import com.ning.billing.util.callcontext.CallContext;
-import org.joda.time.DateTime;
-
-import java.math.BigDecimal;
-import java.util.List;
-import java.util.UUID;
 
 public interface InvoiceDao {
     void create(Invoice invoice, CallContext context);
@@ -54,7 +55,7 @@ public interface InvoiceDao {
 
     void test();
 
-	List<Invoice> getAllInvoicesByAccount(final UUID accountId);
+    List<Invoice> getAllInvoicesByAccount(final UUID accountId);
 
     void setWrittenOff(final UUID invoiceId, final CallContext context) throws TagApiException;
 
diff --git a/invoice/src/main/java/com/ning/billing/invoice/dao/InvoicePaymentSqlDao.java b/invoice/src/main/java/com/ning/billing/invoice/dao/InvoicePaymentSqlDao.java
index 69c4c2a..ebbdbb7 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/dao/InvoicePaymentSqlDao.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/dao/InvoicePaymentSqlDao.java
@@ -27,15 +27,6 @@ import java.sql.SQLException;
 import java.util.List;
 import java.util.UUID;
 
-import com.ning.billing.catalog.api.Currency;
-import com.ning.billing.invoice.model.DefaultInvoicePayment;
-import com.ning.billing.util.dao.AuditSqlDao;
-import com.ning.billing.util.callcontext.CallContext;
-import com.ning.billing.util.callcontext.CallContextBinder;
-import com.ning.billing.util.dao.BinderBase;
-import com.ning.billing.util.dao.MapperBase;
-import com.ning.billing.util.dao.UuidMapper;
-import com.ning.billing.util.entity.dao.EntitySqlDao;
 import org.joda.time.DateTime;
 import org.skife.jdbi.v2.SQLStatement;
 import org.skife.jdbi.v2.StatementContext;
@@ -52,14 +43,23 @@ import org.skife.jdbi.v2.sqlobject.mixins.Transmogrifier;
 import org.skife.jdbi.v2.sqlobject.stringtemplate.ExternalizedSqlViaStringTemplate3;
 import org.skife.jdbi.v2.tweak.ResultSetMapper;
 
+import com.ning.billing.catalog.api.Currency;
 import com.ning.billing.invoice.api.InvoicePayment;
+import com.ning.billing.invoice.model.DefaultInvoicePayment;
+import com.ning.billing.util.callcontext.CallContext;
+import com.ning.billing.util.callcontext.CallContextBinder;
+import com.ning.billing.util.dao.AuditSqlDao;
+import com.ning.billing.util.dao.BinderBase;
+import com.ning.billing.util.dao.MapperBase;
+import com.ning.billing.util.dao.UuidMapper;
+import com.ning.billing.util.entity.dao.EntitySqlDao;
 
 @ExternalizedSqlViaStringTemplate3
 @RegisterMapper(InvoicePaymentSqlDao.InvoicePaymentMapper.class)
 public interface InvoicePaymentSqlDao extends EntitySqlDao<InvoicePayment>, Transactional<InvoicePaymentSqlDao>, AuditSqlDao, Transmogrifier {
     @SqlQuery
     List<Long> getRecordIds(@Bind("invoiceId") final String invoiceId);
-    
+
     @SqlQuery
     public InvoicePayment getByPaymentAttemptId(@Bind("paymentAttempt") final String paymentAttemptId);
 
@@ -70,7 +70,7 @@ public interface InvoicePaymentSqlDao extends EntitySqlDao<InvoicePayment>, Tran
     public void create(@InvoicePaymentBinder final InvoicePayment invoicePayment,
                        @CallContextBinder final CallContext context);
 
-    @SqlBatch(transactional=false)
+    @SqlBatch(transactional = false)
     void batchCreateFromTransaction(@InvoicePaymentBinder final List<InvoicePayment> items,
                                     @CallContextBinder final CallContext context);
 
@@ -99,7 +99,7 @@ public interface InvoicePaymentSqlDao extends EntitySqlDao<InvoicePayment>, Tran
 
     public static class InvoicePaymentMapper extends MapperBase implements ResultSetMapper<InvoicePayment> {
         @Override
-        public InvoicePayment map(int index, ResultSet result, StatementContext context) throws SQLException {
+        public InvoicePayment map(final int index, final ResultSet result, final StatementContext context) throws SQLException {
             final UUID id = getUUID(result, "id");
             final UUID paymentAttemptId = getUUID(result, "payment_attempt_id");
             final UUID invoiceId = getUUID(result, "invoice_id");
@@ -110,7 +110,7 @@ public interface InvoicePaymentSqlDao extends EntitySqlDao<InvoicePayment>, Tran
             final UUID reversedInvoicePaymentId = getUUID(result, "reversed_invoice_Payment_id");
 
             return new DefaultInvoicePayment(id, paymentAttemptId, invoiceId, paymentAttemptDate,
-                    amount, currency, reversedInvoicePaymentId);
+                                             amount, currency, reversedInvoicePaymentId);
         }
     }
 
@@ -120,16 +120,16 @@ public interface InvoicePaymentSqlDao extends EntitySqlDao<InvoicePayment>, Tran
     public @interface InvoicePaymentBinder {
         public static class InvoicePaymentBinderFactory extends BinderBase implements BinderFactory {
             @Override
-            public Binder build(Annotation annotation) {
+            public Binder build(final Annotation annotation) {
                 return new Binder<InvoicePaymentBinder, InvoicePayment>() {
                     @Override
-                    public void bind(SQLStatement q, InvoicePaymentBinder bind, InvoicePayment payment) {
+                    public void bind(final SQLStatement q, final InvoicePaymentBinder bind, final InvoicePayment payment) {
                         q.bind("id", payment.getId().toString());
                         q.bind("invoiceId", payment.getInvoiceId().toString());
                         q.bind("paymentAttemptId", uuidToString(payment.getPaymentAttemptId()));
                         q.bind("paymentAttemptDate", payment.getPaymentAttemptDate().toDate());
                         q.bind("amount", payment.getAmount());
-                        Currency currency = payment.getCurrency();
+                        final Currency currency = payment.getCurrency();
                         q.bind("currency", (currency == null) ? null : currency.toString());
                         q.bind("reversedInvoicePaymentId", uuidToString(payment.getReversedInvoicePaymentId()));
                     }
diff --git a/invoice/src/main/java/com/ning/billing/invoice/dao/InvoiceSqlDao.java b/invoice/src/main/java/com/ning/billing/invoice/dao/InvoiceSqlDao.java
index 04b3fce..21fe8d5 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/dao/InvoiceSqlDao.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/dao/InvoiceSqlDao.java
@@ -16,14 +16,18 @@
 
 package com.ning.billing.invoice.dao;
 
-import com.ning.billing.catalog.api.Currency;
-import com.ning.billing.invoice.api.Invoice;
-import com.ning.billing.invoice.model.DefaultInvoice;
-import com.ning.billing.util.callcontext.CallContext;
-import com.ning.billing.util.dao.AuditSqlDao;
-import com.ning.billing.util.dao.UuidMapper;
-import com.ning.billing.util.callcontext.CallContextBinder;
-import com.ning.billing.util.entity.dao.EntitySqlDao;
+import java.lang.annotation.Annotation;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.math.BigDecimal;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.Date;
+import java.util.List;
+import java.util.UUID;
+
 import org.joda.time.DateTime;
 import org.skife.jdbi.v2.SQLStatement;
 import org.skife.jdbi.v2.StatementContext;
@@ -40,17 +44,14 @@ import org.skife.jdbi.v2.sqlobject.mixins.Transmogrifier;
 import org.skife.jdbi.v2.sqlobject.stringtemplate.ExternalizedSqlViaStringTemplate3;
 import org.skife.jdbi.v2.tweak.ResultSetMapper;
 
-import java.lang.annotation.Annotation;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-import java.math.BigDecimal;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.util.Date;
-import java.util.List;
-import java.util.UUID;
+import com.ning.billing.catalog.api.Currency;
+import com.ning.billing.invoice.api.Invoice;
+import com.ning.billing.invoice.model.DefaultInvoice;
+import com.ning.billing.util.callcontext.CallContext;
+import com.ning.billing.util.callcontext.CallContextBinder;
+import com.ning.billing.util.dao.AuditSqlDao;
+import com.ning.billing.util.dao.UuidMapper;
+import com.ning.billing.util.entity.dao.EntitySqlDao;
 
 @ExternalizedSqlViaStringTemplate3()
 @RegisterMapper(InvoiceSqlDao.InvoiceMapper.class)
@@ -61,7 +62,7 @@ public interface InvoiceSqlDao extends EntitySqlDao<Invoice>, AuditSqlDao, Trans
 
     @SqlQuery
     List<Invoice> getInvoicesByAccount(@Bind("accountId") final String accountId);
-    
+
     @SqlQuery
     List<Invoice> getAllInvoicesByAccount(@Bind("accountId") final String string);
 
@@ -90,10 +91,10 @@ public interface InvoiceSqlDao extends EntitySqlDao<Invoice>, AuditSqlDao, Trans
     public @interface InvoiceBinder {
         public static class InvoiceBinderFactory implements BinderFactory {
             @Override
-            public Binder<InvoiceBinder, Invoice> build(Annotation annotation) {
+            public Binder<InvoiceBinder, Invoice> build(final Annotation annotation) {
                 return new Binder<InvoiceBinder, Invoice>() {
                     @Override
-                    public void bind(@SuppressWarnings("rawtypes") SQLStatement q, InvoiceBinder bind, Invoice invoice) {
+                    public void bind(@SuppressWarnings("rawtypes") final SQLStatement q, final InvoiceBinder bind, final Invoice invoice) {
                         q.bind("id", invoice.getId().toString());
                         q.bind("accountId", invoice.getAccountId().toString());
                         q.bind("invoiceDate", invoice.getInvoiceDate().toDate());
@@ -108,14 +109,14 @@ public interface InvoiceSqlDao extends EntitySqlDao<Invoice>, AuditSqlDao, Trans
 
     public static class InvoiceMapper implements ResultSetMapper<Invoice> {
         @Override
-        public Invoice map(int index, ResultSet result, StatementContext context) throws SQLException {
-            UUID id = UUID.fromString(result.getString("id"));
-            UUID accountId = UUID.fromString(result.getString("account_id"));
-            int invoiceNumber = result.getInt("invoice_number");
-            DateTime invoiceDate = new DateTime(result.getTimestamp("invoice_date"));
-            DateTime targetDate = new DateTime(result.getTimestamp("target_date"));
-            Currency currency = Currency.valueOf(result.getString("currency"));
-            boolean isMigrationInvoice = result.getBoolean("migrated");
+        public Invoice map(final int index, final ResultSet result, final StatementContext context) throws SQLException {
+            final UUID id = UUID.fromString(result.getString("id"));
+            final UUID accountId = UUID.fromString(result.getString("account_id"));
+            final int invoiceNumber = result.getInt("invoice_number");
+            final DateTime invoiceDate = new DateTime(result.getTimestamp("invoice_date"));
+            final DateTime targetDate = new DateTime(result.getTimestamp("target_date"));
+            final Currency currency = Currency.valueOf(result.getString("currency"));
+            final boolean isMigrationInvoice = result.getBoolean("migrated");
 
             return new DefaultInvoice(id, accountId, invoiceNumber, invoiceDate, targetDate, currency, isMigrationInvoice);
         }
@@ -138,8 +139,5 @@ public interface InvoiceSqlDao extends EntitySqlDao<Invoice>, AuditSqlDao, Trans
             return amountInvoiced.subtract(amountPaid);
         }
     }
-
-
-
 }
 
diff --git a/invoice/src/main/java/com/ning/billing/invoice/dao/RecurringInvoiceItemSqlDao.java b/invoice/src/main/java/com/ning/billing/invoice/dao/RecurringInvoiceItemSqlDao.java
index 4daa560..029b29d 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/dao/RecurringInvoiceItemSqlDao.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/dao/RecurringInvoiceItemSqlDao.java
@@ -27,7 +27,6 @@ import java.sql.SQLException;
 import java.util.List;
 import java.util.UUID;
 
-import com.ning.billing.util.dao.MapperBase;
 import org.joda.time.DateTime;
 import org.skife.jdbi.v2.SQLStatement;
 import org.skife.jdbi.v2.StatementContext;
@@ -47,6 +46,7 @@ import com.ning.billing.invoice.api.InvoiceItem;
 import com.ning.billing.invoice.model.RecurringInvoiceItem;
 import com.ning.billing.util.callcontext.CallContext;
 import com.ning.billing.util.callcontext.CallContextBinder;
+import com.ning.billing.util.dao.MapperBase;
 import com.ning.billing.util.entity.dao.EntitySqlDao;
 
 @ExternalizedSqlViaStringTemplate3()
@@ -77,10 +77,10 @@ public interface RecurringInvoiceItemSqlDao extends EntitySqlDao<InvoiceItem> {
     public @interface RecurringInvoiceItemBinder {
         public static class InvoiceItemBinderFactory implements BinderFactory {
             @Override
-            public Binder build(Annotation annotation) {
+            public Binder build(final Annotation annotation) {
                 return new Binder<RecurringInvoiceItemBinder, RecurringInvoiceItem>() {
                     @Override
-                    public void bind(SQLStatement q, RecurringInvoiceItemBinder bind, RecurringInvoiceItem item) {
+                    public void bind(final SQLStatement q, final RecurringInvoiceItemBinder bind, final RecurringInvoiceItem item) {
                         q.bind("id", item.getId().toString());
                         q.bind("invoiceId", item.getInvoiceId().toString());
                         q.bind("accountId", item.getAccountId().toString());
@@ -102,23 +102,23 @@ public interface RecurringInvoiceItemSqlDao extends EntitySqlDao<InvoiceItem> {
 
     public static class RecurringInvoiceItemMapper extends MapperBase implements ResultSetMapper<InvoiceItem> {
         @Override
-        public InvoiceItem map(int index, ResultSet result, StatementContext context) throws SQLException {
-            UUID id = getUUID(result, "id");
-            UUID invoiceId = getUUID(result, "invoice_id");
-            UUID accountId = getUUID(result, "account_id");
-            UUID subscriptionId = getUUID(result, "subscription_id");
-            UUID bundleId = getUUID(result, "bundle_id");
-            String planName = result.getString("plan_name");
-            String phaseName = result.getString("phase_name");
-            DateTime startDate = getDate(result, "start_date");
-            DateTime endDate = getDate(result, "end_date");
-            BigDecimal amount = result.getBigDecimal("amount");
-            BigDecimal rate = result.getBigDecimal("rate");
-            Currency currency = Currency.valueOf(result.getString("currency"));
-            UUID reversedItemId = getUUID(result, "reversed_item_id");
+        public InvoiceItem map(final int index, final ResultSet result, final StatementContext context) throws SQLException {
+            final UUID id = getUUID(result, "id");
+            final UUID invoiceId = getUUID(result, "invoice_id");
+            final UUID accountId = getUUID(result, "account_id");
+            final UUID subscriptionId = getUUID(result, "subscription_id");
+            final UUID bundleId = getUUID(result, "bundle_id");
+            final String planName = result.getString("plan_name");
+            final String phaseName = result.getString("phase_name");
+            final DateTime startDate = getDate(result, "start_date");
+            final DateTime endDate = getDate(result, "end_date");
+            final BigDecimal amount = result.getBigDecimal("amount");
+            final BigDecimal rate = result.getBigDecimal("rate");
+            final Currency currency = Currency.valueOf(result.getString("currency"));
+            final UUID reversedItemId = getUUID(result, "reversed_item_id");
 
             return new RecurringInvoiceItem(id, invoiceId, accountId, bundleId, subscriptionId, planName, phaseName, startDate, endDate,
-                    amount, rate, currency, reversedItemId);
+                                            amount, rate, currency, reversedItemId);
 
         }
     }
diff --git a/invoice/src/main/java/com/ning/billing/invoice/glue/DefaultInvoiceModule.java b/invoice/src/main/java/com/ning/billing/invoice/glue/DefaultInvoiceModule.java
index f440071..b0fa991 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/glue/DefaultInvoiceModule.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/glue/DefaultInvoiceModule.java
@@ -58,10 +58,10 @@ public class DefaultInvoiceModule extends AbstractModule implements InvoiceModul
     public void installInvoiceUserApi() {
         bind(InvoiceUserApi.class).to(DefaultInvoiceUserApi.class).asEagerSingleton();
     }
-    
+
     /* (non-Javadoc)
-     * @see com.ning.billing.invoice.glue.InvoiceModule#installInvoiceUserApi()
-     */
+    * @see com.ning.billing.invoice.glue.InvoiceModule#installInvoiceUserApi()
+    */
     @Override
     public void installInvoiceTestApi() {
         bind(InvoiceTestApi.class).to(DefaultInvoiceTestApi.class).asEagerSingleton();
@@ -83,19 +83,19 @@ public class DefaultInvoiceModule extends AbstractModule implements InvoiceModul
     protected void installInvoiceService() {
         bind(InvoiceService.class).to(DefaultInvoiceService.class).asEagerSingleton();
     }
-    
+
     /* (non-Javadoc)
-     * @see com.ning.billing.invoice.glue.InvoiceModule#installInvoiceMigrationApi()
-     */
+    * @see com.ning.billing.invoice.glue.InvoiceModule#installInvoiceMigrationApi()
+    */
     @Override
     public void installInvoiceMigrationApi() {
-    	bind(InvoiceMigrationApi.class).to(DefaultInvoiceMigrationApi.class).asEagerSingleton();
-	}
+        bind(InvoiceMigrationApi.class).to(DefaultInvoiceMigrationApi.class).asEagerSingleton();
+    }
 
     protected void installNotifiers() {
         bind(NextBillingDateNotifier.class).to(DefaultNextBillingDateNotifier.class).asEagerSingleton();
         bind(NextBillingDatePoster.class).to(DefaultNextBillingDatePoster.class).asEagerSingleton();
-        TranslatorConfig config = new ConfigurationObjectFactory(System.getProperties()).build(TranslatorConfig.class);
+        final TranslatorConfig config = new ConfigurationObjectFactory(System.getProperties()).build(TranslatorConfig.class);
         bind(TranslatorConfig.class).toInstance(config);
         bind(InvoiceFormatterFactory.class).to(DefaultInvoiceFormatterFactory.class).asEagerSingleton();
         bind(InvoiceNotifier.class).to(NullInvoiceNotifier.class).asEagerSingleton();
diff --git a/invoice/src/main/java/com/ning/billing/invoice/InvoiceDispatcher.java b/invoice/src/main/java/com/ning/billing/invoice/InvoiceDispatcher.java
index b982a3f..af6dad1 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/InvoiceDispatcher.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/InvoiceDispatcher.java
@@ -60,8 +60,8 @@ import com.ning.billing.util.globallocker.GlobalLocker.LockerService;
 import com.ning.billing.util.globallocker.LockFailedException;
 
 public class InvoiceDispatcher {
-    private final static Logger log = LoggerFactory.getLogger(InvoiceDispatcher.class);
-    private final static int NB_LOCK_TRY = 5;
+    private static final Logger log = LoggerFactory.getLogger(InvoiceDispatcher.class);
+    private static final int NB_LOCK_TRY = 5;
 
     private final InvoiceGenerator generator;
     private final BillingApi billingApi;
@@ -76,12 +76,12 @@ public class InvoiceDispatcher {
 
     @Inject
     public InvoiceDispatcher(final InvoiceGenerator generator, final AccountUserApi accountUserApi,
-            final BillingApi billingApi,
-            final InvoiceDao invoiceDao,
-            final InvoiceNotifier invoiceNotifier,
-            final GlobalLocker locker,
-            final Bus eventBus,
-            final Clock clock) {
+                             final BillingApi billingApi,
+                             final InvoiceDao invoiceDao,
+                             final InvoiceNotifier invoiceNotifier,
+                             final GlobalLocker locker,
+                             final Bus eventBus,
+                             final Clock clock) {
         this.generator = generator;
         this.billingApi = billingApi;
         this.accountUserApi = accountUserApi;
@@ -91,37 +91,36 @@ public class InvoiceDispatcher {
         this.eventBus = eventBus;
         this.clock = clock;
 
-        String verboseOutputValue = System.getProperty("VERBOSE_OUTPUT");
+        final String verboseOutputValue = System.getProperty("VERBOSE_OUTPUT");
         VERBOSE_OUTPUT = (verboseOutputValue != null) && Boolean.parseBoolean(verboseOutputValue);
     }
 
     public void processSubscription(final SubscriptionEvent transition,
-            final CallContext context) throws InvoiceApiException {
-        UUID subscriptionId = transition.getSubscriptionId();
-        DateTime targetDate = transition.getEffectiveTransitionTime();
+                                    final CallContext context) throws InvoiceApiException {
+        final UUID subscriptionId = transition.getSubscriptionId();
+        final DateTime targetDate = transition.getEffectiveTransitionTime();
         log.info("Got subscription transition from InvoiceListener. id: " + subscriptionId.toString() + "; targetDate: " + targetDate.toString());
         log.info("Transition type: " + transition.getTransitionType().toString());
         processSubscription(subscriptionId, targetDate, context);
     }
 
     public void processSubscription(final UUID subscriptionId, final DateTime targetDate,
-            final CallContext context) throws InvoiceApiException {
+                                    final CallContext context) throws InvoiceApiException {
         try {
             if (subscriptionId == null) {
                 log.error("Failed handling entitlement change.", new InvoiceApiException(ErrorCode.INVOICE_INVALID_TRANSITION));
                 return;
             }
-            UUID accountId = billingApi.getAccountIdFromSubscriptionId(subscriptionId);
+            final UUID accountId = billingApi.getAccountIdFromSubscriptionId(subscriptionId);
             processAccount(accountId, targetDate, false, context);
         } catch (EntitlementBillingApiException e) {
             log.error("Failed handling entitlement change.",
-                    new InvoiceApiException(ErrorCode.INVOICE_NO_ACCOUNT_ID_FOR_SUBSCRIPTION_ID, subscriptionId.toString()));
+                      new InvoiceApiException(ErrorCode.INVOICE_NO_ACCOUNT_ID_FOR_SUBSCRIPTION_ID, subscriptionId.toString()));
         }
-        return;
     }
 
     public Invoice processAccount(final UUID accountId, final DateTime targetDate,
-            final boolean dryRun, final CallContext context) throws InvoiceApiException {
+                                  final boolean dryRun, final CallContext context) throws InvoiceApiException {
         GlobalLock lock = null;
         try {
             lock = locker.lockWithNumberOfTries(LockerService.INVOICE, accountId.toString(), NB_LOCK_TRY);
@@ -131,7 +130,7 @@ public class InvoiceDispatcher {
         } catch (LockFailedException e) {
             // Not good!
             log.error(String.format("Failed to process invoice for account %s, targetDate %s",
-                    accountId.toString(), targetDate), e);
+                                    accountId.toString(), targetDate), e);
         } finally {
             if (lock != null) {
                 lock.release();
@@ -140,35 +139,35 @@ public class InvoiceDispatcher {
         return null;
     }
 
-   
+
     private Invoice processAccountWithLock(final UUID accountId, final DateTime targetDate,
-            final boolean dryRun, final CallContext context) throws InvoiceApiException {
+                                           final boolean dryRun, final CallContext context) throws InvoiceApiException {
         try {
-            Account account = accountUserApi.getAccountById(accountId);
-            BillingEventSet billingEvents = billingApi.getBillingEventsForAccountAndUpdateAccountBCD(accountId);
-            
+            final Account account = accountUserApi.getAccountById(accountId);
+            final BillingEventSet billingEvents = billingApi.getBillingEventsForAccountAndUpdateAccountBCD(accountId);
+
             List<Invoice> invoices = new ArrayList<Invoice>();
             if (!billingEvents.isAccountAutoInvoiceOff()) {
                 invoices = invoiceDao.getInvoicesByAccount(accountId); //no need to fetch, invoicing is off on this account
-            } 
+            }
 
-            Currency targetCurrency = account.getCurrency();
+            final Currency targetCurrency = account.getCurrency();
 
-            
-            Invoice invoice = generator.generateInvoice(accountId, billingEvents, invoices, targetDate, targetCurrency);
+
+            final Invoice invoice = generator.generateInvoice(accountId, billingEvents, invoices, targetDate, targetCurrency);
 
             if (invoice == null) {
                 log.info("Generated null invoice.");
                 outputDebugData(billingEvents, invoices);
                 if (!dryRun) {
-                    BusEvent event = new DefaultEmptyInvoiceEvent(accountId, clock.getUTCNow(), context.getUserToken());
+                    final BusEvent event = new DefaultEmptyInvoiceEvent(accountId, clock.getUTCNow(), context.getUserToken());
                     postEvent(event, accountId);
                 }
             } else {
                 log.info("Generated invoice {} with {} items.", invoice.getId().toString(), invoice.getNumberOfItems());
                 if (VERBOSE_OUTPUT) {
                     log.info("New items");
-                    for (InvoiceItem item : invoice.getInvoiceItems()) {
+                    for (final InvoiceItem item : invoice.getInvoiceItems()) {
                         log.info(item.toString());
                     }
                 }
@@ -176,14 +175,14 @@ public class InvoiceDispatcher {
                 if (!dryRun) {
                     invoiceDao.create(invoice, context);
 
-                    List<InvoiceItem> fixedPriceInvoiceItems = invoice.getInvoiceItems(FixedPriceInvoiceItem.class);
-                    List<InvoiceItem> recurringInvoiceItems = invoice.getInvoiceItems(RecurringInvoiceItem.class);
+                    final List<InvoiceItem> fixedPriceInvoiceItems = invoice.getInvoiceItems(FixedPriceInvoiceItem.class);
+                    final List<InvoiceItem> recurringInvoiceItems = invoice.getInvoiceItems(RecurringInvoiceItem.class);
                     setChargedThroughDates(fixedPriceInvoiceItems, recurringInvoiceItems, context);
 
                     final InvoiceCreationEvent event = new DefaultInvoiceCreationEvent(invoice.getId(), invoice.getAccountId(),
-                            invoice.getBalance(), invoice.getCurrency(),
-                            invoice.getInvoiceDate(),
-                            context.getUserToken());
+                                                                                       invoice.getBalance(), invoice.getCurrency(),
+                                                                                       invoice.getInvoiceDate(),
+                                                                                       context.getUserToken());
 
                     postEvent(event, accountId);
                 }
@@ -194,41 +193,41 @@ public class InvoiceDispatcher {
             }
 
             return invoice;
-        } catch(AccountApiException e) {
-            log.error("Failed handling entitlement change.",e);
-            return null;    
+        } catch (AccountApiException e) {
+            log.error("Failed handling entitlement change.", e);
+            return null;
         }
     }
 
     private void setChargedThroughDates(final Collection<InvoiceItem> fixedPriceItems,
-            final Collection<InvoiceItem> recurringItems, CallContext context) {
+                                        final Collection<InvoiceItem> recurringItems, final CallContext context) {
 
-        Map<UUID, DateTime> chargeThroughDates = new HashMap<UUID, DateTime>();
+        final Map<UUID, DateTime> chargeThroughDates = new HashMap<UUID, DateTime>();
         addInvoiceItemsToChargeThroughDates(chargeThroughDates, fixedPriceItems);
         addInvoiceItemsToChargeThroughDates(chargeThroughDates, recurringItems);
 
-        for (UUID subscriptionId : chargeThroughDates.keySet()) {
-            if(subscriptionId != null) {
-                DateTime chargeThroughDate = chargeThroughDates.get(subscriptionId);
+        for (final UUID subscriptionId : chargeThroughDates.keySet()) {
+            if (subscriptionId != null) {
+                final DateTime chargeThroughDate = chargeThroughDates.get(subscriptionId);
                 log.info("Setting CTD for subscription {} to {}", subscriptionId.toString(), chargeThroughDate.toString());
                 billingApi.setChargedThroughDate(subscriptionId, chargeThroughDate, context);
             }
         }
     }
-    
+
     private void postEvent(final BusEvent event, final UUID accountId) {
         try {
             eventBus.post(event);
-        } catch (EventBusException e){
-            log.error(String.format("Failed to post event {} for account {} ", event.getBusEventType(), accountId), e);
+        } catch (EventBusException e) {
+            log.error(String.format("Failed to post event %s for account %s", event.getBusEventType(), accountId), e);
         }
     }
 
 
-    private void addInvoiceItemsToChargeThroughDates(Map<UUID, DateTime> chargeThroughDates, Collection<InvoiceItem> items) {
-        for (InvoiceItem item : items) {
-            UUID subscriptionId = item.getSubscriptionId();
-            DateTime endDate = item.getEndDate();
+    private void addInvoiceItemsToChargeThroughDates(final Map<UUID, DateTime> chargeThroughDates, final Collection<InvoiceItem> items) {
+        for (final InvoiceItem item : items) {
+            final UUID subscriptionId = item.getSubscriptionId();
+            final DateTime endDate = item.getEndDate();
 
             if (chargeThroughDates.containsKey(subscriptionId)) {
                 if (chargeThroughDates.get(subscriptionId).isBefore(endDate)) {
@@ -241,16 +240,16 @@ public class InvoiceDispatcher {
     }
 
 
-    private void outputDebugData(Collection<BillingEvent> events, Collection<Invoice> invoices) {
+    private void outputDebugData(final Collection<BillingEvent> events, final Collection<Invoice> invoices) {
         if (VERBOSE_OUTPUT) {
             log.info("Events");
-            for (BillingEvent event : events) {
+            for (final BillingEvent event : events) {
                 log.info(event.toString());
             }
 
             log.info("Existing items");
-            for (Invoice invoice : invoices) {
-                for (InvoiceItem item : invoice.getInvoiceItems()) {
+            for (final Invoice invoice : invoices) {
+                for (final InvoiceItem item : invoice.getInvoiceItems()) {
                     log.info(item.toString());
                 }
             }
diff --git a/invoice/src/main/java/com/ning/billing/invoice/InvoiceListener.java b/invoice/src/main/java/com/ning/billing/invoice/InvoiceListener.java
index 66f423e..5793dec 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/InvoiceListener.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/InvoiceListener.java
@@ -18,10 +18,6 @@ package com.ning.billing.invoice;
 
 import java.util.UUID;
 
-import com.ning.billing.util.callcontext.CallContext;
-import com.ning.billing.util.callcontext.CallOrigin;
-import com.ning.billing.util.callcontext.UserType;
-import com.ning.billing.util.callcontext.CallContextFactory;
 import org.joda.time.DateTime;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -32,14 +28,18 @@ import com.ning.billing.entitlement.api.SubscriptionTransitionType;
 import com.ning.billing.entitlement.api.timeline.RepairEntitlementEvent;
 import com.ning.billing.entitlement.api.user.SubscriptionEvent;
 import com.ning.billing.invoice.api.InvoiceApiException;
+import com.ning.billing.util.callcontext.CallContext;
+import com.ning.billing.util.callcontext.CallContextFactory;
+import com.ning.billing.util.callcontext.CallOrigin;
+import com.ning.billing.util.callcontext.UserType;
 
 public class InvoiceListener {
-    private final static Logger log = LoggerFactory.getLogger(InvoiceListener.class);
-	private final InvoiceDispatcher dispatcher;
+    private static final Logger log = LoggerFactory.getLogger(InvoiceListener.class);
+    private final InvoiceDispatcher dispatcher;
     private final CallContextFactory factory;
 
     @Inject
-    public InvoiceListener(CallContextFactory factory, InvoiceDispatcher dispatcher) {
+    public InvoiceListener(final CallContextFactory factory, final InvoiceDispatcher dispatcher) {
         this.dispatcher = dispatcher;
         this.factory = factory;
     }
@@ -47,25 +47,25 @@ public class InvoiceListener {
     @Subscribe
     public void handleRepairEntitlementEvent(final RepairEntitlementEvent repairEvent) {
         try {
-            CallContext context = factory.createCallContext("RepairBundle", CallOrigin.INTERNAL, UserType.SYSTEM, repairEvent.getUserToken());
+            final CallContext context = factory.createCallContext("RepairBundle", CallOrigin.INTERNAL, UserType.SYSTEM, repairEvent.getUserToken());
             dispatcher.processAccount(repairEvent.getAccountId(), repairEvent.getEffectiveDate(), false, context);
         } catch (InvoiceApiException e) {
             log.error(e.getMessage());
         }
     }
-    
+
     @Subscribe
     public void handleSubscriptionTransition(final SubscriptionEvent transition) {
         try {
             //  Skip future uncancel event
             //  Skip events which are marked as not being the last one
-            if (transition.getTransitionType() == SubscriptionTransitionType.UNCANCEL 
+            if (transition.getTransitionType() == SubscriptionTransitionType.UNCANCEL
                     || transition.getRemainingEventsForUserOperation() > 0) {
                 return;
             }
 
-            CallContext context = factory.createCallContext("Transition", CallOrigin.INTERNAL, UserType.SYSTEM, transition.getUserToken());
-        	dispatcher.processSubscription(transition, context);
+            final CallContext context = factory.createCallContext("Transition", CallOrigin.INTERNAL, UserType.SYSTEM, transition.getUserToken());
+            dispatcher.processSubscription(transition, context);
         } catch (InvoiceApiException e) {
             log.error(e.getMessage());
         }
@@ -73,8 +73,8 @@ public class InvoiceListener {
 
     public void handleNextBillingDateEvent(final UUID subscriptionId, final DateTime eventDateTime) {
         try {
-            CallContext context = factory.createCallContext("Next Billing Date", CallOrigin.INTERNAL, UserType.SYSTEM);
-        	dispatcher.processSubscription(subscriptionId, eventDateTime, context);
+            final CallContext context = factory.createCallContext("Next Billing Date", CallOrigin.INTERNAL, UserType.SYSTEM);
+            dispatcher.processSubscription(subscriptionId, eventDateTime, context);
         } catch (InvoiceApiException e) {
             log.error(e.getMessage());
         }
diff --git a/invoice/src/main/java/com/ning/billing/invoice/model/BillingMode.java b/invoice/src/main/java/com/ning/billing/invoice/model/BillingMode.java
index 4920b88..7006cf6 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/model/BillingMode.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/model/BillingMode.java
@@ -16,12 +16,14 @@
 
 package com.ning.billing.invoice.model;
 
-import com.ning.billing.catalog.api.BillingPeriod;
+import java.util.List;
+
 import org.joda.time.DateTime;
 
-import java.util.List;
+import com.ning.billing.catalog.api.BillingPeriod;
 
 public interface BillingMode {
     List<RecurringInvoiceItemData> calculateInvoiceItemData(DateTime startDate, DateTime endDate, DateTime targetDate, int billingCycleDay, BillingPeriod billingPeriod) throws InvalidDateSequenceException;
+
     List<RecurringInvoiceItemData> calculateInvoiceItemData(DateTime startDate, DateTime targetDate, int billingCycleDay, BillingPeriod billingPeriod) throws InvalidDateSequenceException;
-}
\ No newline at end of file
+}
diff --git a/invoice/src/main/java/com/ning/billing/invoice/model/BillingModeBase.java b/invoice/src/main/java/com/ning/billing/invoice/model/BillingModeBase.java
index 55c646c..adc4e3f 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/model/BillingModeBase.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/model/BillingModeBase.java
@@ -16,11 +16,6 @@
 
 package com.ning.billing.invoice.model;
 
-import com.ning.billing.catalog.api.BillingPeriod;
-import org.joda.time.DateTime;
-
-import java.math.BigDecimal;
-
 public abstract class BillingModeBase {
 //    public BigDecimal calculateNumberOfBillingCycles(final DateTime startDate, final DateTime endDate, final DateTime targetDate, final int billingCycleDay, final BillingPeriod billingPeriod) throws InvalidDateSequenceException {
 //        if (endDate.isBefore(startDate)) {throw new InvalidDateSequenceException();}
diff --git a/invoice/src/main/java/com/ning/billing/invoice/model/CreditInvoiceItem.java b/invoice/src/main/java/com/ning/billing/invoice/model/CreditInvoiceItem.java
index 651a717..d271561 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/model/CreditInvoiceItem.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/model/CreditInvoiceItem.java
@@ -16,20 +16,21 @@
 
 package com.ning.billing.invoice.model;
 
+import java.math.BigDecimal;
+import java.util.UUID;
+
+import org.joda.time.DateTime;
+
 import com.ning.billing.catalog.api.Currency;
 import com.ning.billing.invoice.api.InvoiceItem;
 import com.ning.billing.invoice.api.InvoiceItemType;
-import org.joda.time.DateTime;
-
-import java.math.BigDecimal;
-import java.util.UUID;
 
 public class CreditInvoiceItem extends InvoiceItemBase {
-    public CreditInvoiceItem(UUID invoiceId, UUID accountId, DateTime date, BigDecimal amount, Currency currency) {
+    public CreditInvoiceItem(final UUID invoiceId, final UUID accountId, final DateTime date, final BigDecimal amount, final Currency currency) {
         this(UUID.randomUUID(), invoiceId, accountId, date, amount, currency);
     }
 
-    public CreditInvoiceItem(UUID id, UUID invoiceId, UUID accountId, DateTime date, BigDecimal amount, Currency currency) {
+    public CreditInvoiceItem(final UUID id, final UUID invoiceId, final UUID accountId, final DateTime date, final BigDecimal amount, final Currency currency) {
         super(id, invoiceId, accountId, null, null, null, null, date, date, amount, currency, InvoiceItemType.CREDIT);
     }
 
@@ -44,17 +45,31 @@ public class CreditInvoiceItem extends InvoiceItemBase {
     }
 
     @Override
-    public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
+    public boolean equals(final Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
 
-        CreditInvoiceItem that = (CreditInvoiceItem) o;
+        final CreditInvoiceItem that = (CreditInvoiceItem) o;
 
-        if (accountId.compareTo(that.accountId) != 0) return false;
-        if (amount.compareTo(that.amount) != 0) return false;
-        if (currency != that.currency) return false;
-        if (startDate.compareTo(that.startDate) != 0) return false;
-        if (endDate.compareTo(that.endDate) != 0) return false;
+        if (accountId.compareTo(that.accountId) != 0) {
+            return false;
+        }
+        if (amount.compareTo(that.amount) != 0) {
+            return false;
+        }
+        if (currency != that.currency) {
+            return false;
+        }
+        if (startDate.compareTo(that.startDate) != 0) {
+            return false;
+        }
+        if (endDate.compareTo(that.endDate) != 0) {
+            return false;
+        }
 
         return true;
     }
@@ -70,12 +85,12 @@ public class CreditInvoiceItem extends InvoiceItemBase {
     }
 
     @Override
-    public int compareTo(InvoiceItem item) {
+    public int compareTo(final InvoiceItem item) {
         if (!(item instanceof CreditInvoiceItem)) {
             return 1;
         }
 
-        CreditInvoiceItem that = (CreditInvoiceItem) item;
+        final CreditInvoiceItem that = (CreditInvoiceItem) item;
         return id.compareTo(that.getId());
     }
 }
diff --git a/invoice/src/main/java/com/ning/billing/invoice/model/DateRange.java b/invoice/src/main/java/com/ning/billing/invoice/model/DateRange.java
index b1e2fa9..c6eb5bc 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/model/DateRange.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/model/DateRange.java
@@ -22,17 +22,16 @@ public class DateRange {
     private final DateTime startDate;
     private final DateTime endDate;
 
-    public DateRange(DateTime startDate, DateTime endDate) {
+    public DateRange(final DateTime startDate, final DateTime endDate) {
         this.startDate = startDate;
         this.endDate = endDate;
     }
 
     /**
-     *
      * @param date the DateTime in question
      * @return whether the DateRange contains (inclusively) the DateTime in question
      */
-    public boolean contains(DateTime date) {
+    public boolean contains(final DateTime date) {
         if (endDate == null) {
             return date.compareTo(startDate) >= 0;
         }
@@ -40,11 +39,11 @@ public class DateRange {
         return !date.isBefore(startDate) && !date.isAfter(endDate);
     }
 
-    public boolean overlaps(DateRange range) {
+    public boolean overlaps(final DateRange range) {
         return (this.contains(range.startDate) || this.contains(range.endDate));
     }
 
-    public DateRange calculateUnionWith(DateRange range) {
+    public DateRange calculateUnionWith(final DateRange range) {
         if (this.contains(range.startDate) && this.contains(range.endDate)) {
             return this;
         }
diff --git a/invoice/src/main/java/com/ning/billing/invoice/model/DefaultInvoice.java b/invoice/src/main/java/com/ning/billing/invoice/model/DefaultInvoice.java
index 952ff60..c636ada 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/model/DefaultInvoice.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/model/DefaultInvoice.java
@@ -16,13 +16,12 @@
 
 package com.ning.billing.invoice.model;
 
+import javax.annotation.Nullable;
 import java.math.BigDecimal;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.UUID;
 
-import javax.annotation.Nullable;
-
 import org.joda.time.DateTime;
 
 import com.ning.billing.catalog.api.Currency;
@@ -42,13 +41,13 @@ public class DefaultInvoice extends EntityBase implements Invoice {
     private final boolean migrationInvoice;
 
     // used to create a new invoice
-    public DefaultInvoice(UUID accountId, DateTime invoiceDate, DateTime targetDate, Currency currency) {
+    public DefaultInvoice(final UUID accountId, final DateTime invoiceDate, final DateTime targetDate, final Currency currency) {
         this(UUID.randomUUID(), accountId, null, invoiceDate, targetDate, currency, false);
     }
 
     // used to hydrate invoice from persistence layer
-    public DefaultInvoice(UUID invoiceId, UUID accountId, @Nullable Integer invoiceNumber, DateTime invoiceDate,
-                          DateTime targetDate, Currency currency, boolean isMigrationInvoice) {
+    public DefaultInvoice(final UUID invoiceId, final UUID accountId, @Nullable final Integer invoiceNumber, final DateTime invoiceDate,
+                          final DateTime targetDate, final Currency currency, final boolean isMigrationInvoice) {
         super(invoiceId);
         this.accountId = accountId;
         this.invoiceNumber = invoiceNumber;
@@ -74,10 +73,10 @@ public class DefaultInvoice extends EntityBase implements Invoice {
     }
 
     @Override
-    public <T extends InvoiceItem> List<InvoiceItem> getInvoiceItems(Class<T> clazz) {
-        List<InvoiceItem> results = new ArrayList<InvoiceItem>();
-        for (InvoiceItem item : invoiceItems) {
-            if ( clazz.isInstance(item) ) {
+    public <T extends InvoiceItem> List<InvoiceItem> getInvoiceItems(final Class<T> clazz) {
+        final List<InvoiceItem> results = new ArrayList<InvoiceItem>();
+        for (final InvoiceItem item : invoiceItems) {
+            if (clazz.isInstance(item)) {
                 results.add(item);
             }
         }
@@ -116,6 +115,7 @@ public class DefaultInvoice extends EntityBase implements Invoice {
 
     /**
      * null until retrieved from the database
+     *
      * @return the invoice number
      */
     @Override
@@ -137,18 +137,18 @@ public class DefaultInvoice extends EntityBase implements Invoice {
     public Currency getCurrency() {
         return currency;
     }
-    
+
     @Override
     public boolean isMigrationInvoice() {
-		return migrationInvoice;
-	}
+        return migrationInvoice;
+    }
 
-	@Override
+    @Override
     public DateTime getLastPaymentAttempt() {
         DateTime lastPaymentAttempt = null;
 
         for (final InvoicePayment paymentAttempt : payments) {
-            DateTime paymentAttemptDate = paymentAttempt.getPaymentAttemptDate();
+            final DateTime paymentAttemptDate = paymentAttempt.getPaymentAttemptDate();
             if (lastPaymentAttempt == null) {
                 lastPaymentAttempt = paymentAttemptDate;
             }
@@ -194,7 +194,7 @@ public class DefaultInvoice extends EntityBase implements Invoice {
             return false;
         }
 
-        DateTime lastPaymentAttempt = getLastPaymentAttempt();
+        final DateTime lastPaymentAttempt = getLastPaymentAttempt();
         return (lastPaymentAttempt == null) || lastPaymentAttempt.plusDays(numberOfDays).isAfter(targetDate);
     }
 
diff --git a/invoice/src/main/java/com/ning/billing/invoice/model/DefaultInvoiceGenerator.java b/invoice/src/main/java/com/ning/billing/invoice/model/DefaultInvoiceGenerator.java
index d330c65..486e803 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/model/DefaultInvoiceGenerator.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/model/DefaultInvoiceGenerator.java
@@ -16,6 +16,7 @@
 
 package com.ning.billing.invoice.model;
 
+import javax.annotation.Nullable;
 import java.math.BigDecimal;
 import java.util.ArrayList;
 import java.util.Collections;
@@ -25,8 +26,6 @@ import java.util.List;
 import java.util.Map;
 import java.util.UUID;
 
-import javax.annotation.Nullable;
-
 import org.joda.time.DateTime;
 import org.joda.time.Months;
 import org.slf4j.Logger;
@@ -55,19 +54,19 @@ public class DefaultInvoiceGenerator implements InvoiceGenerator {
     private final InvoiceConfig config;
 
     @Inject
-    public DefaultInvoiceGenerator(Clock clock, InvoiceConfig config) {
+    public DefaultInvoiceGenerator(final Clock clock, final InvoiceConfig config) {
         this.clock = clock;
         this.config = config;
     }
 
-   /*
+    /*
     * adjusts target date to the maximum invoice target date, if future invoices exist
     */
     @Override
     public Invoice generateInvoice(final UUID accountId, @Nullable final BillingEventSet events,
-                                         @Nullable final List<Invoice> existingInvoices,
-                                         DateTime targetDate,
-                                         final Currency targetCurrency) throws InvoiceApiException {
+                                   @Nullable final List<Invoice> existingInvoices,
+                                   DateTime targetDate,
+                                   final Currency targetCurrency) throws InvoiceApiException {
         if ((events == null) || (events.size() == 0) || events.isAccountAutoInvoiceOff()) {
             return null;
         }
@@ -76,13 +75,13 @@ public class DefaultInvoiceGenerator implements InvoiceGenerator {
         //TODO MDW can use subscription Id - not bundle
         //TODO MDW worry about null sub id
 
-        List<InvoiceItem> existingItems = new ArrayList<InvoiceItem>();
+        final List<InvoiceItem> existingItems = new ArrayList<InvoiceItem>();
         if (existingInvoices != null) {
-            for (Invoice invoice : existingInvoices) {
-                for(InvoiceItem item : invoice.getInvoiceItems()) {
-                    if(item.getSubscriptionId() == null || // Always include migration invoices, credits etc.  
-                      !events.getSubscriptionIdsWithAutoInvoiceOff()
-                            .contains(item.getSubscriptionId())) { //don't add items with auto_invoice_off tag 
+            for (final Invoice invoice : existingInvoices) {
+                for (final InvoiceItem item : invoice.getInvoiceItems()) {
+                    if (item.getSubscriptionId() == null || // Always include migration invoices, credits etc.
+                            !events.getSubscriptionIdsWithAutoInvoiceOff()
+                                   .contains(item.getSubscriptionId())) { //don't add items with auto_invoice_off tag
                         existingItems.add(item);
                     }
                 }
@@ -93,9 +92,9 @@ public class DefaultInvoiceGenerator implements InvoiceGenerator {
 
         targetDate = adjustTargetDate(existingInvoices, targetDate);
 
-        Invoice invoice = new DefaultInvoice(accountId, clock.getUTCNow(), targetDate, targetCurrency);
-        UUID invoiceId = invoice.getId();
-        List<InvoiceItem> proposedItems = generateInvoiceItems(invoiceId, accountId, events, targetDate, targetCurrency);
+        final Invoice invoice = new DefaultInvoice(accountId, clock.getUTCNow(), targetDate, targetCurrency);
+        final UUID invoiceId = invoice.getId();
+        final List<InvoiceItem> proposedItems = generateInvoiceItems(invoiceId, accountId, events, targetDate, targetCurrency);
 
         removeCancellingInvoiceItems(existingItems);
         removeDuplicatedInvoiceItems(proposedItems, existingItems);
@@ -113,18 +112,18 @@ public class DefaultInvoiceGenerator implements InvoiceGenerator {
         }
     }
 
-    private void generateCreditsForPastRepairedInvoices(UUID accountId, List<Invoice> existingInvoices, List<InvoiceItem> proposedItems, Currency currency) {
+    private void generateCreditsForPastRepairedInvoices(final UUID accountId, final List<Invoice> existingInvoices, final List<InvoiceItem> proposedItems, final Currency currency) {
         // determine most accurate invoice balances up to this point
-        Map<UUID, BigDecimal> amountOwedByInvoice = new HashMap<UUID, BigDecimal>();
+        final Map<UUID, BigDecimal> amountOwedByInvoice = new HashMap<UUID, BigDecimal>();
 
         if (existingInvoices != null) {
-            for (Invoice invoice : existingInvoices) {
+            for (final Invoice invoice : existingInvoices) {
                 amountOwedByInvoice.put(invoice.getId(), invoice.getBalance());
             }
         }
 
-        for (InvoiceItem item : proposedItems) {
-            UUID invoiceId = item.getInvoiceId();
+        for (final InvoiceItem item : proposedItems) {
+            final UUID invoiceId = item.getInvoiceId();
             if (amountOwedByInvoice.containsKey(invoiceId)) {
                 amountOwedByInvoice.put(invoiceId, amountOwedByInvoice.get(invoiceId).add(item.getAmount()));
             } else {
@@ -132,35 +131,35 @@ public class DefaultInvoiceGenerator implements InvoiceGenerator {
             }
         }
 
-        for (UUID invoiceId : amountOwedByInvoice.keySet()) {
-            BigDecimal invoiceBalance = amountOwedByInvoice.get(invoiceId);
+        for (final UUID invoiceId : amountOwedByInvoice.keySet()) {
+            final BigDecimal invoiceBalance = amountOwedByInvoice.get(invoiceId);
             if (invoiceBalance.compareTo(BigDecimal.ZERO) < 0) {
                 proposedItems.add(new CreditInvoiceItem(invoiceId, accountId, clock.getUTCNow(), invoiceBalance.negate(), currency));
             }
         }
     }
 
-    private void addReversingItems(List<InvoiceItem> existingItems, List<InvoiceItem> proposedItems) {
-        for (InvoiceItem existingItem : existingItems) {
+    private void addReversingItems(final List<InvoiceItem> existingItems, final List<InvoiceItem> proposedItems) {
+        for (final InvoiceItem existingItem : existingItems) {
             if (existingItem instanceof RecurringInvoiceItem) {
-                RecurringInvoiceItem recurringItem = (RecurringInvoiceItem) existingItem;
+                final RecurringInvoiceItem recurringItem = (RecurringInvoiceItem) existingItem;
                 proposedItems.add(recurringItem.asReversingItem());
             }
         }
     }
 
-    private void consumeExistingCredit(UUID invoiceId, UUID accountId, List<InvoiceItem> existingItems,
-                                       List<InvoiceItem> proposedItems, Currency targetCurrency) {
+    private void consumeExistingCredit(final UUID invoiceId, final UUID accountId, final List<InvoiceItem> existingItems,
+                                       final List<InvoiceItem> proposedItems, final Currency targetCurrency) {
         BigDecimal totalUnusedCreditAmount = BigDecimal.ZERO;
         BigDecimal totalAmountOwed = BigDecimal.ZERO;
 
-        for (InvoiceItem item : existingItems) {
+        for (final InvoiceItem item : existingItems) {
             if (item instanceof CreditInvoiceItem) {
                 totalUnusedCreditAmount = totalUnusedCreditAmount.add(item.getAmount());
             }
         }
 
-        for (InvoiceItem item : proposedItems) {
+        for (final InvoiceItem item : proposedItems) {
             if (item instanceof CreditInvoiceItem) {
                 totalUnusedCreditAmount = totalUnusedCreditAmount.add(item.getAmount());
             } else {
@@ -184,8 +183,8 @@ public class DefaultInvoiceGenerator implements InvoiceGenerator {
         }
     }
 
-    private void validateTargetDate(DateTime targetDate) throws InvoiceApiException {
-        int maximumNumberOfMonths = config.getNumberOfMonthsInFuture();
+    private void validateTargetDate(final DateTime targetDate) throws InvoiceApiException {
+        final int maximumNumberOfMonths = config.getNumberOfMonthsInFuture();
 
         if (Months.monthsBetween(clock.getUTCNow(), targetDate).getMonths() > maximumNumberOfMonths) {
             throw new InvoiceApiException(ErrorCode.INVOICE_TARGET_DATE_TOO_FAR_IN_THE_FUTURE, targetDate.toString());
@@ -193,11 +192,13 @@ public class DefaultInvoiceGenerator implements InvoiceGenerator {
     }
 
     private DateTime adjustTargetDate(final List<Invoice> existingInvoices, final DateTime targetDate) {
-        if (existingInvoices == null) {return targetDate;}
+        if (existingInvoices == null) {
+            return targetDate;
+        }
 
         DateTime maxDate = targetDate;
 
-        for (Invoice invoice : existingInvoices) {
+        for (final Invoice invoice : existingInvoices) {
             if (invoice.getTargetDate().isAfter(maxDate)) {
                 maxDate = invoice.getTargetDate();
             }
@@ -211,13 +212,13 @@ public class DefaultInvoiceGenerator implements InvoiceGenerator {
     */
     private void removeDuplicatedInvoiceItems(final List<InvoiceItem> proposedItems,
                                               final List<InvoiceItem> existingInvoiceItems) {
-        Iterator<InvoiceItem> proposedItemIterator = proposedItems.iterator();
+        final Iterator<InvoiceItem> proposedItemIterator = proposedItems.iterator();
         while (proposedItemIterator.hasNext()) {
-            InvoiceItem proposedItem = proposedItemIterator.next();
+            final InvoiceItem proposedItem = proposedItemIterator.next();
 
-            Iterator<InvoiceItem> existingItemIterator = existingInvoiceItems.iterator();
+            final Iterator<InvoiceItem> existingItemIterator = existingInvoiceItems.iterator();
             while (existingItemIterator.hasNext()) {
-                InvoiceItem existingItem = existingItemIterator.next();
+                final InvoiceItem existingItem = existingItemIterator.next();
                 if (existingItem.equals(proposedItem)) {
                     existingItemIterator.remove();
                     proposedItemIterator.remove();
@@ -227,11 +228,11 @@ public class DefaultInvoiceGenerator implements InvoiceGenerator {
     }
 
     private void removeCancellingInvoiceItems(final List<InvoiceItem> items) {
-        List<UUID> itemsToRemove = new ArrayList<UUID>();
+        final List<UUID> itemsToRemove = new ArrayList<UUID>();
 
-        for (InvoiceItem item1 : items) {
+        for (final InvoiceItem item1 : items) {
             if (item1 instanceof RecurringInvoiceItem) {
-                RecurringInvoiceItem recurringInvoiceItem = (RecurringInvoiceItem) item1;
+                final RecurringInvoiceItem recurringInvoiceItem = (RecurringInvoiceItem) item1;
                 if (recurringInvoiceItem.reversesItem()) {
                     itemsToRemove.add(recurringInvoiceItem.getId());
                     itemsToRemove.add(recurringInvoiceItem.getReversedItemId());
@@ -239,9 +240,9 @@ public class DefaultInvoiceGenerator implements InvoiceGenerator {
             }
         }
 
-        Iterator<InvoiceItem> iterator = items.iterator();
+        final Iterator<InvoiceItem> iterator = items.iterator();
         while (iterator.hasNext()) {
-            InvoiceItem item = iterator.next();
+            final InvoiceItem item = iterator.next();
             if (itemsToRemove.contains(item.getId())) {
                 iterator.remove();
             }
@@ -250,26 +251,26 @@ public class DefaultInvoiceGenerator implements InvoiceGenerator {
 
     private List<InvoiceItem> generateInvoiceItems(final UUID invoiceId, final UUID accountId, final BillingEventSet events,
                                                    final DateTime targetDate, final Currency currency) throws InvoiceApiException {
-        List<InvoiceItem> items = new ArrayList<InvoiceItem>();
-        
-        if(events.size() == 0) {
+        final List<InvoiceItem> items = new ArrayList<InvoiceItem>();
+
+        if (events.size() == 0) {
             return items;
         }
 
-        Iterator<BillingEvent> eventIt = events.iterator();
+        final Iterator<BillingEvent> eventIt = events.iterator();
 
         BillingEvent nextEvent = eventIt.next();
-        while(eventIt.hasNext()) {
-            BillingEvent thisEvent = nextEvent;
+        while (eventIt.hasNext()) {
+            final BillingEvent thisEvent = nextEvent;
             nextEvent = eventIt.next();
-            if(!events.getSubscriptionIdsWithAutoInvoiceOff().
+            if (!events.getSubscriptionIdsWithAutoInvoiceOff().
                     contains(thisEvent.getSubscription().getId())) { // don't consider events for subscriptions that have auto_invoice_off
-                BillingEvent adjustedNextEvent = (thisEvent.getSubscription().getId() == nextEvent.getSubscription().getId()) ? nextEvent : null;
+                final BillingEvent adjustedNextEvent = (thisEvent.getSubscription().getId() == nextEvent.getSubscription().getId()) ? nextEvent : null;
                 items.addAll(processEvents(invoiceId, accountId, thisEvent, adjustedNextEvent, targetDate, currency));
             }
         }
         items.addAll(processEvents(invoiceId, accountId, nextEvent, null, targetDate, currency));
-        
+
 // The above should reproduce the semantics of the code below using iterator instead of list.
 //
 //        for (int i = 0; i < events.size(); i++) {
@@ -285,47 +286,47 @@ public class DefaultInvoiceGenerator implements InvoiceGenerator {
         return items;
     }
 
-    private List<InvoiceItem> processEvents(final UUID invoiceId, final UUID accountId, final BillingEvent thisEvent, final BillingEvent nextEvent,
+    private List<InvoiceItem> processEvents(final UUID invoiceId, final UUID accountId, final BillingEvent thisEvent, @Nullable final BillingEvent nextEvent,
                                             final DateTime targetDate, final Currency currency) throws InvoiceApiException {
-        List<InvoiceItem> items = new ArrayList<InvoiceItem>();
-        InvoiceItem fixedPriceInvoiceItem = generateFixedPriceItem(invoiceId, accountId, thisEvent, targetDate, currency);
+        final List<InvoiceItem> items = new ArrayList<InvoiceItem>();
+        final InvoiceItem fixedPriceInvoiceItem = generateFixedPriceItem(invoiceId, accountId, thisEvent, targetDate, currency);
         if (fixedPriceInvoiceItem != null) {
             items.add(fixedPriceInvoiceItem);
         }
 
-        BillingPeriod billingPeriod = thisEvent.getBillingPeriod();
+        final BillingPeriod billingPeriod = thisEvent.getBillingPeriod();
         if (billingPeriod != BillingPeriod.NO_BILLING_PERIOD) {
-            
-            BillingMode billingMode = instantiateBillingMode(thisEvent.getBillingMode());
-            DateTime startDate = thisEvent.getEffectiveDate();
-            DateTime tzAdjustedStartDate = startDate.toDateTime(thisEvent.getTimeZone());
-            DateTime roundedStartDate = new DateTime(tzAdjustedStartDate.getYear(), tzAdjustedStartDate.getMonthOfYear(), tzAdjustedStartDate.getDayOfMonth(),0,0);
+
+            final BillingMode billingMode = instantiateBillingMode(thisEvent.getBillingMode());
+            final DateTime startDate = thisEvent.getEffectiveDate();
+            final DateTime tzAdjustedStartDate = startDate.toDateTime(thisEvent.getTimeZone());
+            final DateTime roundedStartDate = new DateTime(tzAdjustedStartDate.getYear(), tzAdjustedStartDate.getMonthOfYear(), tzAdjustedStartDate.getDayOfMonth(), 0, 0);
             log.info(String.format("start = %s, rounded = %s, target = %s, in = %s", startDate, roundedStartDate, targetDate, (!roundedStartDate.isAfter(targetDate)) ? "in" : "out"));
             if (!roundedStartDate.isAfter(targetDate)) {
-                DateTime endDate = (nextEvent == null) ? null : nextEvent.getEffectiveDate();
-                int billCycleDay = thisEvent.getBillCycleDay();
+                final DateTime endDate = (nextEvent == null) ? null : nextEvent.getEffectiveDate();
+                final int billCycleDay = thisEvent.getBillCycleDay();
 
-                List<RecurringInvoiceItemData> itemData;
+                final List<RecurringInvoiceItemData> itemData;
                 try {
                     itemData = billingMode.calculateInvoiceItemData(startDate, endDate, targetDate, billCycleDay, billingPeriod);
                 } catch (InvalidDateSequenceException e) {
                     throw new InvoiceApiException(ErrorCode.INVOICE_INVALID_DATE_SEQUENCE, startDate, endDate, targetDate);
                 }
 
-                for (RecurringInvoiceItemData itemDatum : itemData) {
-                    BigDecimal rate = thisEvent.getRecurringPrice();
+                for (final RecurringInvoiceItemData itemDatum : itemData) {
+                    final BigDecimal rate = thisEvent.getRecurringPrice();
 
                     if (rate != null) {
-                        BigDecimal amount = itemDatum.getNumberOfCycles().multiply(rate).setScale(NUMBER_OF_DECIMALS, ROUNDING_MODE);
-
-                        RecurringInvoiceItem recurringItem = new RecurringInvoiceItem(invoiceId, 
-                                accountId,
-                                thisEvent.getSubscription().getBundleId(), 
-                                thisEvent.getSubscription().getId(),
-                                thisEvent.getPlan().getName(),
-                                thisEvent.getPlanPhase().getName(),
-                                itemDatum.getStartDate(), itemDatum.getEndDate(),
-                                amount, rate, currency);
+                        final BigDecimal amount = itemDatum.getNumberOfCycles().multiply(rate).setScale(NUMBER_OF_DECIMALS, ROUNDING_MODE);
+
+                        final RecurringInvoiceItem recurringItem = new RecurringInvoiceItem(invoiceId,
+                                                                                            accountId,
+                                                                                            thisEvent.getSubscription().getBundleId(),
+                                                                                            thisEvent.getSubscription().getId(),
+                                                                                            thisEvent.getPlan().getName(),
+                                                                                            thisEvent.getPlanPhase().getName(),
+                                                                                            itemDatum.getStartDate(), itemDatum.getEndDate(),
+                                                                                            amount, rate, currency);
                         items.add(recurringItem);
                     }
                 }
@@ -335,7 +336,7 @@ public class DefaultInvoiceGenerator implements InvoiceGenerator {
         return items;
     }
 
-    private BillingMode instantiateBillingMode(BillingModeType billingMode) {
+    private BillingMode instantiateBillingMode(final BillingModeType billingMode) {
         switch (billingMode) {
             case IN_ADVANCE:
                 return new InAdvanceBillingMode();
@@ -345,15 +346,15 @@ public class DefaultInvoiceGenerator implements InvoiceGenerator {
     }
 
     private InvoiceItem generateFixedPriceItem(final UUID invoiceId, final UUID accountId, final BillingEvent thisEvent,
-                                               final DateTime targetDate, final Currency currency) throws InvoiceApiException {
+                                               final DateTime targetDate, final Currency currency) {
         if (thisEvent.getEffectiveDate().isAfter(targetDate)) {
             return null;
         } else {
-            BigDecimal fixedPrice = thisEvent.getFixedPrice();
+            final BigDecimal fixedPrice = thisEvent.getFixedPrice();
 
             if (fixedPrice != null) {
-                Duration duration = thisEvent.getPlanPhase().getDuration();
-                DateTime endDate = duration.addToDateTime(thisEvent.getEffectiveDate());
+                final Duration duration = thisEvent.getPlanPhase().getDuration();
+                final DateTime endDate = duration.addToDateTime(thisEvent.getEffectiveDate());
 
                 return new FixedPriceInvoiceItem(invoiceId, accountId, thisEvent.getSubscription().getBundleId(),
                                                  thisEvent.getSubscription().getId(),
@@ -364,4 +365,4 @@ public class DefaultInvoiceGenerator implements InvoiceGenerator {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/invoice/src/main/java/com/ning/billing/invoice/model/DefaultInvoicePayment.java b/invoice/src/main/java/com/ning/billing/invoice/model/DefaultInvoicePayment.java
index 1be9662..db80be0 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/model/DefaultInvoicePayment.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/model/DefaultInvoicePayment.java
@@ -16,16 +16,17 @@
 
 package com.ning.billing.invoice.model;
 
+import javax.annotation.Nullable;
+import java.math.BigDecimal;
+import java.util.UUID;
+
+import org.joda.time.DateTime;
+
 import com.ning.billing.ErrorCode;
 import com.ning.billing.catalog.api.Currency;
 import com.ning.billing.invoice.api.InvoiceApiException;
 import com.ning.billing.invoice.api.InvoicePayment;
 import com.ning.billing.util.entity.EntityBase;
-import org.joda.time.DateTime;
-
-import javax.annotation.Nullable;
-import java.math.BigDecimal;
-import java.util.UUID;
 
 public class DefaultInvoicePayment extends EntityBase implements InvoicePayment {
     private final UUID paymentAttemptId;
@@ -87,7 +88,7 @@ public class DefaultInvoicePayment extends EntityBase implements InvoicePayment 
     }
 
     @Override
-    public InvoicePayment asChargeBack(BigDecimal chargeBackAmount, DateTime chargeBackDate) throws InvoiceApiException {
+    public InvoicePayment asChargeBack(final BigDecimal chargeBackAmount, final DateTime chargeBackDate) throws InvoiceApiException {
         if (chargeBackAmount.compareTo(amount) > 0) {
             throw new InvoiceApiException(ErrorCode.CHARGE_BACK_AMOUNT_TOO_HIGH, chargeBackAmount, amount);
         }
diff --git a/invoice/src/main/java/com/ning/billing/invoice/model/FixedPriceInvoiceItem.java b/invoice/src/main/java/com/ning/billing/invoice/model/FixedPriceInvoiceItem.java
index 60a39a6..9176230 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/model/FixedPriceInvoiceItem.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/model/FixedPriceInvoiceItem.java
@@ -16,24 +16,25 @@
 
 package com.ning.billing.invoice.model;
 
+import javax.annotation.Nullable;
 import java.math.BigDecimal;
 import java.util.UUID;
 
-import com.ning.billing.invoice.api.InvoiceItemType;
 import org.joda.time.DateTime;
 
 import com.ning.billing.catalog.api.Currency;
 import com.ning.billing.invoice.api.InvoiceItem;
+import com.ning.billing.invoice.api.InvoiceItemType;
 
 public class FixedPriceInvoiceItem extends InvoiceItemBase {
 
-    public FixedPriceInvoiceItem(UUID invoiceId, UUID accountId, UUID bundleId, UUID subscriptionId, String planName, String phaseName,
-                                 DateTime startDate, DateTime endDate, BigDecimal amount, Currency currency) {
+    public FixedPriceInvoiceItem(final UUID invoiceId, final UUID accountId, @Nullable final UUID bundleId, @Nullable final UUID subscriptionId, final String planName, final String phaseName,
+                                 final DateTime startDate, final DateTime endDate, final BigDecimal amount, final Currency currency) {
         super(invoiceId, accountId, bundleId, subscriptionId, planName, phaseName, startDate, endDate, amount, currency, InvoiceItemType.FIXED);
     }
 
-    public FixedPriceInvoiceItem(UUID id, UUID invoiceId, UUID accountId, UUID bundleId, UUID subscriptionId, String planName, String phaseName,
-                                 DateTime startDate, DateTime endDate, BigDecimal amount, Currency currency) {
+    public FixedPriceInvoiceItem(final UUID id, final UUID invoiceId, final UUID accountId, final UUID bundleId, final UUID subscriptionId, final String planName, final String phaseName,
+                                 final DateTime startDate, final DateTime endDate, final BigDecimal amount, final Currency currency) {
         super(id, invoiceId, accountId, bundleId, subscriptionId, planName, phaseName, startDate, endDate, amount, currency, InvoiceItemType.FIXED);
     }
 
@@ -62,17 +63,17 @@ public class FixedPriceInvoiceItem extends InvoiceItemBase {
     }
 
     @Override
-    public int compareTo(InvoiceItem item) {
+    public int compareTo(final InvoiceItem item) {
         if (!(item instanceof FixedPriceInvoiceItem)) {
             return 1;
         }
 
-        FixedPriceInvoiceItem that = (FixedPriceInvoiceItem) item;
-        int compareAccounts = getAccountId().compareTo(that.getAccountId());
+        final FixedPriceInvoiceItem that = (FixedPriceInvoiceItem) item;
+        final int compareAccounts = getAccountId().compareTo(that.getAccountId());
         if (compareAccounts == 0 && bundleId != null) {
-            int compareBundles = getBundleId().compareTo(that.getBundleId());
+            final int compareBundles = getBundleId().compareTo(that.getBundleId());
             if (compareBundles == 0 && subscriptionId != null) {
-                int compareSubscriptions = getSubscriptionId().compareTo(that.getSubscriptionId());
+                final int compareSubscriptions = getSubscriptionId().compareTo(that.getSubscriptionId());
                 if (compareSubscriptions == 0) {
                     return getStartDate().compareTo(that.getStartDate());
                 } else {
@@ -88,7 +89,7 @@ public class FixedPriceInvoiceItem extends InvoiceItemBase {
 
     @Override
     public String toString() {
-        StringBuilder sb = new StringBuilder();
+        final StringBuilder sb = new StringBuilder();
         sb.append("InvoiceItem = {").append("id = ").append(id.toString()).append(", ");
         sb.append("invoiceId = ").append(invoiceId.toString()).append(", ");
         sb.append("accountId = ").append(accountId.toString()).append(", ");
@@ -111,22 +112,42 @@ public class FixedPriceInvoiceItem extends InvoiceItemBase {
     }
 
     @Override
-    public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
+    public boolean equals(final Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
 
-        FixedPriceInvoiceItem that = (FixedPriceInvoiceItem) o;
-        if (accountId.compareTo(that.accountId) != 0) return false;
-        if (subscriptionId != null ? !subscriptionId.equals(that.subscriptionId) : that.subscriptionId != null)
+        final FixedPriceInvoiceItem that = (FixedPriceInvoiceItem) o;
+        if (accountId.compareTo(that.accountId) != 0) {
             return false;
-        if (bundleId != null ? !bundleId.equals(that.bundleId) : that.bundleId != null)
+        }
+        if (subscriptionId != null ? !subscriptionId.equals(that.subscriptionId) : that.subscriptionId != null) {
             return false;
-        if (amount != null ? amount.compareTo(that.amount) != 0 : that.amount != null) return false;
-        if (currency != that.currency) return false;
-        if (startDate != null ? startDate.compareTo(that.startDate) != 0 : that.startDate != null) return false;
-        if (endDate != null ? endDate.compareTo(that.endDate) != 0 : that.endDate != null) return false;
-        if (phaseName != null ? !phaseName.equals(that.phaseName) : that.phaseName != null) return false;
-        if (planName != null ? !planName.equals(that.planName) : that.planName != null) return false;
+        }
+        if (bundleId != null ? !bundleId.equals(that.bundleId) : that.bundleId != null) {
+            return false;
+        }
+        if (amount != null ? amount.compareTo(that.amount) != 0 : that.amount != null) {
+            return false;
+        }
+        if (currency != that.currency) {
+            return false;
+        }
+        if (startDate != null ? startDate.compareTo(that.startDate) != 0 : that.startDate != null) {
+            return false;
+        }
+        if (endDate != null ? endDate.compareTo(that.endDate) != 0 : that.endDate != null) {
+            return false;
+        }
+        if (phaseName != null ? !phaseName.equals(that.phaseName) : that.phaseName != null) {
+            return false;
+        }
+        if (planName != null ? !planName.equals(that.planName) : that.planName != null) {
+            return false;
+        }
 
         return true;
     }
diff --git a/invoice/src/main/java/com/ning/billing/invoice/model/InAdvanceBillingMode.java b/invoice/src/main/java/com/ning/billing/invoice/model/InAdvanceBillingMode.java
index 916d514..3fcff90 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/model/InAdvanceBillingMode.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/model/InAdvanceBillingMode.java
@@ -16,15 +16,16 @@
 
 package com.ning.billing.invoice.model;
 
-import com.ning.billing.catalog.api.BillingPeriod;
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.List;
+
 import org.joda.time.DateTime;
 import org.joda.time.Days;
 import org.joda.time.Months;
 import org.joda.time.MutableDateTime;
 
-import java.math.BigDecimal;
-import java.util.ArrayList;
-import java.util.List;
+import com.ning.billing.catalog.api.BillingPeriod;
 
 public class InAdvanceBillingMode implements BillingMode {
     private static final int ROUNDING_METHOD = InvoicingConfiguration.getRoundingMode();
@@ -38,27 +39,31 @@ public class InAdvanceBillingMode implements BillingMode {
             return calculateInvoiceItemData(startDate, targetDate, billingCycleDay, billingPeriod);
         }
 
-        if (endDate.isBefore(startDate)) {throw new InvalidDateSequenceException();}
-        if (targetDate.isBefore(startDate)) {throw new InvalidDateSequenceException();}
+        if (endDate.isBefore(startDate)) {
+            throw new InvalidDateSequenceException();
+        }
+        if (targetDate.isBefore(startDate)) {
+            throw new InvalidDateSequenceException();
+        }
 
-        List<RecurringInvoiceItemData> results = new ArrayList<RecurringInvoiceItemData>();
+        final List<RecurringInvoiceItemData> results = new ArrayList<RecurringInvoiceItemData>();
 
         // beginning from the start date, find the first billing date
-        DateTime firstBillingCycleDate = calculateBillingCycleDateOnOrAfter(startDate, billingCycleDay);
+        final DateTime firstBillingCycleDate = calculateBillingCycleDateOnOrAfter(startDate, billingCycleDay);
 
         // add pro-ration item if needed
         if (firstBillingCycleDate.isAfter(startDate)) {
-            BigDecimal leadingProRationPeriods = calculateProRationBeforeFirstBillingPeriod(startDate, firstBillingCycleDate, billingPeriod);
+            final BigDecimal leadingProRationPeriods = calculateProRationBeforeFirstBillingPeriod(startDate, firstBillingCycleDate, billingPeriod);
             if (leadingProRationPeriods != null && leadingProRationPeriods.compareTo(BigDecimal.ZERO) > 0) {
                 results.add(new RecurringInvoiceItemData(startDate, firstBillingCycleDate, leadingProRationPeriods));
             }
         }
 
         // add one item per billing period
-        DateTime effectiveEndDate = calculateEffectiveEndDate(firstBillingCycleDate, targetDate, endDate, billingPeriod);
-        DateTime lastBillingCycleDate = calculateLastBillingCycleDateBefore(effectiveEndDate, firstBillingCycleDate, billingCycleDay, billingPeriod);
-        int numberOfWholeBillingPeriods =  calculateNumberOfWholeBillingPeriods(firstBillingCycleDate, lastBillingCycleDate, billingPeriod);
-        int numberOfMonthsPerBillingPeriod = billingPeriod.getNumberOfMonths();
+        final DateTime effectiveEndDate = calculateEffectiveEndDate(firstBillingCycleDate, targetDate, endDate, billingPeriod);
+        final DateTime lastBillingCycleDate = calculateLastBillingCycleDateBefore(effectiveEndDate, firstBillingCycleDate, billingCycleDay, billingPeriod);
+        final int numberOfWholeBillingPeriods = calculateNumberOfWholeBillingPeriods(firstBillingCycleDate, lastBillingCycleDate, billingPeriod);
+        final int numberOfMonthsPerBillingPeriod = billingPeriod.getNumberOfMonths();
 
         for (int i = 0; i < numberOfWholeBillingPeriods; i++) {
             results.add(new RecurringInvoiceItemData(firstBillingCycleDate.plusMonths(i * numberOfMonthsPerBillingPeriod),
@@ -67,7 +72,7 @@ public class InAdvanceBillingMode implements BillingMode {
 
         // check to see if a trailing pro-ration amount is needed
         if (effectiveEndDate.isAfter(lastBillingCycleDate)) {
-            BigDecimal trailingProRationPeriods = calculateProRationAfterLastBillingCycleDate(effectiveEndDate, lastBillingCycleDate, billingPeriod);
+            final BigDecimal trailingProRationPeriods = calculateProRationAfterLastBillingCycleDate(effectiveEndDate, lastBillingCycleDate, billingPeriod);
             if (trailingProRationPeriods.compareTo(BigDecimal.ZERO) > 0) {
                 results.add(new RecurringInvoiceItemData(lastBillingCycleDate, effectiveEndDate, trailingProRationPeriods));
             }
@@ -80,7 +85,7 @@ public class InAdvanceBillingMode implements BillingMode {
     public List<RecurringInvoiceItemData> calculateInvoiceItemData(final DateTime startDate,
                                                                    final DateTime targetDate, final int billingCycleDay,
                                                                    final BillingPeriod billingPeriod) throws InvalidDateSequenceException {
-        List<RecurringInvoiceItemData> results = new ArrayList<RecurringInvoiceItemData>();
+        final List<RecurringInvoiceItemData> results = new ArrayList<RecurringInvoiceItemData>();
 
         if (targetDate.isBefore(startDate)) {
             // since the target date is before the start date of the event, this should result in no items being generated
@@ -88,21 +93,21 @@ public class InAdvanceBillingMode implements BillingMode {
         }
 
         // beginning from the start date, find the first billing date
-        DateTime firstBillingCycleDate = calculateBillingCycleDateOnOrAfter(startDate, billingCycleDay);
+        final DateTime firstBillingCycleDate = calculateBillingCycleDateOnOrAfter(startDate, billingCycleDay);
 
         // add pro-ration item if needed
         if (firstBillingCycleDate.isAfter(startDate)) {
-            BigDecimal leadingProRationPeriods = calculateProRationBeforeFirstBillingPeriod(startDate, firstBillingCycleDate, billingPeriod);
+            final BigDecimal leadingProRationPeriods = calculateProRationBeforeFirstBillingPeriod(startDate, firstBillingCycleDate, billingPeriod);
             if (leadingProRationPeriods != null && leadingProRationPeriods.compareTo(BigDecimal.ZERO) > 0) {
                 results.add(new RecurringInvoiceItemData(startDate, firstBillingCycleDate, leadingProRationPeriods));
             }
         }
 
         // add one item per billing period
-        DateTime effectiveEndDate = calculateEffectiveEndDate(firstBillingCycleDate, targetDate, billingPeriod);
-        DateTime lastBillingCycleDate = calculateLastBillingCycleDateBefore(effectiveEndDate, firstBillingCycleDate, billingCycleDay, billingPeriod);
-        int numberOfWholeBillingPeriods =  calculateNumberOfWholeBillingPeriods(firstBillingCycleDate, lastBillingCycleDate, billingPeriod);
-        int numberOfMonthsPerBillingPeriod = billingPeriod.getNumberOfMonths();
+        final DateTime effectiveEndDate = calculateEffectiveEndDate(firstBillingCycleDate, targetDate, billingPeriod);
+        final DateTime lastBillingCycleDate = calculateLastBillingCycleDateBefore(effectiveEndDate, firstBillingCycleDate, billingCycleDay, billingPeriod);
+        final int numberOfWholeBillingPeriods = calculateNumberOfWholeBillingPeriods(firstBillingCycleDate, lastBillingCycleDate, billingPeriod);
+        final int numberOfMonthsPerBillingPeriod = billingPeriod.getNumberOfMonths();
 
         for (int i = 0; i < numberOfWholeBillingPeriods; i++) {
             results.add(new RecurringInvoiceItemData(firstBillingCycleDate.plusMonths(i * numberOfMonthsPerBillingPeriod),
@@ -111,7 +116,7 @@ public class InAdvanceBillingMode implements BillingMode {
 
         // check to see if a trailing pro-ration amount is needed
         if (effectiveEndDate.isAfter(lastBillingCycleDate)) {
-            BigDecimal trailingProRationPeriods = calculateProRationAfterLastBillingCycleDate(effectiveEndDate, lastBillingCycleDate, billingPeriod);
+            final BigDecimal trailingProRationPeriods = calculateProRationAfterLastBillingCycleDate(effectiveEndDate, lastBillingCycleDate, billingPeriod);
             if (trailingProRationPeriods.compareTo(BigDecimal.ZERO) > 0) {
                 results.add(new RecurringInvoiceItemData(lastBillingCycleDate, effectiveEndDate, trailingProRationPeriods));
             }
@@ -121,9 +126,9 @@ public class InAdvanceBillingMode implements BillingMode {
     }
 
     private DateTime calculateBillingCycleDateOnOrAfter(final DateTime date, final int billingCycleDay) {
-        int lastDayOfMonth = date.dayOfMonth().getMaximumValue();
+        final int lastDayOfMonth = date.dayOfMonth().getMaximumValue();
 
-        MutableDateTime tmp = date.toMutableDateTime();
+        final MutableDateTime tmp = date.toMutableDateTime();
         if (billingCycleDay > lastDayOfMonth) {
             tmp.setDayOfMonth(lastDayOfMonth);
         } else {
@@ -138,33 +143,33 @@ public class InAdvanceBillingMode implements BillingMode {
         return proposedDate;
     }
 
-    private BigDecimal calculateProRationBeforeFirstBillingPeriod(final DateTime startDate, DateTime nextBillingCycleDate, final BillingPeriod billingPeriod) {
-        DateTime previousBillingCycleDate = nextBillingCycleDate.plusMonths(-billingPeriod.getNumberOfMonths());
+    private BigDecimal calculateProRationBeforeFirstBillingPeriod(final DateTime startDate, final DateTime nextBillingCycleDate, final BillingPeriod billingPeriod) {
+        final DateTime previousBillingCycleDate = nextBillingCycleDate.plusMonths(-billingPeriod.getNumberOfMonths());
 
-        int daysBetween = Days.daysBetween(previousBillingCycleDate, nextBillingCycleDate).getDays();
+        final int daysBetween = Days.daysBetween(previousBillingCycleDate, nextBillingCycleDate).getDays();
         if (daysBetween <= 0) {
             return BigDecimal.ZERO;
         }
 
-        BigDecimal daysInPeriod = new BigDecimal(daysBetween);
-        BigDecimal days = new BigDecimal(Days.daysBetween(startDate, nextBillingCycleDate).getDays());
+        final BigDecimal daysInPeriod = new BigDecimal(daysBetween);
+        final BigDecimal days = new BigDecimal(Days.daysBetween(startDate, nextBillingCycleDate).getDays());
 
         return days.divide(daysInPeriod, 2 * NUMBER_OF_DECIMALS, ROUNDING_METHOD);
     }
 
     private int calculateNumberOfWholeBillingPeriods(final DateTime startDate, final DateTime endDate, final BillingPeriod billingPeriod) {
-        int numberOfMonths = Months.monthsBetween(startDate, endDate).getMonths();
-        int numberOfMonthsInPeriod = billingPeriod.getNumberOfMonths();
+        final int numberOfMonths = Months.monthsBetween(startDate, endDate).getMonths();
+        final int numberOfMonthsInPeriod = billingPeriod.getNumberOfMonths();
         return numberOfMonths / numberOfMonthsInPeriod;
     }
 
-    private DateTime calculateEffectiveEndDate(DateTime billCycleDate, DateTime targetDate, DateTime endDate, BillingPeriod billingPeriod) {
+    private DateTime calculateEffectiveEndDate(final DateTime billCycleDate, final DateTime targetDate, final DateTime endDate, final BillingPeriod billingPeriod) {
         if (targetDate.isBefore(endDate)) {
             if (targetDate.isBefore(billCycleDate)) {
                 return billCycleDate;
             }
 
-            int numberOfMonthsInPeriod = billingPeriod.getNumberOfMonths();
+            final int numberOfMonthsInPeriod = billingPeriod.getNumberOfMonths();
             int numberOfPeriods = 0;
             DateTime proposedDate = billCycleDate;
 
@@ -185,12 +190,12 @@ public class InAdvanceBillingMode implements BillingMode {
         }
     }
 
-    private DateTime calculateEffectiveEndDate(DateTime billCycleDate, DateTime targetDate, BillingPeriod billingPeriod) {
+    private DateTime calculateEffectiveEndDate(final DateTime billCycleDate, final DateTime targetDate, final BillingPeriod billingPeriod) {
         if (targetDate.isBefore(billCycleDate)) {
             return billCycleDate;
         }
 
-        int numberOfMonthsInPeriod = billingPeriod.getNumberOfMonths();
+        final int numberOfMonthsInPeriod = billingPeriod.getNumberOfMonths();
         int numberOfPeriods = 0;
         DateTime proposedDate = billCycleDate;
 
@@ -214,7 +219,7 @@ public class InAdvanceBillingMode implements BillingMode {
         proposedDate = proposedDate.plusMonths(-billingPeriod.getNumberOfMonths());
 
         if (proposedDate.dayOfMonth().get() < billingCycleDay) {
-            int lastDayOfTheMonth = proposedDate.dayOfMonth().getMaximumValue();
+            final int lastDayOfTheMonth = proposedDate.dayOfMonth().getMaximumValue();
             if (lastDayOfTheMonth < billingCycleDay) {
                 return new MutableDateTime(proposedDate).dayOfMonth().set(lastDayOfTheMonth).toDateTime();
             } else {
@@ -227,11 +232,11 @@ public class InAdvanceBillingMode implements BillingMode {
 
     private BigDecimal calculateProRationAfterLastBillingCycleDate(final DateTime endDate, final DateTime previousBillThroughDate, final BillingPeriod billingPeriod) {
         // note: assumption is that previousBillThroughDate is correctly aligned with the billing cycle day
-        DateTime nextBillThroughDate = previousBillThroughDate.plusMonths(billingPeriod.getNumberOfMonths());
-        BigDecimal daysInPeriod = new BigDecimal(Days.daysBetween(previousBillThroughDate, nextBillThroughDate).getDays());
+        final DateTime nextBillThroughDate = previousBillThroughDate.plusMonths(billingPeriod.getNumberOfMonths());
+        final BigDecimal daysInPeriod = new BigDecimal(Days.daysBetween(previousBillThroughDate, nextBillThroughDate).getDays());
 
-        BigDecimal days = new BigDecimal(Days.daysBetween(previousBillThroughDate, endDate).getDays());
+        final BigDecimal days = new BigDecimal(Days.daysBetween(previousBillThroughDate, endDate).getDays());
 
         return days.divide(daysInPeriod, 2 * NUMBER_OF_DECIMALS, ROUNDING_METHOD);
     }
-}
\ No newline at end of file
+}
diff --git a/invoice/src/main/java/com/ning/billing/invoice/model/InvoiceGenerator.java b/invoice/src/main/java/com/ning/billing/invoice/model/InvoiceGenerator.java
index 0b47099..ec28df0 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/model/InvoiceGenerator.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/model/InvoiceGenerator.java
@@ -16,11 +16,10 @@
 
 package com.ning.billing.invoice.model;
 
+import javax.annotation.Nullable;
 import java.util.List;
 import java.util.UUID;
 
-import javax.annotation.Nullable;
-
 import org.joda.time.DateTime;
 
 import com.ning.billing.catalog.api.Currency;
diff --git a/invoice/src/main/java/com/ning/billing/invoice/model/InvoiceItemBase.java b/invoice/src/main/java/com/ning/billing/invoice/model/InvoiceItemBase.java
index 016184d..89bd1a3 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/model/InvoiceItemBase.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/model/InvoiceItemBase.java
@@ -16,15 +16,16 @@
 
 package com.ning.billing.invoice.model;
 
+import javax.annotation.Nullable;
+import java.math.BigDecimal;
+import java.util.UUID;
+
+import org.joda.time.DateTime;
+
 import com.ning.billing.catalog.api.Currency;
 import com.ning.billing.invoice.api.InvoiceItem;
 import com.ning.billing.invoice.api.InvoiceItemType;
 import com.ning.billing.util.entity.EntityBase;
-import org.joda.time.DateTime;
-
-import javax.annotation.Nullable;
-import java.math.BigDecimal;
-import java.util.UUID;
 
 public abstract class InvoiceItemBase extends EntityBase implements InvoiceItem {
     protected final UUID invoiceId;
@@ -37,18 +38,18 @@ public abstract class InvoiceItemBase extends EntityBase implements InvoiceItem 
     protected final DateTime endDate;
     protected final BigDecimal amount;
     protected final Currency currency;
-    protected InvoiceItemType invoiceItemType;
+    protected final InvoiceItemType invoiceItemType;
 
-    public InvoiceItemBase(UUID invoiceId, UUID accountId, UUID bundleId, UUID subscriptionId, String planName, String phaseName,
-            DateTime startDate, DateTime endDate, BigDecimal amount, Currency currency, InvoiceItemType invoiceItemType) {
+    public InvoiceItemBase(final UUID invoiceId, final UUID accountId, final UUID bundleId, final UUID subscriptionId, final String planName, final String phaseName,
+                           final DateTime startDate, final DateTime endDate, final BigDecimal amount, final Currency currency, final InvoiceItemType invoiceItemType) {
         this(UUID.randomUUID(), invoiceId, accountId, bundleId, subscriptionId, planName, phaseName,
-                startDate, endDate, amount, currency, invoiceItemType);
+             startDate, endDate, amount, currency, invoiceItemType);
     }
 
-    public InvoiceItemBase(UUID id, UUID invoiceId, UUID accountId, @Nullable UUID bundleId,
-                           @Nullable UUID subscriptionId, String planName, String phaseName,
-                           DateTime startDate, DateTime endDate, BigDecimal amount, Currency currency,
-                           InvoiceItemType invoiceItemType) {
+    public InvoiceItemBase(final UUID id, final UUID invoiceId, final UUID accountId, @Nullable final UUID bundleId,
+                           @Nullable final UUID subscriptionId, @Nullable final String planName, @Nullable final String phaseName,
+                           final DateTime startDate, final DateTime endDate, final BigDecimal amount, final Currency currency,
+                           final InvoiceItemType invoiceItemType) {
         super(id);
         this.invoiceId = invoiceId;
         this.accountId = accountId;
@@ -72,7 +73,7 @@ public abstract class InvoiceItemBase extends EntityBase implements InvoiceItem 
     public UUID getBundleId() {
         return bundleId;
     }
-    
+
     public UUID getAccountId() {
         return accountId;
     }
diff --git a/invoice/src/main/java/com/ning/billing/invoice/model/InvoiceItemList.java b/invoice/src/main/java/com/ning/billing/invoice/model/InvoiceItemList.java
index 357c7a8..265f518 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/model/InvoiceItemList.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/model/InvoiceItemList.java
@@ -19,6 +19,7 @@ package com.ning.billing.invoice.model;
 import java.math.BigDecimal;
 import java.util.ArrayList;
 import java.util.List;
+
 import com.ning.billing.invoice.api.InvoiceItem;
 
 public class InvoiceItemList extends ArrayList<InvoiceItem> {
diff --git a/invoice/src/main/java/com/ning/billing/invoice/model/InvoicingConfiguration.java b/invoice/src/main/java/com/ning/billing/invoice/model/InvoicingConfiguration.java
index 7741f00..1651c13 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/model/InvoicingConfiguration.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/model/InvoicingConfiguration.java
@@ -19,8 +19,8 @@ package com.ning.billing.invoice.model;
 import java.math.BigDecimal;
 
 public class InvoicingConfiguration {
-    private final static int roundingMethod = BigDecimal.ROUND_HALF_UP;
-    private final static int numberOfDecimals = 2;
+    private static final int roundingMethod = BigDecimal.ROUND_HALF_UP;
+    private static final int numberOfDecimals = 2;
 
     public static int getRoundingMode() {
         return roundingMethod;
diff --git a/invoice/src/main/java/com/ning/billing/invoice/model/MigrationInvoiceItem.java b/invoice/src/main/java/com/ning/billing/invoice/model/MigrationInvoiceItem.java
index ec0962b..32de55b 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/model/MigrationInvoiceItem.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/model/MigrationInvoiceItem.java
@@ -26,8 +26,8 @@ import com.ning.billing.catalog.api.MigrationPlan;
 
 public class MigrationInvoiceItem extends FixedPriceInvoiceItem {
 
-	public MigrationInvoiceItem(UUID invoiceId, UUID accountId, DateTime startDate, BigDecimal amount, Currency currency) {
-		super(invoiceId, accountId, null, null, MigrationPlan.MIGRATION_PLAN_NAME, MigrationPlan.MIGRATION_PLAN_PHASE_NAME,
+    public MigrationInvoiceItem(final UUID invoiceId, final UUID accountId, final DateTime startDate, final BigDecimal amount, final Currency currency) {
+        super(invoiceId, accountId, null, null, MigrationPlan.MIGRATION_PLAN_NAME, MigrationPlan.MIGRATION_PLAN_PHASE_NAME,
               startDate, startDate, amount, currency);
-	}
-}
\ No newline at end of file
+    }
+}
diff --git a/invoice/src/main/java/com/ning/billing/invoice/model/RecurringInvoiceItem.java b/invoice/src/main/java/com/ning/billing/invoice/model/RecurringInvoiceItem.java
index 9dbbae0..cfd2659 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/model/RecurringInvoiceItem.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/model/RecurringInvoiceItem.java
@@ -16,52 +16,53 @@
 
 package com.ning.billing.invoice.model;
 
+import java.math.BigDecimal;
+import java.util.UUID;
+
+import org.joda.time.DateTime;
+
 import com.ning.billing.catalog.api.Currency;
 import com.ning.billing.invoice.api.InvoiceItem;
 import com.ning.billing.invoice.api.InvoiceItemType;
-import org.joda.time.DateTime;
-
-import java.math.BigDecimal;
-import java.util.UUID;
 
 public class RecurringInvoiceItem extends InvoiceItemBase {
     private final BigDecimal rate;
     private final UUID reversedItemId;
 
-    public RecurringInvoiceItem(UUID invoiceId, UUID accountId, UUID bundleId, UUID subscriptionId, String planName, String phaseName,
-                                DateTime startDate, DateTime endDate,
-                                BigDecimal amount, BigDecimal rate,
-                                Currency currency) {
+    public RecurringInvoiceItem(final UUID invoiceId, final UUID accountId, final UUID bundleId, final UUID subscriptionId, final String planName, final String phaseName,
+                                final DateTime startDate, final DateTime endDate,
+                                final BigDecimal amount, final BigDecimal rate,
+                                final Currency currency) {
         super(invoiceId, accountId, bundleId, subscriptionId, planName, phaseName, startDate, endDate, amount, currency, InvoiceItemType.RECURRING);
         this.rate = rate;
         this.reversedItemId = null;
     }
 
-    public RecurringInvoiceItem(UUID invoiceId, UUID accountId, UUID bundleId, UUID subscriptionId, String planName, String phaseName,
-                                DateTime startDate, DateTime endDate,
-                                BigDecimal amount, BigDecimal rate,
-                                Currency currency, UUID reversedItemId) {
+    public RecurringInvoiceItem(final UUID invoiceId, final UUID accountId, final UUID bundleId, final UUID subscriptionId, final String planName, final String phaseName,
+                                final DateTime startDate, final DateTime endDate,
+                                final BigDecimal amount, final BigDecimal rate,
+                                final Currency currency, final UUID reversedItemId) {
         super(invoiceId, accountId, bundleId, subscriptionId, planName, phaseName, startDate, endDate,
-                amount, currency, InvoiceItemType.REVERSAL);
+              amount, currency, InvoiceItemType.REVERSAL);
         this.rate = rate;
         this.reversedItemId = reversedItemId;
     }
 
-    public RecurringInvoiceItem(UUID id, UUID invoiceId, UUID accountId, UUID bundleId, UUID subscriptionId,
-                                String planName, String phaseName,
-                                DateTime startDate, DateTime endDate,
-                                BigDecimal amount, BigDecimal rate,
-                                Currency currency) {
+    public RecurringInvoiceItem(final UUID id, final UUID invoiceId, final UUID accountId, final UUID bundleId, final UUID subscriptionId,
+                                final String planName, final String phaseName,
+                                final DateTime startDate, final DateTime endDate,
+                                final BigDecimal amount, final BigDecimal rate,
+                                final Currency currency) {
         super(id, invoiceId, accountId, bundleId, subscriptionId, planName, phaseName, startDate, endDate, amount, currency, InvoiceItemType.RECURRING);
         this.rate = rate;
         this.reversedItemId = null;
     }
 
-    public RecurringInvoiceItem(UUID id, UUID invoiceId, UUID accountId, UUID bundleId, UUID subscriptionId,
-                                String planName, String phaseName,
-                                DateTime startDate, DateTime endDate,
-                                BigDecimal amount, BigDecimal rate,
-                                Currency currency, UUID reversedItemId) {
+    public RecurringInvoiceItem(final UUID id, final UUID invoiceId, final UUID accountId, final UUID bundleId, final UUID subscriptionId,
+                                final String planName, final String phaseName,
+                                final DateTime startDate, final DateTime endDate,
+                                final BigDecimal amount, final BigDecimal rate,
+                                final Currency currency, final UUID reversedItemId) {
         super(id, invoiceId, accountId, bundleId, subscriptionId, planName, phaseName, startDate, endDate, amount, currency, InvoiceItemType.REVERSAL);
         this.rate = rate;
         this.reversedItemId = reversedItemId;
@@ -69,10 +70,10 @@ public class RecurringInvoiceItem extends InvoiceItemBase {
 
     @Override
     public InvoiceItem asReversingItem() {
-        BigDecimal amountNegated = amount == null ? null : amount.negate();
+        final BigDecimal amountNegated = amount == null ? null : amount.negate();
 
         return new RecurringInvoiceItem(invoiceId, accountId, bundleId, subscriptionId, planName, phaseName, startDate, endDate,
-                amountNegated, rate, currency, id);
+                                        amountNegated, rate, currency, id);
     }
 
     @Override
@@ -93,7 +94,7 @@ public class RecurringInvoiceItem extends InvoiceItemBase {
     }
 
     @Override
-    public int compareTo(InvoiceItem item) {
+    public int compareTo(final InvoiceItem item) {
         if (item == null) {
             return -1;
         }
@@ -101,15 +102,15 @@ public class RecurringInvoiceItem extends InvoiceItemBase {
             return -1;
         }
 
-        RecurringInvoiceItem that = (RecurringInvoiceItem) item;
-        int compareAccounts = getAccountId().compareTo(that.getAccountId());
+        final RecurringInvoiceItem that = (RecurringInvoiceItem) item;
+        final int compareAccounts = getAccountId().compareTo(that.getAccountId());
         if (compareAccounts == 0 && bundleId != null) {
-            int compareBundles = getBundleId().compareTo(that.getBundleId());
+            final int compareBundles = getBundleId().compareTo(that.getBundleId());
             if (compareBundles == 0 && subscriptionId != null) {
 
-                int compareSubscriptions = getSubscriptionId().compareTo(that.getSubscriptionId());
+                final int compareSubscriptions = getSubscriptionId().compareTo(that.getSubscriptionId());
                 if (compareSubscriptions == 0) {
-                    int compareStartDates = getStartDate().compareTo(that.getStartDate());
+                    final int compareStartDates = getStartDate().compareTo(that.getStartDate());
                     if (compareStartDates == 0) {
                         return getEndDate().compareTo(that.getEndDate());
                     } else {
@@ -127,27 +128,50 @@ public class RecurringInvoiceItem extends InvoiceItemBase {
     }
 
     @Override
-    public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
+    public boolean equals(final Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
 
-        RecurringInvoiceItem that = (RecurringInvoiceItem) o;
+        final RecurringInvoiceItem that = (RecurringInvoiceItem) o;
 
         // do not include invoice item type, since a reversing item can be equal to the original item
-        if (accountId.compareTo(that.accountId) != 0) return false;
-        if (amount.compareTo(that.amount) != 0) return false;
-        if (currency != that.currency) return false;
-        if (startDate.compareTo(that.startDate) != 0) return false;
-        if (endDate.compareTo(that.endDate) != 0) return false;
-        if (!phaseName.equals(that.phaseName)) return false;
-        if (!planName.equals(that.planName)) return false;
-        if (rate.compareTo(that.rate) != 0) return false;
-        if (reversedItemId != null ? !reversedItemId.equals(that.reversedItemId) : that.reversedItemId != null)
+        if (accountId.compareTo(that.accountId) != 0) {
             return false;
-        if (subscriptionId != null ? !subscriptionId.equals(that.subscriptionId) : that.subscriptionId != null)
+        }
+        if (amount.compareTo(that.amount) != 0) {
+            return false;
+        }
+        if (currency != that.currency) {
             return false;
-        if (bundleId != null ? !bundleId.equals(that.bundleId) : that.bundleId != null)
+        }
+        if (startDate.compareTo(that.startDate) != 0) {
             return false;
+        }
+        if (endDate.compareTo(that.endDate) != 0) {
+            return false;
+        }
+        if (!phaseName.equals(that.phaseName)) {
+            return false;
+        }
+        if (!planName.equals(that.planName)) {
+            return false;
+        }
+        if (rate.compareTo(that.rate) != 0) {
+            return false;
+        }
+        if (reversedItemId != null ? !reversedItemId.equals(that.reversedItemId) : that.reversedItemId != null) {
+            return false;
+        }
+        if (subscriptionId != null ? !subscriptionId.equals(that.subscriptionId) : that.subscriptionId != null) {
+            return false;
+        }
+        if (bundleId != null ? !bundleId.equals(that.bundleId) : that.bundleId != null) {
+            return false;
+        }
 
         return true;
     }
@@ -171,7 +195,7 @@ public class RecurringInvoiceItem extends InvoiceItemBase {
 
     @Override
     public String toString() {
-        StringBuilder sb = new StringBuilder();
+        final StringBuilder sb = new StringBuilder();
 
         sb.append(phaseName).append(", ");
         sb.append(startDate.toString()).append(", ");
diff --git a/invoice/src/main/java/com/ning/billing/invoice/model/RecurringInvoiceItemData.java b/invoice/src/main/java/com/ning/billing/invoice/model/RecurringInvoiceItemData.java
index d42c533..3d4a2d8 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/model/RecurringInvoiceItemData.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/model/RecurringInvoiceItemData.java
@@ -16,16 +16,16 @@
 
 package com.ning.billing.invoice.model;
 
-import org.joda.time.DateTime;
-
 import java.math.BigDecimal;
 
+import org.joda.time.DateTime;
+
 public class RecurringInvoiceItemData {
     private final DateTime startDate;
     private final DateTime endDate;
     private final BigDecimal numberOfCycles;
 
-    public RecurringInvoiceItemData(DateTime startDate, DateTime endDate, BigDecimal numberOfCycles) {
+    public RecurringInvoiceItemData(final DateTime startDate, final DateTime endDate, final BigDecimal numberOfCycles) {
         this.startDate = startDate;
         this.endDate = endDate;
         this.numberOfCycles = numberOfCycles;
diff --git a/invoice/src/main/java/com/ning/billing/invoice/notification/DefaultNextBillingDateNotifier.java b/invoice/src/main/java/com/ning/billing/invoice/notification/DefaultNextBillingDateNotifier.java
index 4418dd9..534ee0f 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/notification/DefaultNextBillingDateNotifier.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/notification/DefaultNextBillingDateNotifier.java
@@ -36,9 +36,9 @@ import com.ning.billing.util.notificationq.NotificationQueueService.NoSuchNotifi
 import com.ning.billing.util.notificationq.NotificationQueueService.NotificationQueueAlreadyExists;
 import com.ning.billing.util.notificationq.NotificationQueueService.NotificationQueueHandler;
 
-public class DefaultNextBillingDateNotifier implements  NextBillingDateNotifier {
+public class DefaultNextBillingDateNotifier implements NextBillingDateNotifier {
 
-    private final static Logger log = LoggerFactory.getLogger(DefaultNextBillingDateNotifier.class);
+    private static final Logger log = LoggerFactory.getLogger(DefaultNextBillingDateNotifier.class);
 
     public static final String NEXT_BILLING_DATE_NOTIFIER_QUEUE = "next-billing-date-queue";
 
@@ -51,8 +51,8 @@ public class DefaultNextBillingDateNotifier implements  NextBillingDateNotifier 
     private final InvoiceListener listener;
 
     @Inject
-    public DefaultNextBillingDateNotifier(NotificationQueueService notificationQueueService,
-            InvoiceConfig config, EntitlementUserApi entitlementUserApi, InvoiceListener listener){
+    public DefaultNextBillingDateNotifier(final NotificationQueueService notificationQueueService,
+                                          final InvoiceConfig config, final EntitlementUserApi entitlementUserApi, final InvoiceListener listener) {
         this.notificationQueueService = notificationQueueService;
         this.config = config;
         this.entitlementUserApi = entitlementUserApi;
@@ -62,41 +62,41 @@ public class DefaultNextBillingDateNotifier implements  NextBillingDateNotifier 
     @Override
     public void initialize() throws NotificationQueueAlreadyExists {
         nextBillingQueue = notificationQueueService.createNotificationQueue(DefaultInvoiceService.INVOICE_SERVICE_NAME,
-                NEXT_BILLING_DATE_NOTIFIER_QUEUE,
-                new NotificationQueueHandler() {
-            @Override
-            public void handleReadyNotification(String notificationKey, DateTime eventDate) {
-                try {
-                    UUID key = UUID.fromString(notificationKey);
-                    try {
-                        Subscription subscription = entitlementUserApi.getSubscriptionFromId(key);
-                        if (subscription == null) {
-                            log.warn("Next Billing Date Notification Queue handled spurious notification (key: " + key + ")" );
-                        } else {
-                            processEvent(key , eventDate);
-                        }
-                    } catch (EntitlementUserApiException e) {
-                        log.warn("Next Billing Date Notification Queue handled spurious notification (key: " + key + ")", e );
-                    }
-                } catch (IllegalArgumentException e) {
-                    log.error("The key returned from the NextBillingNotificationQueue is not a valid UUID", e);
-                    return;
-                }
-
-            }
-        },
-        new NotificationConfig() {
-
-            @Override
-            public long getSleepTimeMs() {
-                return config.getSleepTimeMs();
-            }
-
-            @Override
-            public boolean isNotificationProcessingOff() {
-                return config.isNotificationProcessingOff();
-            }
-        });
+                                                                            NEXT_BILLING_DATE_NOTIFIER_QUEUE,
+                                                                            new NotificationQueueHandler() {
+                                                                                @Override
+                                                                                public void handleReadyNotification(final String notificationKey, final DateTime eventDate) {
+                                                                                    try {
+                                                                                        final UUID key = UUID.fromString(notificationKey);
+                                                                                        try {
+                                                                                            final Subscription subscription = entitlementUserApi.getSubscriptionFromId(key);
+                                                                                            if (subscription == null) {
+                                                                                                log.warn("Next Billing Date Notification Queue handled spurious notification (key: " + key + ")");
+                                                                                            } else {
+                                                                                                processEvent(key, eventDate);
+                                                                                            }
+                                                                                        } catch (EntitlementUserApiException e) {
+                                                                                            log.warn("Next Billing Date Notification Queue handled spurious notification (key: " + key + ")", e);
+                                                                                        }
+                                                                                    } catch (IllegalArgumentException e) {
+                                                                                        log.error("The key returned from the NextBillingNotificationQueue is not a valid UUID", e);
+                                                                                    }
+
+                                                                                }
+                                                                            },
+                                                                            new NotificationConfig() {
+
+                                                                                @Override
+                                                                                public long getSleepTimeMs() {
+                                                                                    return config.getSleepTimeMs();
+                                                                                }
+
+                                                                                @Override
+                                                                                public boolean isNotificationProcessingOff() {
+                                                                                    return config.isNotificationProcessingOff();
+                                                                                }
+                                                                            }
+                                                                           );
 
     }
 
@@ -113,7 +113,7 @@ public class DefaultNextBillingDateNotifier implements  NextBillingDateNotifier 
         }
     }
 
-    private void processEvent(UUID subscriptionId, DateTime eventDateTime) {
+    private void processEvent(final UUID subscriptionId, final DateTime eventDateTime) {
         listener.handleNextBillingDateEvent(subscriptionId, eventDateTime);
     }
 
diff --git a/invoice/src/main/java/com/ning/billing/invoice/notification/DefaultNextBillingDatePoster.java b/invoice/src/main/java/com/ning/billing/invoice/notification/DefaultNextBillingDatePoster.java
index 4aad036..ffc08a3 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/notification/DefaultNextBillingDatePoster.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/notification/DefaultNextBillingDatePoster.java
@@ -31,34 +31,34 @@ import com.ning.billing.util.notificationq.NotificationQueueService;
 import com.ning.billing.util.notificationq.NotificationQueueService.NoSuchNotificationQueue;
 
 public class DefaultNextBillingDatePoster implements NextBillingDatePoster {
-    
-    private final static Logger log = LoggerFactory.getLogger(DefaultNextBillingDatePoster.class);
 
-	private final NotificationQueueService notificationQueueService;
+    private static final Logger log = LoggerFactory.getLogger(DefaultNextBillingDatePoster.class);
 
-	@Inject
+    private final NotificationQueueService notificationQueueService;
+
+    @Inject
     public DefaultNextBillingDatePoster(
-			NotificationQueueService notificationQueueService) {
-		super();
-		this.notificationQueueService = notificationQueueService;
-	}
+            final NotificationQueueService notificationQueueService) {
+        super();
+        this.notificationQueueService = notificationQueueService;
+    }
 
-	@Override
-	public void insertNextBillingNotification(final Transmogrifier transactionalDao, final UUID subscriptionId, final DateTime futureNotificationTime) {
-    	NotificationQueue nextBillingQueue;
-		try {
-			nextBillingQueue = notificationQueueService.getNotificationQueue(DefaultInvoiceService.INVOICE_SERVICE_NAME,
-					DefaultNextBillingDateNotifier.NEXT_BILLING_DATE_NOTIFIER_QUEUE);
-			 log.info("Queuing next billing date notification. id: {}, timestamp: {}", subscriptionId.toString(), futureNotificationTime.toString());
+    @Override
+    public void insertNextBillingNotification(final Transmogrifier transactionalDao, final UUID subscriptionId, final DateTime futureNotificationTime) {
+        final NotificationQueue nextBillingQueue;
+        try {
+            nextBillingQueue = notificationQueueService.getNotificationQueue(DefaultInvoiceService.INVOICE_SERVICE_NAME,
+                                                                             DefaultNextBillingDateNotifier.NEXT_BILLING_DATE_NOTIFIER_QUEUE);
+            log.info("Queuing next billing date notification. id: {}, timestamp: {}", subscriptionId.toString(), futureNotificationTime.toString());
 
-	            nextBillingQueue.recordFutureNotificationFromTransaction(transactionalDao, futureNotificationTime, new NotificationKey(){
-	                @Override
-	                public String toString() {
-	                    return subscriptionId.toString();
-	                }
-	    	    });
-		} catch (NoSuchNotificationQueue e) {
-			log.error("Attempting to put items on a non-existent queue (NextBillingDateNotifier).", e);
-		}
+            nextBillingQueue.recordFutureNotificationFromTransaction(transactionalDao, futureNotificationTime, new NotificationKey() {
+                @Override
+                public String toString() {
+                    return subscriptionId.toString();
+                }
+            });
+        } catch (NoSuchNotificationQueue e) {
+            log.error("Attempting to put items on a non-existent queue (NextBillingDateNotifier).", e);
+        }
     }
 }
diff --git a/invoice/src/main/java/com/ning/billing/invoice/notification/EmailInvoiceNotifier.java b/invoice/src/main/java/com/ning/billing/invoice/notification/EmailInvoiceNotifier.java
index 58026b2..22926e0 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/notification/EmailInvoiceNotifier.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/notification/EmailInvoiceNotifier.java
@@ -16,6 +16,10 @@
 
 package com.ning.billing.invoice.notification;
 
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
 import com.google.inject.Inject;
 import com.ning.billing.ErrorCode;
 import com.ning.billing.account.api.Account;
@@ -30,34 +34,30 @@ import com.ning.billing.util.email.EmailApiException;
 import com.ning.billing.util.email.EmailConfig;
 import com.ning.billing.util.email.EmailSender;
 
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.List;
-
 public class EmailInvoiceNotifier implements InvoiceNotifier {
     private final AccountUserApi accountUserApi;
     private final HtmlInvoiceGenerator generator;
     private final EmailConfig config;
 
     @Inject
-    public EmailInvoiceNotifier(AccountUserApi accountUserApi, HtmlInvoiceGenerator generator, EmailConfig config) {
+    public EmailInvoiceNotifier(final AccountUserApi accountUserApi, final HtmlInvoiceGenerator generator, final EmailConfig config) {
         this.accountUserApi = accountUserApi;
         this.generator = generator;
         this.config = config;
     }
 
     @Override
-    public void notify(Account account, Invoice invoice) throws InvoiceApiException {
-        List<String> to = new ArrayList<String>();
+    public void notify(final Account account, final Invoice invoice) throws InvoiceApiException {
+        final List<String> to = new ArrayList<String>();
         to.add(account.getEmail());
 
-        List<AccountEmail> accountEmailList = accountUserApi.getEmails(account.getId());
-        List<String> cc = new ArrayList<String>();
-        for (AccountEmail email : accountEmailList) {
+        final List<AccountEmail> accountEmailList = accountUserApi.getEmails(account.getId());
+        final List<String> cc = new ArrayList<String>();
+        for (final AccountEmail email : accountEmailList) {
             cc.add(email.getEmail());
         }
 
-        String htmlBody = null;
+        final String htmlBody;
         try {
             htmlBody = generator.generateInvoice(account, invoice, "HtmlInvoiceTemplate");
         } catch (IOException e) {
@@ -65,9 +65,9 @@ public class EmailInvoiceNotifier implements InvoiceNotifier {
         }
 
         // TODO: get subject
-        String subject = "";
+        final String subject = "";
 
-        EmailSender sender = new DefaultEmailSender(config);
+        final EmailSender sender = new DefaultEmailSender(config);
         try {
             sender.sendSecureEmail(to, cc, subject, htmlBody);
         } catch (EmailApiException e) {
diff --git a/invoice/src/main/java/com/ning/billing/invoice/notification/NextBillingDatePoster.java b/invoice/src/main/java/com/ning/billing/invoice/notification/NextBillingDatePoster.java
index 67598d1..279c61a 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/notification/NextBillingDatePoster.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/notification/NextBillingDatePoster.java
@@ -23,7 +23,7 @@ import org.skife.jdbi.v2.sqlobject.mixins.Transmogrifier;
 
 public interface NextBillingDatePoster {
 
-	void insertNextBillingNotification(Transmogrifier transactionalDao,
-			UUID subscriptionId, DateTime futureNotificationTime);
+    void insertNextBillingNotification(Transmogrifier transactionalDao,
+                                       UUID subscriptionId, DateTime futureNotificationTime);
 
-}
\ No newline at end of file
+}
diff --git a/invoice/src/main/java/com/ning/billing/invoice/notification/NullInvoiceNotifier.java b/invoice/src/main/java/com/ning/billing/invoice/notification/NullInvoiceNotifier.java
index 460e779..e0e44f7 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/notification/NullInvoiceNotifier.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/notification/NullInvoiceNotifier.java
@@ -22,7 +22,7 @@ import com.ning.billing.invoice.api.InvoiceNotifier;
 
 public class NullInvoiceNotifier implements InvoiceNotifier {
     @Override
-    public void notify(Account account, Invoice invoice) {
+    public void notify(final Account account, final Invoice invoice) {
         // deliberate no-op
     }
-}
\ No newline at end of file
+}
diff --git a/invoice/src/main/java/com/ning/billing/invoice/template/formatters/DefaultInvoiceFormatter.java b/invoice/src/main/java/com/ning/billing/invoice/template/formatters/DefaultInvoiceFormatter.java
index 1ca7824..098bde8 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/template/formatters/DefaultInvoiceFormatter.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/template/formatters/DefaultInvoiceFormatter.java
@@ -31,21 +31,22 @@
  */
 package com.ning.billing.invoice.template.formatters;
 
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+import java.util.UUID;
+
+import org.joda.time.DateTime;
+import org.joda.time.format.DateTimeFormat;
+import org.joda.time.format.DateTimeFormatter;
+
 import com.ning.billing.catalog.api.Currency;
 import com.ning.billing.invoice.api.Invoice;
 import com.ning.billing.invoice.api.InvoiceItem;
 import com.ning.billing.invoice.api.InvoicePayment;
 import com.ning.billing.invoice.api.formatters.InvoiceFormatter;
 import com.ning.billing.util.template.translation.TranslatorConfig;
-import org.joda.time.DateTime;
-import org.joda.time.format.DateTimeFormat;
-import org.joda.time.format.DateTimeFormatter;
-
-import java.math.BigDecimal;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Locale;
-import java.util.UUID;
 
 public class DefaultInvoiceFormatter implements InvoiceFormatter {
     private final TranslatorConfig config;
@@ -53,7 +54,7 @@ public class DefaultInvoiceFormatter implements InvoiceFormatter {
     private final DateTimeFormatter dateFormatter;
     private final Locale locale;
 
-    public DefaultInvoiceFormatter(TranslatorConfig config, Invoice invoice, Locale locale) {
+    public DefaultInvoiceFormatter(final TranslatorConfig config, final Invoice invoice, final Locale locale) {
         this.config = config;
         this.invoice = invoice;
         dateFormatter = DateTimeFormat.mediumDate().withLocale(locale);
@@ -67,25 +68,25 @@ public class DefaultInvoiceFormatter implements InvoiceFormatter {
 
     @Override
     public List<InvoiceItem> getInvoiceItems() {
-        List<InvoiceItem> formatters = new ArrayList<InvoiceItem>();
-        for (InvoiceItem item : invoice.getInvoiceItems()) {
+        final List<InvoiceItem> formatters = new ArrayList<InvoiceItem>();
+        for (final InvoiceItem item : invoice.getInvoiceItems()) {
             formatters.add(new DefaultInvoiceItemFormatter(config, item, dateFormatter, locale));
         }
         return formatters;
     }
 
     @Override
-    public boolean addInvoiceItem(InvoiceItem item) {
+    public boolean addInvoiceItem(final InvoiceItem item) {
         return invoice.addInvoiceItem(item);
     }
 
     @Override
-    public boolean addInvoiceItems(List<InvoiceItem> items) {
+    public boolean addInvoiceItems(final List<InvoiceItem> items) {
         return invoice.addInvoiceItems(items);
     }
 
     @Override
-    public <T extends InvoiceItem> List<InvoiceItem> getInvoiceItems(Class<T> clazz) {
+    public <T extends InvoiceItem> List<InvoiceItem> getInvoiceItems(final Class<T> clazz) {
         return invoice.getInvoiceItems(clazz);
     }
 
@@ -95,12 +96,12 @@ public class DefaultInvoiceFormatter implements InvoiceFormatter {
     }
 
     @Override
-    public boolean addPayment(InvoicePayment payment) {
+    public boolean addPayment(final InvoicePayment payment) {
         return invoice.addPayment(payment);
     }
 
     @Override
-    public boolean addPayments(List<InvoicePayment> payments) {
+    public boolean addPayments(final List<InvoicePayment> payments) {
         return invoice.addPayments(payments);
     }
 
@@ -135,7 +136,7 @@ public class DefaultInvoiceFormatter implements InvoiceFormatter {
     }
 
     @Override
-    public boolean isDueForPayment(DateTime targetDate, int numberOfDays) {
+    public boolean isDueForPayment(final DateTime targetDate, final int numberOfDays) {
         return invoice.isDueForPayment(targetDate, numberOfDays);
     }
 
diff --git a/invoice/src/main/java/com/ning/billing/invoice/template/formatters/DefaultInvoiceFormatterFactory.java b/invoice/src/main/java/com/ning/billing/invoice/template/formatters/DefaultInvoiceFormatterFactory.java
index 83c0619..99e62e9 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/template/formatters/DefaultInvoiceFormatterFactory.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/template/formatters/DefaultInvoiceFormatterFactory.java
@@ -16,16 +16,16 @@
 
 package com.ning.billing.invoice.template.formatters;
 
+import java.util.Locale;
+
 import com.ning.billing.invoice.api.Invoice;
 import com.ning.billing.invoice.api.formatters.InvoiceFormatter;
 import com.ning.billing.invoice.api.formatters.InvoiceFormatterFactory;
 import com.ning.billing.util.template.translation.TranslatorConfig;
 
-import java.util.Locale;
-
 public class DefaultInvoiceFormatterFactory implements InvoiceFormatterFactory {
     @Override
-    public InvoiceFormatter createInvoiceFormatter(TranslatorConfig config, Invoice invoice, Locale locale) {
+    public InvoiceFormatter createInvoiceFormatter(final TranslatorConfig config, final Invoice invoice, final Locale locale) {
         return new DefaultInvoiceFormatter(config, invoice, locale);
     }
 }
diff --git a/invoice/src/main/java/com/ning/billing/invoice/template/formatters/DefaultInvoiceItemFormatter.java b/invoice/src/main/java/com/ning/billing/invoice/template/formatters/DefaultInvoiceItemFormatter.java
index 9f49eb5..2dc8168 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/template/formatters/DefaultInvoiceItemFormatter.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/template/formatters/DefaultInvoiceItemFormatter.java
@@ -16,6 +16,13 @@
 
 package com.ning.billing.invoice.template.formatters;
 
+import java.math.BigDecimal;
+import java.util.Locale;
+import java.util.UUID;
+
+import org.joda.time.DateTime;
+import org.joda.time.format.DateTimeFormatter;
+
 import com.ning.billing.catalog.api.Currency;
 import com.ning.billing.invoice.api.InvoiceItem;
 import com.ning.billing.invoice.api.InvoiceItemType;
@@ -23,12 +30,6 @@ import com.ning.billing.invoice.api.formatters.InvoiceItemFormatter;
 import com.ning.billing.util.template.translation.DefaultCatalogTranslator;
 import com.ning.billing.util.template.translation.Translator;
 import com.ning.billing.util.template.translation.TranslatorConfig;
-import org.joda.time.DateTime;
-import org.joda.time.format.DateTimeFormatter;
-
-import java.math.BigDecimal;
-import java.util.Locale;
-import java.util.UUID;
 
 public class DefaultInvoiceItemFormatter implements InvoiceItemFormatter {
     private final Translator translator;
@@ -37,7 +38,7 @@ public class DefaultInvoiceItemFormatter implements InvoiceItemFormatter {
     private final DateTimeFormatter dateFormatter;
     private final Locale locale;
 
-    public DefaultInvoiceItemFormatter(TranslatorConfig config, InvoiceItem item, DateTimeFormatter dateFormatter, Locale locale) {
+    public DefaultInvoiceItemFormatter(final TranslatorConfig config, final InvoiceItem item, final DateTimeFormatter dateFormatter, final Locale locale) {
         this.item = item;
         this.dateFormatter = dateFormatter;
         this.locale = locale;
@@ -121,7 +122,7 @@ public class DefaultInvoiceItemFormatter implements InvoiceItemFormatter {
     }
 
     @Override
-    public int compareTo(InvoiceItem invoiceItem) {
+    public int compareTo(final InvoiceItem invoiceItem) {
         return item.compareTo(invoiceItem);
     }
 
@@ -129,4 +130,4 @@ public class DefaultInvoiceItemFormatter implements InvoiceItemFormatter {
     public UUID getId() {
         return item.getId();
     }
-}
\ No newline at end of file
+}
diff --git a/invoice/src/main/java/com/ning/billing/invoice/template/HtmlInvoiceGenerator.java b/invoice/src/main/java/com/ning/billing/invoice/template/HtmlInvoiceGenerator.java
index 2a006d8..ddfe39a 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/template/HtmlInvoiceGenerator.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/template/HtmlInvoiceGenerator.java
@@ -16,6 +16,11 @@
 
 package com.ning.billing.invoice.template;
 
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
+
 import com.google.inject.Inject;
 import com.ning.billing.account.api.Account;
 import com.ning.billing.invoice.api.Invoice;
@@ -25,35 +30,29 @@ import com.ning.billing.invoice.template.translator.DefaultInvoiceTranslator;
 import com.ning.billing.util.email.templates.TemplateEngine;
 import com.ning.billing.util.template.translation.TranslatorConfig;
 
-import java.io.IOException;
-import java.lang.String;
-import java.util.HashMap;
-import java.util.Locale;
-import java.util.Map;
-
 public class HtmlInvoiceGenerator {
     private final InvoiceFormatterFactory factory;
     private final TemplateEngine templateEngine;
     private final TranslatorConfig config;
 
     @Inject
-    public HtmlInvoiceGenerator(InvoiceFormatterFactory factory, TemplateEngine templateEngine, TranslatorConfig config) {
+    public HtmlInvoiceGenerator(final InvoiceFormatterFactory factory, final TemplateEngine templateEngine, final TranslatorConfig config) {
         this.factory = factory;
         this.templateEngine = templateEngine;
         this.config = config;
     }
 
-    public String generateInvoice(Account account, Invoice invoice, String templateName) throws IOException {
-        Map<String, Object> data = new HashMap<String, Object>();
-        DefaultInvoiceTranslator invoiceTranslator = new DefaultInvoiceTranslator(config);
-        Locale locale = new Locale(account.getLocale());
+    public String generateInvoice(final Account account, final Invoice invoice, final String templateName) throws IOException {
+        final Map<String, Object> data = new HashMap<String, Object>();
+        final DefaultInvoiceTranslator invoiceTranslator = new DefaultInvoiceTranslator(config);
+        final Locale locale = new Locale(account.getLocale());
         invoiceTranslator.setLocale(locale);
         data.put("text", invoiceTranslator);
         data.put("account", account);
 
-        InvoiceFormatter formattedInvoice = factory.createInvoiceFormatter(config, invoice, locale);
+        final InvoiceFormatter formattedInvoice = factory.createInvoiceFormatter(config, invoice, locale);
         data.put("invoice", formattedInvoice);
 
         return templateEngine.executeTemplate(templateName, data);
     }
-}
\ No newline at end of file
+}
diff --git a/invoice/src/main/java/com/ning/billing/invoice/template/translator/DefaultInvoiceTranslator.java b/invoice/src/main/java/com/ning/billing/invoice/template/translator/DefaultInvoiceTranslator.java
index f238ea7..9f46012 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/template/translator/DefaultInvoiceTranslator.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/template/translator/DefaultInvoiceTranslator.java
@@ -16,21 +16,21 @@
 
 package com.ning.billing.invoice.template.translator;
 
+import java.util.Locale;
+
 import com.google.inject.Inject;
 import com.ning.billing.util.template.translation.DefaultTranslatorBase;
 import com.ning.billing.util.template.translation.TranslatorConfig;
 
-import java.util.Locale;
-
 public class DefaultInvoiceTranslator extends DefaultTranslatorBase implements InvoiceStrings {
     private Locale locale;
 
     @Inject
-    public DefaultInvoiceTranslator(TranslatorConfig config) {
+    public DefaultInvoiceTranslator(final TranslatorConfig config) {
         super(config);
     }
 
-    public void setLocale(Locale locale) {
+    public void setLocale(final Locale locale) {
         this.locale = locale;
     }
 
diff --git a/invoice/src/main/java/com/ning/billing/invoice/template/translator/InvoiceStrings.java b/invoice/src/main/java/com/ning/billing/invoice/template/translator/InvoiceStrings.java
index cc19d5f..b76322b 100644
--- a/invoice/src/main/java/com/ning/billing/invoice/template/translator/InvoiceStrings.java
+++ b/invoice/src/main/java/com/ning/billing/invoice/template/translator/InvoiceStrings.java
@@ -18,25 +18,39 @@ package com.ning.billing.invoice.template.translator;
 
 public interface InvoiceStrings {
     String getInvoiceTitle();
+
     String getInvoiceDate();
+
     String getInvoiceNumber();
+
     String getAccountOwnerName();
+
     String getAccountOwnerEmail();
+
     String getAccountOwnerPhone();
 
     // company name and address
     String getCompanyName();
+
     String getCompanyAddress();
+
     String getCompanyCityProvincePostalCode();
+
     String getCompanyCountry();
+
     String getCompanyUrl();
 
     String getInvoiceItemBundleName();
+
     String getInvoiceItemDescription();
+
     String getInvoiceItemServicePeriod();
+
     String getInvoiceItemAmount();
 
     String getInvoiceAmount();
+
     String getInvoiceAmountPaid();
+
     String getInvoiceBalance();
 }
diff --git a/invoice/src/test/java/com/ning/billing/invoice/api/migration/MockModuleNoEntitlement.java b/invoice/src/test/java/com/ning/billing/invoice/api/migration/MockModuleNoEntitlement.java
index fe5d886..0bc2d9f 100644
--- a/invoice/src/test/java/com/ning/billing/invoice/api/migration/MockModuleNoEntitlement.java
+++ b/invoice/src/test/java/com/ning/billing/invoice/api/migration/MockModuleNoEntitlement.java
@@ -39,24 +39,24 @@ public class MockModuleNoEntitlement extends MockModule {
 //        ((ZombieControl)cta).addResult("setChargedThroughDateFromTransaction", BrainDeadProxyFactory.ZOMBIE_VOID);
 //	}
 
-	@Override
-	protected void installInvoiceModule() {
-		install(new DefaultInvoiceModule(){
-
-			@Override
-			protected void installNotifiers() {
-				 bind(NextBillingDateNotifier.class).toInstance(BrainDeadProxyFactory.createBrainDeadProxyFor(NextBillingDateNotifier.class));
-				 NextBillingDatePoster poster = BrainDeadProxyFactory.createBrainDeadProxyFor(NextBillingDatePoster.class);
-				 ((ZombieControl)poster).addResult("insertNextBillingNotification",BrainDeadProxyFactory.ZOMBIE_VOID);
-			     bind(NextBillingDatePoster.class).toInstance(poster);
+    @Override
+    protected void installInvoiceModule() {
+        install(new DefaultInvoiceModule() {
+
+            @Override
+            protected void installNotifiers() {
+                bind(NextBillingDateNotifier.class).toInstance(BrainDeadProxyFactory.createBrainDeadProxyFor(NextBillingDateNotifier.class));
+                final NextBillingDatePoster poster = BrainDeadProxyFactory.createBrainDeadProxyFor(NextBillingDatePoster.class);
+                ((ZombieControl) poster).addResult("insertNextBillingNotification", BrainDeadProxyFactory.ZOMBIE_VOID);
+                bind(NextBillingDatePoster.class).toInstance(poster);
                 bind(InvoiceNotifier.class).to(NullInvoiceNotifier.class).asEagerSingleton();
-			}
-			
-			
-		});
+            }
+
+
+        });
         install(new TemplateModule());
 
-		
-	}
+
+    }
 
 }
diff --git a/invoice/src/test/java/com/ning/billing/invoice/api/migration/TestDefaultInvoiceMigrationApi.java b/invoice/src/test/java/com/ning/billing/invoice/api/migration/TestDefaultInvoiceMigrationApi.java
index 05f7179..a1e17e1 100644
--- a/invoice/src/test/java/com/ning/billing/invoice/api/migration/TestDefaultInvoiceMigrationApi.java
+++ b/invoice/src/test/java/com/ning/billing/invoice/api/migration/TestDefaultInvoiceMigrationApi.java
@@ -72,192 +72,191 @@ import com.ning.billing.util.globallocker.GlobalLocker;
 
 @Guice(modules = {MockModuleNoEntitlement.class})
 public class TestDefaultInvoiceMigrationApi extends InvoicingTestBase {
-	Logger log = LoggerFactory.getLogger(TestDefaultInvoiceMigrationApi.class);
+    final Logger log = LoggerFactory.getLogger(TestDefaultInvoiceMigrationApi.class);
 
-	@Inject
-	InvoiceUserApi invoiceUserApi;
+    @Inject
+    InvoiceUserApi invoiceUserApi;
 
-	@Inject
-	InvoicePaymentApi invoicePaymentApi;
+    @Inject
+    InvoicePaymentApi invoicePaymentApi;
 
-	@Inject
-	private InvoiceGenerator generator;
-	@Inject
-	private InvoiceDao invoiceDao;
-	@Inject
-	private GlobalLocker locker;
+    @Inject
+    private InvoiceGenerator generator;
+    @Inject
+    private InvoiceDao invoiceDao;
+    @Inject
+    private GlobalLocker locker;
 
-	@Inject
-	private MysqlTestingHelper helper;
+    @Inject
+    private MysqlTestingHelper helper;
 
-	@Inject
-	private BusService busService;
+    @Inject
+    private BusService busService;
 
-	@Inject
-	private InvoiceMigrationApi migrationApi;
-	
-	@Inject
-	private BillingApi billingApi;
+    @Inject
+    private InvoiceMigrationApi migrationApi;
 
-	private UUID accountId ;
-	private UUID subscriptionId ;
-	private DateTime date_migrated;
-	private DateTime date_regular;
+    @Inject
+    private BillingApi billingApi;
 
-	private UUID migrationInvoiceId;
-	private UUID regularInvoiceId;
+    private UUID accountId;
+    private UUID subscriptionId;
+    private DateTime date_migrated;
+    private DateTime date_regular;
 
-	private static final BigDecimal MIGRATION_INVOICE_AMOUNT =  new BigDecimal("100.00");
-	private static final Currency MIGRATION_INVOICE_CURRENCY =  Currency.USD;
+    private UUID migrationInvoiceId;
+    private UUID regularInvoiceId;
+
+    private static final BigDecimal MIGRATION_INVOICE_AMOUNT = new BigDecimal("100.00");
+    private static final Currency MIGRATION_INVOICE_CURRENCY = Currency.USD;
 
     private final Clock clock = new ClockMock();
 
-	@BeforeClass(groups={"slow"})
-	public void setup() throws Exception
-	{
-		log.info("Starting set up");
-		accountId = UUID.randomUUID();
-		subscriptionId = UUID.randomUUID();
-		date_migrated = clock.getUTCNow().minusYears(1);
-		date_regular = clock.getUTCNow();
-
-		final String invoiceDdl = IOUtils.toString(TestInvoiceDispatcher.class.getResourceAsStream("/com/ning/billing/invoice/ddl.sql"));
-		final String utilDdl = IOUtils.toString(TestInvoiceDispatcher.class.getResourceAsStream("/com/ning/billing/util/ddl.sql"));
-
-		helper.startMysql();
-
-		helper.initDb(invoiceDdl);
-		helper.initDb(utilDdl);
-
-		busService.getBus().start();
-
-        ((ZombieControl)billingApi).addResult("setChargedThroughDate", BrainDeadProxyFactory.ZOMBIE_VOID);
-		migrationInvoiceId = createAndCheckMigrationInvoice();
-		regularInvoiceId = generateRegularInvoice();
-
-	}
-
-	@AfterClass(groups={"slow"})
-	public void tearDown() {
-		try {
-			((DefaultBusService) busService).stopBus();
-			helper.stopMysql();
-		} catch (Exception e) {
-			log.warn("Failed to tearDown test properly ", e);
-		}
-	}
-
-	private UUID createAndCheckMigrationInvoice(){
-		UUID migrationInvoiceId = migrationApi.createMigrationInvoice(accountId, date_migrated, MIGRATION_INVOICE_AMOUNT, MIGRATION_INVOICE_CURRENCY);
-		Assert.assertNotNull(migrationInvoiceId);
-		//Double check it was created and values are correct
-
-		Invoice invoice = invoiceDao.getById(migrationInvoiceId);
-		Assert.assertNotNull(invoice);
-
-		Assert.assertEquals(invoice.getAccountId(), accountId);
-		Assert.assertEquals(invoice.getTargetDate().compareTo(date_migrated), 0); //temp to avoid tz test artifact
-		//		Assert.assertEquals(invoice.getTargetDate(),now);
-		Assert.assertEquals(invoice.getNumberOfItems(), 1);
-		Assert.assertEquals(invoice.getInvoiceItems().get(0).getAmount().compareTo(MIGRATION_INVOICE_AMOUNT), 0 );
-		Assert.assertEquals(invoice.getBalance().compareTo(MIGRATION_INVOICE_AMOUNT),0);
-		Assert.assertEquals(invoice.getCurrency(), MIGRATION_INVOICE_CURRENCY);
-		Assert.assertTrue(invoice.isMigrationInvoice());
-
-		return migrationInvoiceId;
-	}
-
-	private UUID generateRegularInvoice()  throws Exception {
-		AccountUserApi accountUserApi = BrainDeadProxyFactory.createBrainDeadProxyFor(AccountUserApi.class);
-		Account account = BrainDeadProxyFactory.createBrainDeadProxyFor(Account.class);
-		((ZombieControl)accountUserApi).addResult("getAccountById", account);
-		((ZombieControl)account).addResult("getCurrency", Currency.USD);
-		((ZombieControl)account).addResult("getId", accountId);
-        ((ZombieControl)account).addResult("isNotifiedForInvoices", true);
-
-		Subscription subscription =  BrainDeadProxyFactory.createBrainDeadProxyFor(Subscription.class);
-        ((ZombieControl)subscription).addResult("getId", subscriptionId);
-        ((ZombieControl)subscription).addResult("getBundleId", new UUID(0L,0L));
-		BillingEventSet events = new MockBillingEventSet();
-		Plan plan = MockPlan.createBicycleNoTrialEvergreen1USD();
-		PlanPhase planPhase = MockPlanPhase.create1USDMonthlyEvergreen();
-		DateTime effectiveDate = new DateTime().minusDays(1);
-		Currency currency = Currency.USD;
-		BigDecimal fixedPrice = null;
-		events.add(createMockBillingEvent(account, subscription, effectiveDate, plan, planPhase,
-                fixedPrice, BigDecimal.ONE, currency, BillingPeriod.MONTHLY, 1,
-                BillingModeType.IN_ADVANCE, "", 1L, SubscriptionTransitionType.CREATE));
-
-		((ZombieControl)billingApi).addResult("getBillingEventsForAccountAndUpdateAccountBCD", events);
-
-        InvoiceNotifier invoiceNotifier = new NullInvoiceNotifier();
-		InvoiceDispatcher dispatcher = new InvoiceDispatcher(generator, accountUserApi, billingApi,
-                                                             invoiceDao, invoiceNotifier, locker, busService.getBus(), clock);
-
-        CallContext context = new DefaultCallContextFactory(clock).createCallContext("Migration test", CallOrigin.TEST, UserType.TEST);
-		Invoice invoice = dispatcher.processAccount(accountId, date_regular, true, context);
-		Assert.assertNotNull(invoice);
-
-		List<Invoice> invoices = invoiceDao.getInvoicesByAccount(accountId);
-		Assert.assertEquals(invoices.size(),0);
-
-		invoice = dispatcher.processAccount(accountId, date_regular, false, context);
-		Assert.assertNotNull(invoice);
-
-		invoices = invoiceDao.getInvoicesByAccount(accountId);
-		Assert.assertEquals(invoices.size(),1);
-
-		return invoice.getId();
-	}
-
-	// Check migration invoice is NOT returned for all user api invoice calls
-	@Test(groups={"slow"}, enabled=true)
-	public void testUserApiAccess(){
-		List<Invoice> byAccount = invoiceUserApi.getInvoicesByAccount(accountId);
-		Assert.assertEquals(byAccount.size(),1);
-		Assert.assertEquals(byAccount.get(0).getId(), regularInvoiceId);
-
-		List<Invoice> byAccountAndDate = invoiceUserApi.getInvoicesByAccount(accountId, date_migrated.minusDays(1));
-		Assert.assertEquals(byAccountAndDate.size(),1);
-		Assert.assertEquals(byAccountAndDate.get(0).getId(), regularInvoiceId);
-
-		Collection<Invoice> unpaid = invoiceUserApi.getUnpaidInvoicesByAccountId(accountId, date_regular.plusDays(1));
-		Assert.assertEquals(unpaid.size(), 1);
-		Assert.assertEquals(regularInvoiceId, unpaid.iterator().next().getId());
-
-	}
-
-
-	// Check migration invoice IS returned for payment api calls
-	@Test(groups={"slow"},enabled=true)
-	public void testPaymentApi(){
-		List<Invoice> allByAccount = invoicePaymentApi.getAllInvoicesByAccount(accountId);
-		Assert.assertEquals(allByAccount.size(),2);
-		Assert.assertTrue(checkContains(allByAccount, regularInvoiceId));
-		Assert.assertTrue(checkContains(allByAccount, migrationInvoiceId));
-	}
-
-
-	// ACCOUNT balance should reflect total of migration and non-migration invoices
-	@Test(groups={"slow"},enabled=true)
-	public void testBalance(){
-		Invoice migrationInvoice = invoiceDao.getById(migrationInvoiceId);
-		Invoice regularInvoice = invoiceDao.getById(regularInvoiceId);
-		BigDecimal balanceOfAllInvoices = migrationInvoice.getBalance().add(regularInvoice.getBalance());
-
-		BigDecimal accountBalance = invoiceUserApi.getAccountBalance(accountId);
-		System.out.println("ACCOUNT balance: " + accountBalance + " should equal the Balance Of All Invoices: " + balanceOfAllInvoices);
-		Assert.assertEquals(accountBalance.compareTo(balanceOfAllInvoices), 0);
-
-
-	}
-
-	private boolean checkContains(List<Invoice> invoices, UUID invoiceId) {
-		for(Invoice invoice : invoices) {
-			if(invoice.getId().equals(invoiceId)) {
-				return true;
-			}
-		}
-		return false;		
-	}
+    @BeforeClass(groups = {"slow"})
+    public void setup() throws Exception {
+        log.info("Starting set up");
+        accountId = UUID.randomUUID();
+        subscriptionId = UUID.randomUUID();
+        date_migrated = clock.getUTCNow().minusYears(1);
+        date_regular = clock.getUTCNow();
+
+        final String invoiceDdl = IOUtils.toString(TestInvoiceDispatcher.class.getResourceAsStream("/com/ning/billing/invoice/ddl.sql"));
+        final String utilDdl = IOUtils.toString(TestInvoiceDispatcher.class.getResourceAsStream("/com/ning/billing/util/ddl.sql"));
+
+        helper.startMysql();
+
+        helper.initDb(invoiceDdl);
+        helper.initDb(utilDdl);
+
+        busService.getBus().start();
+
+        ((ZombieControl) billingApi).addResult("setChargedThroughDate", BrainDeadProxyFactory.ZOMBIE_VOID);
+        migrationInvoiceId = createAndCheckMigrationInvoice();
+        regularInvoiceId = generateRegularInvoice();
+
+    }
+
+    @AfterClass(groups = {"slow"})
+    public void tearDown() {
+        try {
+            ((DefaultBusService) busService).stopBus();
+            helper.stopMysql();
+        } catch (Exception e) {
+            log.warn("Failed to tearDown test properly ", e);
+        }
+    }
+
+    private UUID createAndCheckMigrationInvoice() {
+        final UUID migrationInvoiceId = migrationApi.createMigrationInvoice(accountId, date_migrated, MIGRATION_INVOICE_AMOUNT, MIGRATION_INVOICE_CURRENCY);
+        Assert.assertNotNull(migrationInvoiceId);
+        //Double check it was created and values are correct
+
+        final Invoice invoice = invoiceDao.getById(migrationInvoiceId);
+        Assert.assertNotNull(invoice);
+
+        Assert.assertEquals(invoice.getAccountId(), accountId);
+        Assert.assertEquals(invoice.getTargetDate().compareTo(date_migrated), 0); //temp to avoid tz test artifact
+        //		Assert.assertEquals(invoice.getTargetDate(),now);
+        Assert.assertEquals(invoice.getNumberOfItems(), 1);
+        Assert.assertEquals(invoice.getInvoiceItems().get(0).getAmount().compareTo(MIGRATION_INVOICE_AMOUNT), 0);
+        Assert.assertEquals(invoice.getBalance().compareTo(MIGRATION_INVOICE_AMOUNT), 0);
+        Assert.assertEquals(invoice.getCurrency(), MIGRATION_INVOICE_CURRENCY);
+        Assert.assertTrue(invoice.isMigrationInvoice());
+
+        return migrationInvoiceId;
+    }
+
+    private UUID generateRegularInvoice() throws Exception {
+        final AccountUserApi accountUserApi = BrainDeadProxyFactory.createBrainDeadProxyFor(AccountUserApi.class);
+        final Account account = BrainDeadProxyFactory.createBrainDeadProxyFor(Account.class);
+        ((ZombieControl) accountUserApi).addResult("getAccountById", account);
+        ((ZombieControl) account).addResult("getCurrency", Currency.USD);
+        ((ZombieControl) account).addResult("getId", accountId);
+        ((ZombieControl) account).addResult("isNotifiedForInvoices", true);
+
+        final Subscription subscription = BrainDeadProxyFactory.createBrainDeadProxyFor(Subscription.class);
+        ((ZombieControl) subscription).addResult("getId", subscriptionId);
+        ((ZombieControl) subscription).addResult("getBundleId", new UUID(0L, 0L));
+        final BillingEventSet events = new MockBillingEventSet();
+        final Plan plan = MockPlan.createBicycleNoTrialEvergreen1USD();
+        final PlanPhase planPhase = MockPlanPhase.create1USDMonthlyEvergreen();
+        final DateTime effectiveDate = new DateTime().minusDays(1);
+        final Currency currency = Currency.USD;
+        final BigDecimal fixedPrice = null;
+        events.add(createMockBillingEvent(account, subscription, effectiveDate, plan, planPhase,
+                                          fixedPrice, BigDecimal.ONE, currency, BillingPeriod.MONTHLY, 1,
+                                          BillingModeType.IN_ADVANCE, "", 1L, SubscriptionTransitionType.CREATE));
+
+        ((ZombieControl) billingApi).addResult("getBillingEventsForAccountAndUpdateAccountBCD", events);
+
+        final InvoiceNotifier invoiceNotifier = new NullInvoiceNotifier();
+        final InvoiceDispatcher dispatcher = new InvoiceDispatcher(generator, accountUserApi, billingApi,
+                                                                   invoiceDao, invoiceNotifier, locker, busService.getBus(), clock);
+
+        final CallContext context = new DefaultCallContextFactory(clock).createCallContext("Migration test", CallOrigin.TEST, UserType.TEST);
+        Invoice invoice = dispatcher.processAccount(accountId, date_regular, true, context);
+        Assert.assertNotNull(invoice);
+
+        List<Invoice> invoices = invoiceDao.getInvoicesByAccount(accountId);
+        Assert.assertEquals(invoices.size(), 0);
+
+        invoice = dispatcher.processAccount(accountId, date_regular, false, context);
+        Assert.assertNotNull(invoice);
+
+        invoices = invoiceDao.getInvoicesByAccount(accountId);
+        Assert.assertEquals(invoices.size(), 1);
+
+        return invoice.getId();
+    }
+
+    // Check migration invoice is NOT returned for all user api invoice calls
+    @Test(groups = {"slow"}, enabled = true)
+    public void testUserApiAccess() {
+        final List<Invoice> byAccount = invoiceUserApi.getInvoicesByAccount(accountId);
+        Assert.assertEquals(byAccount.size(), 1);
+        Assert.assertEquals(byAccount.get(0).getId(), regularInvoiceId);
+
+        final List<Invoice> byAccountAndDate = invoiceUserApi.getInvoicesByAccount(accountId, date_migrated.minusDays(1));
+        Assert.assertEquals(byAccountAndDate.size(), 1);
+        Assert.assertEquals(byAccountAndDate.get(0).getId(), regularInvoiceId);
+
+        final Collection<Invoice> unpaid = invoiceUserApi.getUnpaidInvoicesByAccountId(accountId, date_regular.plusDays(1));
+        Assert.assertEquals(unpaid.size(), 1);
+        Assert.assertEquals(regularInvoiceId, unpaid.iterator().next().getId());
+
+    }
+
+
+    // Check migration invoice IS returned for payment api calls
+    @Test(groups = {"slow"}, enabled = true)
+    public void testPaymentApi() {
+        final List<Invoice> allByAccount = invoicePaymentApi.getAllInvoicesByAccount(accountId);
+        Assert.assertEquals(allByAccount.size(), 2);
+        Assert.assertTrue(checkContains(allByAccount, regularInvoiceId));
+        Assert.assertTrue(checkContains(allByAccount, migrationInvoiceId));
+    }
+
+
+    // ACCOUNT balance should reflect total of migration and non-migration invoices
+    @Test(groups = {"slow"}, enabled = true)
+    public void testBalance() {
+        final Invoice migrationInvoice = invoiceDao.getById(migrationInvoiceId);
+        final Invoice regularInvoice = invoiceDao.getById(regularInvoiceId);
+        final BigDecimal balanceOfAllInvoices = migrationInvoice.getBalance().add(regularInvoice.getBalance());
+
+        final BigDecimal accountBalance = invoiceUserApi.getAccountBalance(accountId);
+        System.out.println("ACCOUNT balance: " + accountBalance + " should equal the Balance Of All Invoices: " + balanceOfAllInvoices);
+        Assert.assertEquals(accountBalance.compareTo(balanceOfAllInvoices), 0);
+
+
+    }
+
+    private boolean checkContains(final List<Invoice> invoices, final UUID invoiceId) {
+        for (final Invoice invoice : invoices) {
+            if (invoice.getId().equals(invoiceId)) {
+                return true;
+            }
+        }
+        return false;
+    }
 }
diff --git a/invoice/src/test/java/com/ning/billing/invoice/api/MockInvoicePaymentApi.java b/invoice/src/test/java/com/ning/billing/invoice/api/MockInvoicePaymentApi.java
index 1bde0c6..e6349c9 100644
--- a/invoice/src/test/java/com/ning/billing/invoice/api/MockInvoicePaymentApi.java
+++ b/invoice/src/test/java/com/ning/billing/invoice/api/MockInvoicePaymentApi.java
@@ -23,24 +23,23 @@ import java.util.UUID;
 import java.util.concurrent.CopyOnWriteArrayList;
 
 import org.joda.time.DateTime;
+import org.joda.time.DateTimeZone;
 
 import com.ning.billing.catalog.api.Currency;
 import com.ning.billing.invoice.model.DefaultInvoicePayment;
 import com.ning.billing.util.callcontext.CallContext;
-import org.joda.time.DateTimeZone;
 
-public class MockInvoicePaymentApi implements InvoicePaymentApi
-{
+public class MockInvoicePaymentApi implements InvoicePaymentApi {
     private final CopyOnWriteArrayList<Invoice> invoices = new CopyOnWriteArrayList<Invoice>();
     private final CopyOnWriteArrayList<InvoicePayment> invoicePayments = new CopyOnWriteArrayList<InvoicePayment>();
 
-    public void add(Invoice invoice) {
+    public void add(final Invoice invoice) {
         invoices.add(invoice);
     }
 
     @Override
-    public void notifyOfPaymentAttempt(InvoicePayment invoicePayment, CallContext context) {
-        for (InvoicePayment existingInvoicePayment : invoicePayments) {
+    public void notifyOfPaymentAttempt(final InvoicePayment invoicePayment, final CallContext context) {
+        for (final InvoicePayment existingInvoicePayment : invoicePayments) {
             if (existingInvoicePayment.getInvoiceId().equals(invoicePayment.getInvoiceId()) && existingInvoicePayment.getPaymentAttemptId().equals(invoicePayment.getPaymentAttemptId())) {
                 invoicePayments.remove(existingInvoicePayment);
             }
@@ -49,10 +48,10 @@ public class MockInvoicePaymentApi implements InvoicePaymentApi
     }
 
     @Override
-    public List<Invoice> getAllInvoicesByAccount(UUID accountId) {
-        ArrayList<Invoice> result = new ArrayList<Invoice>();
+    public List<Invoice> getAllInvoicesByAccount(final UUID accountId) {
+        final ArrayList<Invoice> result = new ArrayList<Invoice>();
 
-        for (Invoice invoice : invoices) {
+        for (final Invoice invoice : invoices) {
             if (accountId.equals(invoice.getAccountId())) {
                 result.add(invoice);
             }
@@ -61,8 +60,8 @@ public class MockInvoicePaymentApi implements InvoicePaymentApi
     }
 
     @Override
-    public Invoice getInvoice(UUID invoiceId) {
-        for (Invoice invoice : invoices) {
+    public Invoice getInvoice(final UUID invoiceId) {
+        for (final Invoice invoice : invoices) {
             if (invoiceId.equals(invoice.getId())) {
                 return invoice;
             }
@@ -71,8 +70,8 @@ public class MockInvoicePaymentApi implements InvoicePaymentApi
     }
 
     @Override
-    public Invoice getInvoiceForPaymentAttemptId(UUID paymentAttemptId) {
-        for (InvoicePayment invoicePayment : invoicePayments) {
+    public Invoice getInvoiceForPaymentAttemptId(final UUID paymentAttemptId) {
+        for (final InvoicePayment invoicePayment : invoicePayments) {
             if (invoicePayment.getPaymentAttemptId().equals(paymentAttemptId)) {
                 return getInvoice(invoicePayment.getInvoiceId());
             }
@@ -81,8 +80,8 @@ public class MockInvoicePaymentApi implements InvoicePaymentApi
     }
 
     @Override
-    public InvoicePayment getInvoicePayment(UUID paymentAttemptId) {
-        for (InvoicePayment invoicePayment : invoicePayments) {
+    public InvoicePayment getInvoicePayment(final UUID paymentAttemptId) {
+        for (final InvoicePayment invoicePayment : invoicePayments) {
             if (paymentAttemptId.equals(invoicePayment.getPaymentAttemptId())) {
                 return invoicePayment;
             }
@@ -91,22 +90,22 @@ public class MockInvoicePaymentApi implements InvoicePaymentApi
     }
 
     @Override
-    public void notifyOfPaymentAttempt(UUID invoiceId, BigDecimal amountOutstanding, Currency currency, UUID paymentAttemptId, DateTime paymentAttemptDate, CallContext context) {
-        InvoicePayment invoicePayment = new DefaultInvoicePayment(paymentAttemptId, invoiceId, paymentAttemptDate, amountOutstanding, currency);
+    public void notifyOfPaymentAttempt(final UUID invoiceId, final BigDecimal amountOutstanding, final Currency currency, final UUID paymentAttemptId, final DateTime paymentAttemptDate, final CallContext context) {
+        final InvoicePayment invoicePayment = new DefaultInvoicePayment(paymentAttemptId, invoiceId, paymentAttemptDate, amountOutstanding, currency);
         notifyOfPaymentAttempt(invoicePayment, context);
     }
 
     @Override
-    public void notifyOfPaymentAttempt(UUID invoiceId, UUID paymentAttemptId, DateTime paymentAttemptDate, CallContext context) {
-        InvoicePayment invoicePayment = new DefaultInvoicePayment(paymentAttemptId, invoiceId, paymentAttemptDate);
+    public void notifyOfPaymentAttempt(final UUID invoiceId, final UUID paymentAttemptId, final DateTime paymentAttemptDate, final CallContext context) {
+        final InvoicePayment invoicePayment = new DefaultInvoicePayment(paymentAttemptId, invoiceId, paymentAttemptDate);
         notifyOfPaymentAttempt(invoicePayment, context);
     }
 
     @Override
-    public void processChargeback(UUID invoicePaymentId, BigDecimal amount, CallContext context) throws InvoiceApiException {
+    public void processChargeback(final UUID invoicePaymentId, final BigDecimal amount, final CallContext context) throws InvoiceApiException {
         InvoicePayment existingPayment = null;
-        for (InvoicePayment payment : invoicePayments) {
-            if (payment.getId()  == invoicePaymentId) {
+        for (final InvoicePayment payment : invoicePayments) {
+            if (payment.getId() == invoicePaymentId) {
                 existingPayment = payment;
             }
         }
@@ -117,10 +116,10 @@ public class MockInvoicePaymentApi implements InvoicePaymentApi
     }
 
     @Override
-    public void processChargeback(UUID invoicePaymentId, CallContext context) throws InvoiceApiException {
+    public void processChargeback(final UUID invoicePaymentId, final CallContext context) throws InvoiceApiException {
         InvoicePayment existingPayment = null;
-        for (InvoicePayment payment : invoicePayments) {
-            if (payment.getId()  == invoicePaymentId) {
+        for (final InvoicePayment payment : invoicePayments) {
+            if (payment.getId() == invoicePaymentId) {
                 existingPayment = payment;
             }
         }
@@ -131,9 +130,9 @@ public class MockInvoicePaymentApi implements InvoicePaymentApi
     }
 
     @Override
-    public BigDecimal getRemainingAmountPaid(UUID invoicePaymentId) {
+    public BigDecimal getRemainingAmountPaid(final UUID invoicePaymentId) {
         BigDecimal amount = BigDecimal.ZERO;
-        for (InvoicePayment payment : invoicePayments) {
+        for (final InvoicePayment payment : invoicePayments) {
             if (payment.getId().equals(invoicePaymentId)) {
                 amount = amount.add(payment.getAmount());
             }
@@ -147,22 +146,22 @@ public class MockInvoicePaymentApi implements InvoicePaymentApi
     }
 
     @Override
-    public List<InvoicePayment> getChargebacksByAccountId(UUID accountId) {
+    public List<InvoicePayment> getChargebacksByAccountId(final UUID accountId) {
         throw new UnsupportedOperationException();
     }
 
     @Override
-    public UUID getAccountIdFromInvoicePaymentId(UUID uuid) throws InvoiceApiException {
+    public UUID getAccountIdFromInvoicePaymentId(final UUID uuid) throws InvoiceApiException {
         throw new UnsupportedOperationException();
     }
 
     @Override
-    public List<InvoicePayment> getChargebacksByPaymentAttemptId(UUID paymentAttemptId) {
+    public List<InvoicePayment> getChargebacksByPaymentAttemptId(final UUID paymentAttemptId) {
         throw new UnsupportedOperationException();
     }
 
     @Override
-    public InvoicePayment getChargebackById(UUID chargebackId) {
+    public InvoicePayment getChargebackById(final UUID chargebackId) {
         throw new UnsupportedOperationException();
     }
 }
diff --git a/invoice/src/test/java/com/ning/billing/invoice/api/user/TestEventJson.java b/invoice/src/test/java/com/ning/billing/invoice/api/user/TestEventJson.java
index f2d9282..404255b 100644
--- a/invoice/src/test/java/com/ning/billing/invoice/api/user/TestEventJson.java
+++ b/invoice/src/test/java/com/ning/billing/invoice/api/user/TestEventJson.java
@@ -18,7 +18,6 @@ package com.ning.billing.invoice.api.user;
 import java.math.BigDecimal;
 import java.util.UUID;
 
-import com.ning.billing.util.jackson.ObjectMapper;
 import org.joda.time.DateTime;
 import org.testng.Assert;
 import org.testng.annotations.Test;
@@ -26,31 +25,32 @@ import org.testng.annotations.Test;
 import com.ning.billing.catalog.api.Currency;
 import com.ning.billing.invoice.api.EmptyInvoiceEvent;
 import com.ning.billing.invoice.api.InvoiceCreationEvent;
+import com.ning.billing.util.jackson.ObjectMapper;
 
 public class TestEventJson {
     private final ObjectMapper mapper = new ObjectMapper();
 
-    @Test(groups= {"fast"})
+    @Test(groups = {"fast"})
     public void testInvoiceCreationEvent() throws Exception {
 
-        InvoiceCreationEvent e = new DefaultInvoiceCreationEvent(UUID.randomUUID(), UUID.randomUUID(), new BigDecimal(12.0), Currency.USD, new DateTime(), UUID.randomUUID());
+        final InvoiceCreationEvent e = new DefaultInvoiceCreationEvent(UUID.randomUUID(), UUID.randomUUID(), new BigDecimal(12.0), Currency.USD, new DateTime(), UUID.randomUUID());
 
-        String json = mapper.writeValueAsString(e);
+        final String json = mapper.writeValueAsString(e);
 
-        Class<?> claz = Class.forName(DefaultInvoiceCreationEvent.class.getName());
-        Object obj =  mapper.readValue(json, claz);
+        final Class<?> claz = Class.forName(DefaultInvoiceCreationEvent.class.getName());
+        final Object obj = mapper.readValue(json, claz);
         Assert.assertTrue(obj.equals(e));
     }
 
-    @Test(groups= {"fast"})
+    @Test(groups = {"fast"})
     public void testEmptyInvoiceEvent() throws Exception {
 
-        EmptyInvoiceEvent e = new DefaultEmptyInvoiceEvent(UUID.randomUUID(), new DateTime(), UUID.randomUUID());
+        final EmptyInvoiceEvent e = new DefaultEmptyInvoiceEvent(UUID.randomUUID(), new DateTime(), UUID.randomUUID());
 
-        String json = mapper.writeValueAsString(e);
+        final String json = mapper.writeValueAsString(e);
 
-        Class<?> claz = Class.forName(DefaultEmptyInvoiceEvent.class.getName());
-        Object obj =  mapper.readValue(json, claz);
+        final Class<?> claz = Class.forName(DefaultEmptyInvoiceEvent.class.getName());
+        final Object obj = mapper.readValue(json, claz);
         Assert.assertTrue(obj.equals(e));
     }
 }
diff --git a/invoice/src/test/java/com/ning/billing/invoice/dao/InvoiceDaoTestBase.java b/invoice/src/test/java/com/ning/billing/invoice/dao/InvoiceDaoTestBase.java
index 4c4677e..b0718db 100644
--- a/invoice/src/test/java/com/ning/billing/invoice/dao/InvoiceDaoTestBase.java
+++ b/invoice/src/test/java/com/ning/billing/invoice/dao/InvoiceDaoTestBase.java
@@ -16,23 +16,8 @@
 
 package com.ning.billing.invoice.dao;
 
-import static org.testng.Assert.assertTrue;
-
 import java.io.IOException;
 
-import com.ning.billing.dbi.MysqlTestingHelper;
-import com.ning.billing.invoice.notification.MockNextBillingDatePoster;
-import com.ning.billing.invoice.notification.NextBillingDatePoster;
-import com.ning.billing.util.api.TagUserApi;
-import com.ning.billing.util.bus.Bus;
-import com.ning.billing.util.bus.InMemoryBus;
-import com.ning.billing.util.callcontext.TestCallContext;
-import com.ning.billing.util.clock.ClockMock;
-import com.ning.billing.util.tag.api.DefaultTagUserApi;
-import com.ning.billing.util.tag.api.user.TagEventBuilder;
-import com.ning.billing.util.tag.dao.AuditedTagDao;
-import com.ning.billing.util.tag.dao.MockTagDefinitionDao;
-import com.ning.billing.util.tag.dao.TagDao;
 import org.apache.commons.io.IOUtils;
 import org.skife.jdbi.v2.Handle;
 import org.skife.jdbi.v2.IDBI;
@@ -43,13 +28,28 @@ import org.testng.annotations.BeforeClass;
 import org.testng.annotations.BeforeMethod;
 
 import com.ning.billing.config.InvoiceConfig;
+import com.ning.billing.dbi.MysqlTestingHelper;
 import com.ning.billing.invoice.model.DefaultInvoiceGenerator;
 import com.ning.billing.invoice.model.InvoiceGenerator;
+import com.ning.billing.invoice.notification.MockNextBillingDatePoster;
+import com.ning.billing.invoice.notification.NextBillingDatePoster;
 import com.ning.billing.invoice.tests.InvoicingTestBase;
+import com.ning.billing.util.api.TagUserApi;
+import com.ning.billing.util.bus.Bus;
+import com.ning.billing.util.bus.InMemoryBus;
 import com.ning.billing.util.callcontext.CallContext;
+import com.ning.billing.util.callcontext.TestCallContext;
 import com.ning.billing.util.clock.Clock;
+import com.ning.billing.util.clock.ClockMock;
+import com.ning.billing.util.tag.api.DefaultTagUserApi;
+import com.ning.billing.util.tag.api.user.TagEventBuilder;
+import com.ning.billing.util.tag.dao.AuditedTagDao;
+import com.ning.billing.util.tag.dao.MockTagDefinitionDao;
+import com.ning.billing.util.tag.dao.TagDao;
 import com.ning.billing.util.tag.dao.TagDefinitionDao;
 
+import static org.testng.Assert.assertTrue;
+
 public abstract class InvoiceDaoTestBase extends InvoicingTestBase {
     protected final TagEventBuilder tagEventBuilder = new TagEventBuilder();
 
@@ -67,11 +67,19 @@ public abstract class InvoiceDaoTestBase extends InvoicingTestBase {
 
     private final InvoiceConfig invoiceConfig = new InvoiceConfig() {
         @Override
-        public long getSleepTimeMs() {throw new UnsupportedOperationException();}
+        public long getSleepTimeMs() {
+            throw new UnsupportedOperationException();
+        }
+
         @Override
-        public boolean isNotificationProcessingOff() {throw new UnsupportedOperationException();}
+        public boolean isNotificationProcessingOff() {
+            throw new UnsupportedOperationException();
+        }
+
         @Override
-        public int getNumberOfMonthsInFuture() {return 36;}
+        public int getNumberOfMonthsInFuture() {
+            return 36;
+        }
     };
 
     @BeforeClass(alwaysRun = true)
@@ -86,7 +94,7 @@ public abstract class InvoiceDaoTestBase extends InvoicingTestBase {
         mysqlTestingHelper.initDb(invoiceDdl);
         mysqlTestingHelper.initDb(utilDdl);
 
-        NextBillingDatePoster nextBillingDatePoster = new MockNextBillingDatePoster();
+        final NextBillingDatePoster nextBillingDatePoster = new MockNextBillingDatePoster();
         final TagDefinitionDao tagDefinitionDao = new MockTagDefinitionDao();
         final TagDao tagDao = new AuditedTagDao(dbi, tagEventBuilder, bus);
         final TagUserApi tagUserApi = new DefaultTagUserApi(tagDefinitionDao, tagDao);
@@ -111,7 +119,7 @@ public abstract class InvoiceDaoTestBase extends InvoicingTestBase {
     public void cleanupData() {
         dbi.inTransaction(new TransactionCallback<Void>() {
             @Override
-            public Void inTransaction(Handle h, TransactionStatus status)
+            public Void inTransaction(final Handle h, final TransactionStatus status)
                     throws Exception {
                 h.execute("truncate table invoices");
                 h.execute("truncate table fixed_invoice_items");
diff --git a/invoice/src/test/java/com/ning/billing/invoice/dao/InvoiceDaoTests.java b/invoice/src/test/java/com/ning/billing/invoice/dao/InvoiceDaoTests.java
index a47a518..44895f2 100644
--- a/invoice/src/test/java/com/ning/billing/invoice/dao/InvoiceDaoTests.java
+++ b/invoice/src/test/java/com/ning/billing/invoice/dao/InvoiceDaoTests.java
@@ -16,11 +16,6 @@
 
 package com.ning.billing.invoice.dao;
 
-import static org.testng.Assert.assertEquals;
-import static org.testng.Assert.assertNotNull;
-import static org.testng.Assert.assertNull;
-import static org.testng.Assert.assertTrue;
-
 import java.math.BigDecimal;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -63,20 +58,25 @@ import com.ning.billing.util.tag.Tag;
 import com.ning.billing.util.tag.dao.AuditedTagDao;
 import com.ning.billing.util.tag.dao.TagDao;
 
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertNotNull;
+import static org.testng.Assert.assertNull;
+import static org.testng.Assert.assertTrue;
+
 @Test(groups = {"slow", "invoicing", "invoicing-invoiceDao"})
 public class InvoiceDaoTests extends InvoiceDaoTestBase {
     @Test
     public void testCreationAndRetrievalByAccount() {
-        UUID accountId = UUID.randomUUID();
-        Invoice invoice = new DefaultInvoice(accountId, clock.getUTCNow(), clock.getUTCNow(), Currency.USD);
-        DateTime invoiceDate = invoice.getInvoiceDate();
+        final UUID accountId = UUID.randomUUID();
+        final Invoice invoice = new DefaultInvoice(accountId, clock.getUTCNow(), clock.getUTCNow(), Currency.USD);
+        final DateTime invoiceDate = invoice.getInvoiceDate();
 
         invoiceDao.create(invoice, context);
 
-        List<Invoice> invoices = invoiceDao.getInvoicesByAccount(accountId);
+        final List<Invoice> invoices = invoiceDao.getInvoicesByAccount(accountId);
         assertNotNull(invoices);
         assertEquals(invoices.size(), 1);
-        Invoice thisInvoice = invoices.get(0);
+        final Invoice thisInvoice = invoices.get(0);
         assertEquals(invoice.getAccountId(), accountId);
         assertTrue(thisInvoice.getInvoiceDate().compareTo(invoiceDate) == 0);
         assertEquals(thisInvoice.getCurrency(), Currency.USD);
@@ -86,32 +86,32 @@ public class InvoiceDaoTests extends InvoiceDaoTestBase {
 
     @Test
     public void testInvoicePayment() {
-        UUID accountId = UUID.randomUUID();
-        Invoice invoice = new DefaultInvoice(accountId, clock.getUTCNow(), clock.getUTCNow(), Currency.USD);
-        UUID invoiceId = invoice.getId();
-        UUID subscriptionId = UUID.randomUUID();
-        UUID bundleId = UUID.randomUUID();
-        DateTime startDate = new DateTime(2010, 1, 1, 0, 0, 0, 0);
-        DateTime endDate = new DateTime(2010, 4, 1, 0, 0, 0, 0);
-        InvoiceItem invoiceItem = new RecurringInvoiceItem(invoiceId, accountId, bundleId,subscriptionId, "test plan", "test phase", startDate, endDate,
-                new BigDecimal("21.00"), new BigDecimal("7.00"), Currency.USD);
+        final UUID accountId = UUID.randomUUID();
+        final Invoice invoice = new DefaultInvoice(accountId, clock.getUTCNow(), clock.getUTCNow(), Currency.USD);
+        final UUID invoiceId = invoice.getId();
+        final UUID subscriptionId = UUID.randomUUID();
+        final UUID bundleId = UUID.randomUUID();
+        final DateTime startDate = new DateTime(2010, 1, 1, 0, 0, 0, 0);
+        final DateTime endDate = new DateTime(2010, 4, 1, 0, 0, 0, 0);
+        final InvoiceItem invoiceItem = new RecurringInvoiceItem(invoiceId, accountId, bundleId, subscriptionId, "test plan", "test phase", startDate, endDate,
+                                                                 new BigDecimal("21.00"), new BigDecimal("7.00"), Currency.USD);
 
         invoice.addInvoiceItem(invoiceItem);
         invoiceDao.create(invoice, context);
 
-        Invoice savedInvoice = invoiceDao.getById(invoiceId);
+        final Invoice savedInvoice = invoiceDao.getById(invoiceId);
         assertNotNull(savedInvoice);
         assertEquals(savedInvoice.getBalance().compareTo(new BigDecimal("21.00")), 0);
         assertEquals(savedInvoice.getBalance().compareTo(new BigDecimal("21.00")), 0);
         assertEquals(savedInvoice.getAmountPaid(), BigDecimal.ZERO);
         assertEquals(savedInvoice.getInvoiceItems().size(), 1);
 
-        BigDecimal paymentAmount = new BigDecimal("11.00");
-        UUID paymentAttemptId = UUID.randomUUID();
+        final BigDecimal paymentAmount = new BigDecimal("11.00");
+        final UUID paymentAttemptId = UUID.randomUUID();
 
         invoiceDao.notifyOfPaymentAttempt(new DefaultInvoicePayment(paymentAttemptId, invoiceId, clock.getUTCNow().plusDays(12), paymentAmount, Currency.USD), context);
 
-        Invoice retrievedInvoice = invoiceDao.getById(invoiceId);
+        final Invoice retrievedInvoice = invoiceDao.getById(invoiceId);
         assertNotNull(retrievedInvoice);
         assertEquals(retrievedInvoice.getInvoiceItems().size(), 1);
         assertEquals(retrievedInvoice.getAmountCharged().compareTo(new BigDecimal("21.00")), 0);
@@ -121,19 +121,19 @@ public class InvoiceDaoTests extends InvoiceDaoTestBase {
 
     @Test
     public void testRetrievalForNonExistentInvoiceId() {
-        Invoice invoice = invoiceDao.getById(UUID.randomUUID());
+        final Invoice invoice = invoiceDao.getById(UUID.randomUUID());
         assertNull(invoice);
     }
 
     @Test
     public void testAddPayment() {
-        UUID accountId = UUID.randomUUID();
-        DateTime targetDate = new DateTime(2011, 10, 6, 0, 0, 0, 0);
+        final UUID accountId = UUID.randomUUID();
+        final DateTime targetDate = new DateTime(2011, 10, 6, 0, 0, 0, 0);
         Invoice invoice = new DefaultInvoice(accountId, clock.getUTCNow(), targetDate, Currency.USD);
 
-        UUID paymentAttemptId = UUID.randomUUID();
-        DateTime paymentAttemptDate = new DateTime(2011, 6, 24, 12, 14, 36, 0);
-        BigDecimal paymentAmount = new BigDecimal("14.0");
+        final UUID paymentAttemptId = UUID.randomUUID();
+        final DateTime paymentAttemptDate = new DateTime(2011, 6, 24, 12, 14, 36, 0);
+        final BigDecimal paymentAmount = new BigDecimal("14.0");
 
         invoiceDao.create(invoice, context);
         invoiceDao.notifyOfPaymentAttempt(new DefaultInvoicePayment(paymentAttemptId, invoice.getId(), paymentAttemptDate, paymentAmount, Currency.USD), context);
@@ -146,11 +146,11 @@ public class InvoiceDaoTests extends InvoiceDaoTestBase {
 
     @Test
     public void testAddPaymentAttempt() {
-        UUID accountId = UUID.randomUUID();
-        DateTime targetDate = new DateTime(2011, 10, 6, 0, 0, 0, 0);
+        final UUID accountId = UUID.randomUUID();
+        final DateTime targetDate = new DateTime(2011, 10, 6, 0, 0, 0, 0);
         Invoice invoice = new DefaultInvoice(accountId, clock.getUTCNow(), targetDate, Currency.USD);
 
-        DateTime paymentAttemptDate = new DateTime(2011, 6, 24, 12, 14, 36, 0);
+        final DateTime paymentAttemptDate = new DateTime(2011, 6, 24, 12, 14, 36, 0);
 
         invoiceDao.create(invoice, context);
         invoiceDao.notifyOfPaymentAttempt(new DefaultInvoicePayment(UUID.randomUUID(), invoice.getId(), paymentAttemptDate), context);
@@ -161,92 +161,92 @@ public class InvoiceDaoTests extends InvoiceDaoTestBase {
 
     @Test
     public void testGetInvoicesBySubscription() {
-        UUID accountId = UUID.randomUUID();
-        UUID bundleId = UUID.randomUUID();
+        final UUID accountId = UUID.randomUUID();
+        final UUID bundleId = UUID.randomUUID();
 
-        UUID subscriptionId1 = UUID.randomUUID();
-        BigDecimal rate1 = new BigDecimal("17.0");
-        UUID subscriptionId2 = UUID.randomUUID();
-        BigDecimal rate2 = new BigDecimal("42.0");
-        UUID subscriptionId3 = UUID.randomUUID();
-        BigDecimal rate3 = new BigDecimal("3.0");
-        UUID subscriptionId4 = UUID.randomUUID();
-        BigDecimal rate4 = new BigDecimal("12.0");
+        final UUID subscriptionId1 = UUID.randomUUID();
+        final BigDecimal rate1 = new BigDecimal("17.0");
+        final UUID subscriptionId2 = UUID.randomUUID();
+        final BigDecimal rate2 = new BigDecimal("42.0");
+        final UUID subscriptionId3 = UUID.randomUUID();
+        final BigDecimal rate3 = new BigDecimal("3.0");
+        final UUID subscriptionId4 = UUID.randomUUID();
+        final BigDecimal rate4 = new BigDecimal("12.0");
 
-        DateTime targetDate = new DateTime(2011, 5, 23, 0, 0, 0, 0);
+        final DateTime targetDate = new DateTime(2011, 5, 23, 0, 0, 0, 0);
 
 
         // create invoice 1 (subscriptions 1-4)
-        Invoice invoice1 = new DefaultInvoice(accountId, clock.getUTCNow(), targetDate, Currency.USD);
+        final Invoice invoice1 = new DefaultInvoice(accountId, clock.getUTCNow(), targetDate, Currency.USD);
         invoiceDao.create(invoice1, context);
 
-        UUID invoiceId1 = invoice1.getId();
+        final UUID invoiceId1 = invoice1.getId();
 
         DateTime startDate = new DateTime(2011, 3, 1, 0, 0, 0, 0);
         DateTime endDate = startDate.plusMonths(1);
 
 
-        RecurringInvoiceItem item1 = new RecurringInvoiceItem(invoiceId1, accountId, bundleId,subscriptionId1, "test plan", "test A", startDate, endDate,
-                rate1, rate1, Currency.USD);
+        final RecurringInvoiceItem item1 = new RecurringInvoiceItem(invoiceId1, accountId, bundleId, subscriptionId1, "test plan", "test A", startDate, endDate,
+                                                                    rate1, rate1, Currency.USD);
         recurringInvoiceItemDao.create(item1, context);
 
-        RecurringInvoiceItem item2 = new RecurringInvoiceItem(invoiceId1, accountId, bundleId,subscriptionId2, "test plan", "test B", startDate, endDate,
-                rate2, rate2, Currency.USD);
+        final RecurringInvoiceItem item2 = new RecurringInvoiceItem(invoiceId1, accountId, bundleId, subscriptionId2, "test plan", "test B", startDate, endDate,
+                                                                    rate2, rate2, Currency.USD);
         recurringInvoiceItemDao.create(item2, context);
 
-        RecurringInvoiceItem item3 = new RecurringInvoiceItem(invoiceId1, accountId, bundleId,subscriptionId3, "test plan", "test C", startDate, endDate,
-                rate3, rate3, Currency.USD);
+        final RecurringInvoiceItem item3 = new RecurringInvoiceItem(invoiceId1, accountId, bundleId, subscriptionId3, "test plan", "test C", startDate, endDate,
+                                                                    rate3, rate3, Currency.USD);
         recurringInvoiceItemDao.create(item3, context);
 
-        RecurringInvoiceItem item4 = new RecurringInvoiceItem(invoiceId1, accountId, bundleId,subscriptionId4, "test plan", "test D", startDate, endDate,
-                rate4, rate4, Currency.USD);
+        final RecurringInvoiceItem item4 = new RecurringInvoiceItem(invoiceId1, accountId, bundleId, subscriptionId4, "test plan", "test D", startDate, endDate,
+                                                                    rate4, rate4, Currency.USD);
         recurringInvoiceItemDao.create(item4, context);
 
         // create invoice 2 (subscriptions 1-3)
-        DefaultInvoice invoice2 = new DefaultInvoice(accountId, clock.getUTCNow(), targetDate, Currency.USD);
+        final DefaultInvoice invoice2 = new DefaultInvoice(accountId, clock.getUTCNow(), targetDate, Currency.USD);
         invoiceDao.create(invoice2, context);
 
-        UUID invoiceId2 = invoice2.getId();
+        final UUID invoiceId2 = invoice2.getId();
 
         startDate = endDate;
         endDate = startDate.plusMonths(1);
 
 
-        RecurringInvoiceItem item5 = new RecurringInvoiceItem(invoiceId2, accountId, bundleId,subscriptionId1, "test plan", "test phase A", startDate, endDate,
-                rate1, rate1, Currency.USD);
+        final RecurringInvoiceItem item5 = new RecurringInvoiceItem(invoiceId2, accountId, bundleId, subscriptionId1, "test plan", "test phase A", startDate, endDate,
+                                                                    rate1, rate1, Currency.USD);
         recurringInvoiceItemDao.create(item5, context);
 
-        RecurringInvoiceItem item6 = new RecurringInvoiceItem(invoiceId2, accountId, bundleId,subscriptionId2, "test plan", "test phase B", startDate, endDate,
-                rate2, rate2, Currency.USD);
+        final RecurringInvoiceItem item6 = new RecurringInvoiceItem(invoiceId2, accountId, bundleId, subscriptionId2, "test plan", "test phase B", startDate, endDate,
+                                                                    rate2, rate2, Currency.USD);
         recurringInvoiceItemDao.create(item6, context);
 
-        RecurringInvoiceItem item7 = new RecurringInvoiceItem(invoiceId2, accountId, bundleId,subscriptionId3, "test plan", "test phase C", startDate, endDate,
-                rate3, rate3, Currency.USD);
+        final RecurringInvoiceItem item7 = new RecurringInvoiceItem(invoiceId2, accountId, bundleId, subscriptionId3, "test plan", "test phase C", startDate, endDate,
+                                                                    rate3, rate3, Currency.USD);
         recurringInvoiceItemDao.create(item7, context);
 
         // check that each subscription returns the correct number of invoices
-        List<Invoice> items1 = invoiceDao.getInvoicesBySubscription(subscriptionId1);
+        final List<Invoice> items1 = invoiceDao.getInvoicesBySubscription(subscriptionId1);
         assertEquals(items1.size(), 2);
 
-        List<Invoice> items2 = invoiceDao.getInvoicesBySubscription(subscriptionId2);
+        final List<Invoice> items2 = invoiceDao.getInvoicesBySubscription(subscriptionId2);
         assertEquals(items2.size(), 2);
 
-        List<Invoice> items3 = invoiceDao.getInvoicesBySubscription(subscriptionId3);
+        final List<Invoice> items3 = invoiceDao.getInvoicesBySubscription(subscriptionId3);
         assertEquals(items3.size(), 2);
 
-        List<Invoice> items4 = invoiceDao.getInvoicesBySubscription(subscriptionId4);
+        final List<Invoice> items4 = invoiceDao.getInvoicesBySubscription(subscriptionId4);
         assertEquals(items4.size(), 1);
     }
 
     @Test
     public void testGetInvoicesForAccountAfterDate() {
-        UUID accountId = UUID.randomUUID();
-        DateTime targetDate1 = new DateTime(2011, 10, 6, 0, 0, 0, 0);
-        Invoice invoice1 = new DefaultInvoice(accountId, clock.getUTCNow(), targetDate1, Currency.USD);
+        final UUID accountId = UUID.randomUUID();
+        final DateTime targetDate1 = new DateTime(2011, 10, 6, 0, 0, 0, 0);
+        final Invoice invoice1 = new DefaultInvoice(accountId, clock.getUTCNow(), targetDate1, Currency.USD);
         invoiceDao.create(invoice1, context);
 
-        DateTime targetDate2 = new DateTime(2011, 12, 6, 0, 0, 0, 0);
-        Invoice invoice2 = new DefaultInvoice(accountId, clock.getUTCNow(), targetDate2, Currency.USD);
+        final DateTime targetDate2 = new DateTime(2011, 12, 6, 0, 0, 0, 0);
+        final Invoice invoice2 = new DefaultInvoice(accountId, clock.getUTCNow(), targetDate2, Currency.USD);
         invoiceDao.create(invoice2, context);
 
 
@@ -269,96 +269,96 @@ public class InvoiceDaoTests extends InvoiceDaoTestBase {
 
     @Test
     public void testAccountBalance() {
-        UUID accountId = UUID.randomUUID();
-        UUID bundleId = UUID.randomUUID();
-        DateTime targetDate1 = new DateTime(2011, 10, 6, 0, 0, 0, 0);
-        Invoice invoice1 = new DefaultInvoice(accountId, clock.getUTCNow(), targetDate1, Currency.USD);
+        final UUID accountId = UUID.randomUUID();
+        final UUID bundleId = UUID.randomUUID();
+        final DateTime targetDate1 = new DateTime(2011, 10, 6, 0, 0, 0, 0);
+        final Invoice invoice1 = new DefaultInvoice(accountId, clock.getUTCNow(), targetDate1, Currency.USD);
         invoiceDao.create(invoice1, context);
 
-        DateTime startDate = new DateTime(2011, 3, 1, 0, 0, 0, 0);
-        DateTime endDate = startDate.plusMonths(1);
+        final DateTime startDate = new DateTime(2011, 3, 1, 0, 0, 0, 0);
+        final DateTime endDate = startDate.plusMonths(1);
 
-        BigDecimal rate1 = new BigDecimal("17.0");
-        BigDecimal rate2 = new BigDecimal("42.0");
+        final BigDecimal rate1 = new BigDecimal("17.0");
+        final BigDecimal rate2 = new BigDecimal("42.0");
 
-        RecurringInvoiceItem item1 = new RecurringInvoiceItem(invoice1.getId(), accountId, bundleId,UUID.randomUUID(), "test plan", "test phase A", startDate,
-                endDate, rate1, rate1, Currency.USD);
+        final RecurringInvoiceItem item1 = new RecurringInvoiceItem(invoice1.getId(), accountId, bundleId, UUID.randomUUID(), "test plan", "test phase A", startDate,
+                                                                    endDate, rate1, rate1, Currency.USD);
         recurringInvoiceItemDao.create(item1, context);
 
-        RecurringInvoiceItem item2 = new RecurringInvoiceItem(invoice1.getId(), accountId, bundleId,UUID.randomUUID(), "test plan", "test phase B", startDate,
-                endDate, rate2, rate2, Currency.USD);
+        final RecurringInvoiceItem item2 = new RecurringInvoiceItem(invoice1.getId(), accountId, bundleId, UUID.randomUUID(), "test plan", "test phase B", startDate,
+                                                                    endDate, rate2, rate2, Currency.USD);
         recurringInvoiceItemDao.create(item2, context);
 
-        BigDecimal payment1 = new BigDecimal("48.0");
-        InvoicePayment payment = new DefaultInvoicePayment(UUID.randomUUID(), invoice1.getId(), new DateTime(), payment1, Currency.USD);
+        final BigDecimal payment1 = new BigDecimal("48.0");
+        final InvoicePayment payment = new DefaultInvoicePayment(UUID.randomUUID(), invoice1.getId(), new DateTime(), payment1, Currency.USD);
         invoicePaymentDao.create(payment, context);
 
-        BigDecimal balance = invoiceDao.getAccountBalance(accountId);
+        final BigDecimal balance = invoiceDao.getAccountBalance(accountId);
         assertEquals(balance.compareTo(rate1.add(rate2).subtract(payment1)), 0);
     }
 
     @Test
     public void testAccountBalanceWithNoPayments() {
-        UUID accountId = UUID.randomUUID();
-        UUID bundleId = UUID.randomUUID();
-        DateTime targetDate1 = new DateTime(2011, 10, 6, 0, 0, 0, 0);
-        Invoice invoice1 = new DefaultInvoice(accountId, clock.getUTCNow(), targetDate1, Currency.USD);
+        final UUID accountId = UUID.randomUUID();
+        final UUID bundleId = UUID.randomUUID();
+        final DateTime targetDate1 = new DateTime(2011, 10, 6, 0, 0, 0, 0);
+        final Invoice invoice1 = new DefaultInvoice(accountId, clock.getUTCNow(), targetDate1, Currency.USD);
         invoiceDao.create(invoice1, context);
 
-        DateTime startDate = new DateTime(2011, 3, 1, 0, 0, 0, 0);
-        DateTime endDate = startDate.plusMonths(1);
+        final DateTime startDate = new DateTime(2011, 3, 1, 0, 0, 0, 0);
+        final DateTime endDate = startDate.plusMonths(1);
 
-        BigDecimal rate1 = new BigDecimal("17.0");
-        BigDecimal rate2 = new BigDecimal("42.0");
+        final BigDecimal rate1 = new BigDecimal("17.0");
+        final BigDecimal rate2 = new BigDecimal("42.0");
 
-        RecurringInvoiceItem item1 = new RecurringInvoiceItem(invoice1.getId(), accountId, bundleId, UUID.randomUUID(), "test plan", "test phase A", startDate, endDate,
-                rate1, rate1, Currency.USD);
+        final RecurringInvoiceItem item1 = new RecurringInvoiceItem(invoice1.getId(), accountId, bundleId, UUID.randomUUID(), "test plan", "test phase A", startDate, endDate,
+                                                                    rate1, rate1, Currency.USD);
         recurringInvoiceItemDao.create(item1, context);
 
-        RecurringInvoiceItem item2 = new RecurringInvoiceItem(invoice1.getId(), accountId, bundleId, UUID.randomUUID(), "test plan", "test phase B", startDate, endDate,
-                rate2, rate2, Currency.USD);
+        final RecurringInvoiceItem item2 = new RecurringInvoiceItem(invoice1.getId(), accountId, bundleId, UUID.randomUUID(), "test plan", "test phase B", startDate, endDate,
+                                                                    rate2, rate2, Currency.USD);
         recurringInvoiceItemDao.create(item2, context);
 
-        BigDecimal balance = invoiceDao.getAccountBalance(accountId);
+        final BigDecimal balance = invoiceDao.getAccountBalance(accountId);
         assertEquals(balance.compareTo(rate1.add(rate2)), 0);
     }
 
     @Test
     public void testAccountBalanceWithNoInvoiceItems() {
-        UUID accountId = UUID.randomUUID();
-        DateTime targetDate1 = new DateTime(2011, 10, 6, 0, 0, 0, 0);
-        Invoice invoice1 = new DefaultInvoice(accountId, clock.getUTCNow(), targetDate1, Currency.USD);
+        final UUID accountId = UUID.randomUUID();
+        final DateTime targetDate1 = new DateTime(2011, 10, 6, 0, 0, 0, 0);
+        final Invoice invoice1 = new DefaultInvoice(accountId, clock.getUTCNow(), targetDate1, Currency.USD);
         invoiceDao.create(invoice1, context);
 
-        BigDecimal payment1 = new BigDecimal("48.0");
-        InvoicePayment payment = new DefaultInvoicePayment(UUID.randomUUID(), invoice1.getId(), new DateTime(), payment1, Currency.USD);
+        final BigDecimal payment1 = new BigDecimal("48.0");
+        final InvoicePayment payment = new DefaultInvoicePayment(UUID.randomUUID(), invoice1.getId(), new DateTime(), payment1, Currency.USD);
         invoicePaymentDao.create(payment, context);
 
-        BigDecimal balance = invoiceDao.getAccountBalance(accountId);
+        final BigDecimal balance = invoiceDao.getAccountBalance(accountId);
         assertEquals(balance.compareTo(BigDecimal.ZERO.subtract(payment1)), 0);
     }
 
     @Test
     public void testGetUnpaidInvoicesByAccountId() {
-        UUID accountId = UUID.randomUUID();
-        UUID bundleId = UUID.randomUUID();
-        DateTime targetDate1 = new DateTime(2011, 10, 6, 0, 0, 0, 0);
-        Invoice invoice1 = new DefaultInvoice(accountId, clock.getUTCNow(), targetDate1, Currency.USD);
+        final UUID accountId = UUID.randomUUID();
+        final UUID bundleId = UUID.randomUUID();
+        final DateTime targetDate1 = new DateTime(2011, 10, 6, 0, 0, 0, 0);
+        final Invoice invoice1 = new DefaultInvoice(accountId, clock.getUTCNow(), targetDate1, Currency.USD);
         invoiceDao.create(invoice1, context);
 
-        DateTime startDate = new DateTime(2011, 3, 1, 0, 0, 0, 0);
-        DateTime endDate = startDate.plusMonths(1);
+        final DateTime startDate = new DateTime(2011, 3, 1, 0, 0, 0, 0);
+        final DateTime endDate = startDate.plusMonths(1);
 
-        BigDecimal rate1 = new BigDecimal("17.0");
-        BigDecimal rate2 = new BigDecimal("42.0");
+        final BigDecimal rate1 = new BigDecimal("17.0");
+        final BigDecimal rate2 = new BigDecimal("42.0");
 
 
-        RecurringInvoiceItem item1 = new RecurringInvoiceItem(invoice1.getId(), accountId, bundleId, UUID.randomUUID(), "test plan", "test phase A", startDate, endDate,
-                rate1, rate1, Currency.USD);
+        final RecurringInvoiceItem item1 = new RecurringInvoiceItem(invoice1.getId(), accountId, bundleId, UUID.randomUUID(), "test plan", "test phase A", startDate, endDate,
+                                                                    rate1, rate1, Currency.USD);
         recurringInvoiceItemDao.create(item1, context);
 
-        RecurringInvoiceItem item2 = new RecurringInvoiceItem(invoice1.getId(), accountId, bundleId, UUID.randomUUID(), "test plan", "test phase B", startDate, endDate,
-                rate2, rate2, Currency.USD);
+        final RecurringInvoiceItem item2 = new RecurringInvoiceItem(invoice1.getId(), accountId, bundleId, UUID.randomUUID(), "test plan", "test phase B", startDate, endDate,
+                                                                    rate2, rate2, Currency.USD);
         recurringInvoiceItemDao.create(item2, context);
 
         DateTime upToDate;
@@ -372,17 +372,17 @@ public class InvoiceDaoTests extends InvoiceDaoTestBase {
         invoices = invoiceDao.getUnpaidInvoicesByAccountId(accountId, upToDate);
         assertEquals(invoices.size(), 1);
 
-        DateTime targetDate2 = new DateTime(2011, 7, 1, 0, 0, 0, 0);
-        Invoice invoice2 = new DefaultInvoice(accountId, clock.getUTCNow(), targetDate2, Currency.USD);
+        final DateTime targetDate2 = new DateTime(2011, 7, 1, 0, 0, 0, 0);
+        final Invoice invoice2 = new DefaultInvoice(accountId, clock.getUTCNow(), targetDate2, Currency.USD);
         invoiceDao.create(invoice2, context);
 
-        DateTime startDate2 = new DateTime(2011, 6, 1, 0, 0, 0, 0);
-        DateTime endDate2 = startDate2.plusMonths(3);
+        final DateTime startDate2 = new DateTime(2011, 6, 1, 0, 0, 0, 0);
+        final DateTime endDate2 = startDate2.plusMonths(3);
 
-        BigDecimal rate3 = new BigDecimal("21.0");
+        final BigDecimal rate3 = new BigDecimal("21.0");
 
-        RecurringInvoiceItem item3 = new RecurringInvoiceItem(invoice2.getId(), accountId, bundleId, UUID.randomUUID(), "test plan", "test phase C", startDate2, endDate2,
-                rate3, rate3, Currency.USD);
+        final RecurringInvoiceItem item3 = new RecurringInvoiceItem(invoice2.getId(), accountId, bundleId, UUID.randomUUID(), "test plan", "test phase C", startDate2, endDate2,
+                                                                    rate3, rate3, Currency.USD);
         recurringInvoiceItemDao.create(item3, context);
 
         upToDate = new DateTime(2011, 1, 1, 0, 0, 0, 0);
@@ -401,78 +401,78 @@ public class InvoiceDaoTests extends InvoiceDaoTestBase {
      */
     @Test
     public void testInvoiceGenerationForImmediateChanges() throws InvoiceApiException, CatalogApiException {
-        UUID accountId = UUID.randomUUID();
-        List<Invoice> invoiceList = new ArrayList<Invoice>();
-        DateTime targetDate = new DateTime(2011, 2, 16, 0, 0, 0, 0);
-        Currency currency = Currency.USD;
+        final UUID accountId = UUID.randomUUID();
+        final List<Invoice> invoiceList = new ArrayList<Invoice>();
+        final DateTime targetDate = new DateTime(2011, 2, 16, 0, 0, 0, 0);
+        final Currency currency = Currency.USD;
 
         // generate first invoice
-        DefaultPrice price1 = new DefaultPrice(TEN, Currency.USD);
-        MockInternationalPrice recurringPrice = new MockInternationalPrice(price1);
-        MockPlanPhase phase1 = new MockPlanPhase(recurringPrice, null, BillingPeriod.MONTHLY, PhaseType.TRIAL);
-        MockPlan plan1 = new MockPlan(phase1);
+        final DefaultPrice price1 = new DefaultPrice(TEN, Currency.USD);
+        final MockInternationalPrice recurringPrice = new MockInternationalPrice(price1);
+        final MockPlanPhase phase1 = new MockPlanPhase(recurringPrice, null, BillingPeriod.MONTHLY, PhaseType.TRIAL);
+        final MockPlan plan1 = new MockPlan(phase1);
 
-        Subscription subscription = getZombieSubscription();
+        final Subscription subscription = getZombieSubscription();
 
-        DateTime effectiveDate1 = new DateTime(2011, 2, 1, 0, 0, 0, 0);
-        BillingEvent event1 = createMockBillingEvent(null, subscription, effectiveDate1, plan1, phase1, null,
-                recurringPrice.getPrice(currency), currency, BillingPeriod.MONTHLY, 1, BillingModeType.IN_ADVANCE,
-                "testEvent1", 1L, SubscriptionTransitionType.CREATE);
+        final DateTime effectiveDate1 = new DateTime(2011, 2, 1, 0, 0, 0, 0);
+        final BillingEvent event1 = createMockBillingEvent(null, subscription, effectiveDate1, plan1, phase1, null,
+                                                           recurringPrice.getPrice(currency), currency, BillingPeriod.MONTHLY, 1, BillingModeType.IN_ADVANCE,
+                                                           "testEvent1", 1L, SubscriptionTransitionType.CREATE);
 
-        BillingEventSet events = new MockBillingEventSet();
+        final BillingEventSet events = new MockBillingEventSet();
         events.add(event1);
 
-        Invoice invoice1 = generator.generateInvoice(accountId, events, invoiceList, targetDate, Currency.USD);
+        final Invoice invoice1 = generator.generateInvoice(accountId, events, invoiceList, targetDate, Currency.USD);
         assertEquals(invoice1.getBalance(), TEN);
         invoiceList.add(invoice1);
 
         // generate second invoice
-        DefaultPrice price2 = new DefaultPrice(TWENTY, Currency.USD);
-        MockInternationalPrice recurringPrice2 = new MockInternationalPrice(price2);
-        MockPlanPhase phase2 = new MockPlanPhase(recurringPrice, null, BillingPeriod.MONTHLY, PhaseType.TRIAL);
-        MockPlan plan2 = new MockPlan(phase2);
-
-        DateTime effectiveDate2 = new DateTime(2011, 2, 15, 0, 0, 0, 0);
-        BillingEvent event2 = createMockBillingEvent(null, subscription, effectiveDate2, plan2, phase2, null,
-                recurringPrice2.getPrice(currency), currency, BillingPeriod.MONTHLY, 1, BillingModeType.IN_ADVANCE,
-                "testEvent2", 2L, SubscriptionTransitionType.CREATE);
+        final DefaultPrice price2 = new DefaultPrice(TWENTY, Currency.USD);
+        final MockInternationalPrice recurringPrice2 = new MockInternationalPrice(price2);
+        final MockPlanPhase phase2 = new MockPlanPhase(recurringPrice, null, BillingPeriod.MONTHLY, PhaseType.TRIAL);
+        final MockPlan plan2 = new MockPlan(phase2);
+
+        final DateTime effectiveDate2 = new DateTime(2011, 2, 15, 0, 0, 0, 0);
+        final BillingEvent event2 = createMockBillingEvent(null, subscription, effectiveDate2, plan2, phase2, null,
+                                                           recurringPrice2.getPrice(currency), currency, BillingPeriod.MONTHLY, 1, BillingModeType.IN_ADVANCE,
+                                                           "testEvent2", 2L, SubscriptionTransitionType.CREATE);
         events.add(event2);
 
         // second invoice should be for one half (14/28 days) the difference between the rate plans
         // this is a temporary state, since it actually contains an adjusting item that properly belong to invoice 1
-        Invoice invoice2 = generator.generateInvoice(accountId, events, invoiceList, targetDate, Currency.USD);
+        final Invoice invoice2 = generator.generateInvoice(accountId, events, invoiceList, targetDate, Currency.USD);
         assertEquals(invoice2.getBalance(), FIVE);
         invoiceList.add(invoice2);
 
         invoiceDao.create(invoice1, context);
         invoiceDao.create(invoice2, context);
 
-        Invoice savedInvoice1 = invoiceDao.getById(invoice1.getId());
+        final Invoice savedInvoice1 = invoiceDao.getById(invoice1.getId());
         assertEquals(savedInvoice1.getBalance(), ZERO);
 
-        Invoice savedInvoice2 = invoiceDao.getById(invoice2.getId());
+        final Invoice savedInvoice2 = invoiceDao.getById(invoice2.getId());
         assertEquals(savedInvoice2.getBalance(), FIFTEEN);
     }
 
     @Test
     public void testInvoiceForFreeTrial() throws InvoiceApiException, CatalogApiException {
-        Currency currency = Currency.USD;
-        DefaultPrice price = new DefaultPrice(BigDecimal.ZERO, Currency.USD);
-        MockInternationalPrice recurringPrice = new MockInternationalPrice(price);
-        MockPlanPhase phase = new MockPlanPhase(recurringPrice, null);
-        MockPlan plan = new MockPlan(phase);
-
-        Subscription subscription = getZombieSubscription();
-        DateTime effectiveDate = buildDateTime(2011, 1, 1);
-
-        BillingEvent event = createMockBillingEvent(null, subscription, effectiveDate, plan, phase, null,
-                recurringPrice.getPrice(currency), currency, BillingPeriod.MONTHLY, 15, BillingModeType.IN_ADVANCE,
-                "testEvent", 1L, SubscriptionTransitionType.CREATE);
-        BillingEventSet events = new MockBillingEventSet();
+        final Currency currency = Currency.USD;
+        final DefaultPrice price = new DefaultPrice(BigDecimal.ZERO, Currency.USD);
+        final MockInternationalPrice recurringPrice = new MockInternationalPrice(price);
+        final MockPlanPhase phase = new MockPlanPhase(recurringPrice, null);
+        final MockPlan plan = new MockPlan(phase);
+
+        final Subscription subscription = getZombieSubscription();
+        final DateTime effectiveDate = buildDateTime(2011, 1, 1);
+
+        final BillingEvent event = createMockBillingEvent(null, subscription, effectiveDate, plan, phase, null,
+                                                          recurringPrice.getPrice(currency), currency, BillingPeriod.MONTHLY, 15, BillingModeType.IN_ADVANCE,
+                                                          "testEvent", 1L, SubscriptionTransitionType.CREATE);
+        final BillingEventSet events = new MockBillingEventSet();
         events.add(event);
 
-        DateTime targetDate = buildDateTime(2011, 1, 15);
-        Invoice invoice = generator.generateInvoice(UUID.randomUUID(), events, null, targetDate, Currency.USD);
+        final DateTime targetDate = buildDateTime(2011, 1, 15);
+        final Invoice invoice = generator.generateInvoice(UUID.randomUUID(), events, null, targetDate, Currency.USD);
 
         // expect one pro-ration item and one full-period item
         assertEquals(invoice.getNumberOfItems(), 2);
@@ -480,7 +480,7 @@ public class InvoiceDaoTests extends InvoiceDaoTestBase {
     }
 
     private Subscription getZombieSubscription() {
-        Subscription subscription = BrainDeadProxyFactory.createBrainDeadProxyFor(Subscription.class);
+        final Subscription subscription = BrainDeadProxyFactory.createBrainDeadProxyFor(Subscription.class);
         ((ZombieControl) subscription).addResult("getId", UUID.randomUUID());
         ((ZombieControl) subscription).addResult("getBundleId", UUID.randomUUID());
         return subscription;
@@ -488,52 +488,52 @@ public class InvoiceDaoTests extends InvoiceDaoTestBase {
 
     @Test
     public void testInvoiceForFreeTrialWithRecurringDiscount() throws InvoiceApiException, CatalogApiException {
-        Currency currency = Currency.USD;
+        final Currency currency = Currency.USD;
 
-        DefaultPrice zeroPrice = new DefaultPrice(BigDecimal.ZERO, Currency.USD);
-        MockInternationalPrice fixedPrice = new MockInternationalPrice(zeroPrice);
-        MockPlanPhase phase1 = new MockPlanPhase(null, fixedPrice);
+        final DefaultPrice zeroPrice = new DefaultPrice(BigDecimal.ZERO, Currency.USD);
+        final MockInternationalPrice fixedPrice = new MockInternationalPrice(zeroPrice);
+        final MockPlanPhase phase1 = new MockPlanPhase(null, fixedPrice);
 
-        BigDecimal cheapAmount = new BigDecimal("24.95");
-        DefaultPrice cheapPrice = new DefaultPrice(cheapAmount, Currency.USD);
-        MockInternationalPrice recurringPrice = new MockInternationalPrice(cheapPrice);
-        MockPlanPhase phase2 = new MockPlanPhase(recurringPrice, null);
+        final BigDecimal cheapAmount = new BigDecimal("24.95");
+        final DefaultPrice cheapPrice = new DefaultPrice(cheapAmount, Currency.USD);
+        final MockInternationalPrice recurringPrice = new MockInternationalPrice(cheapPrice);
+        final MockPlanPhase phase2 = new MockPlanPhase(recurringPrice, null);
 
-        MockPlan plan = new MockPlan();
+        final MockPlan plan = new MockPlan();
 
-        Subscription subscription = getZombieSubscription();
-        DateTime effectiveDate1 = buildDateTime(2011, 1, 1);
+        final Subscription subscription = getZombieSubscription();
+        final DateTime effectiveDate1 = buildDateTime(2011, 1, 1);
 
-        BillingEvent event1 = createMockBillingEvent(null, subscription, effectiveDate1, plan, phase1, fixedPrice.getPrice(currency),
-                null, currency, BillingPeriod.MONTHLY, 1, BillingModeType.IN_ADVANCE,
-                "testEvent1", 1L, SubscriptionTransitionType.CREATE);
-        BillingEventSet events = new MockBillingEventSet();
+        final BillingEvent event1 = createMockBillingEvent(null, subscription, effectiveDate1, plan, phase1, fixedPrice.getPrice(currency),
+                                                           null, currency, BillingPeriod.MONTHLY, 1, BillingModeType.IN_ADVANCE,
+                                                           "testEvent1", 1L, SubscriptionTransitionType.CREATE);
+        final BillingEventSet events = new MockBillingEventSet();
         events.add(event1);
 
-        UUID accountId = UUID.randomUUID();
-        Invoice invoice1 = generator.generateInvoice(accountId, events, null, effectiveDate1, Currency.USD);
+        final UUID accountId = UUID.randomUUID();
+        final Invoice invoice1 = generator.generateInvoice(accountId, events, null, effectiveDate1, Currency.USD);
         assertNotNull(invoice1);
         assertEquals(invoice1.getNumberOfItems(), 1);
         assertEquals(invoice1.getBalance().compareTo(ZERO), 0);
 
-        List<Invoice> invoiceList = new ArrayList<Invoice>();
+        final List<Invoice> invoiceList = new ArrayList<Invoice>();
         invoiceList.add(invoice1);
 
-        DateTime effectiveDate2 = effectiveDate1.plusDays(30);
-        BillingEvent event2 = createMockBillingEvent(null, subscription, effectiveDate2, plan, phase2, null,
-                recurringPrice.getPrice(currency), currency, BillingPeriod.MONTHLY, 31, BillingModeType.IN_ADVANCE,
-                "testEvent2", 2L, SubscriptionTransitionType.CHANGE);
+        final DateTime effectiveDate2 = effectiveDate1.plusDays(30);
+        final BillingEvent event2 = createMockBillingEvent(null, subscription, effectiveDate2, plan, phase2, null,
+                                                           recurringPrice.getPrice(currency), currency, BillingPeriod.MONTHLY, 31, BillingModeType.IN_ADVANCE,
+                                                           "testEvent2", 2L, SubscriptionTransitionType.CHANGE);
         events.add(event2);
 
-        Invoice invoice2 = generator.generateInvoice(accountId, events, invoiceList, effectiveDate2, Currency.USD);
+        final Invoice invoice2 = generator.generateInvoice(accountId, events, invoiceList, effectiveDate2, Currency.USD);
         assertNotNull(invoice2);
         assertEquals(invoice2.getNumberOfItems(), 1);
         assertEquals(invoice2.getBalance().compareTo(cheapAmount), 0);
 
         invoiceList.add(invoice2);
 
-        DateTime effectiveDate3 = effectiveDate2.plusMonths(1);
-        Invoice invoice3 = generator.generateInvoice(accountId, events, invoiceList, effectiveDate3, Currency.USD);
+        final DateTime effectiveDate3 = effectiveDate2.plusMonths(1);
+        final Invoice invoice3 = generator.generateInvoice(accountId, events, invoiceList, effectiveDate3, Currency.USD);
         assertNotNull(invoice3);
         assertEquals(invoice3.getNumberOfItems(), 1);
         assertEquals(invoice3.getBalance().compareTo(cheapAmount), 0);
@@ -541,48 +541,48 @@ public class InvoiceDaoTests extends InvoiceDaoTestBase {
 
     @Test
     public void testInvoiceForEmptyEventSet() throws InvoiceApiException {
-        BillingEventSet events = new MockBillingEventSet();
-        Invoice invoice = generator.generateInvoice(UUID.randomUUID(), events, null, new DateTime(), Currency.USD);
+        final BillingEventSet events = new MockBillingEventSet();
+        final Invoice invoice = generator.generateInvoice(UUID.randomUUID(), events, null, new DateTime(), Currency.USD);
         assertNull(invoice);
     }
 
     @Test
     public void testMixedModeInvoicePersistence() throws InvoiceApiException, CatalogApiException {
-        Currency currency = Currency.USD;
-        DefaultPrice zeroPrice = new DefaultPrice(BigDecimal.ZERO, Currency.USD);
-        MockInternationalPrice fixedPrice = new MockInternationalPrice(zeroPrice);
-        MockPlanPhase phase1 = new MockPlanPhase(null, fixedPrice);
-
-        BigDecimal cheapAmount = new BigDecimal("24.95");
-        DefaultPrice cheapPrice = new DefaultPrice(cheapAmount, Currency.USD);
-        MockInternationalPrice recurringPrice = new MockInternationalPrice(cheapPrice);
-        MockPlanPhase phase2 = new MockPlanPhase(recurringPrice, null);
-
-        MockPlan plan = new MockPlan();
-
-        Subscription subscription = getZombieSubscription();
-        DateTime effectiveDate1 = buildDateTime(2011, 1, 1);
-
-        BillingEvent event1 = createMockBillingEvent(null, subscription, effectiveDate1, plan, phase1,
-                fixedPrice.getPrice(currency), null, currency,
-                BillingPeriod.MONTHLY, 1, BillingModeType.IN_ADVANCE,
-                "testEvent1", 1L, SubscriptionTransitionType.CREATE);
-        BillingEventSet events = new MockBillingEventSet();
+        final Currency currency = Currency.USD;
+        final DefaultPrice zeroPrice = new DefaultPrice(BigDecimal.ZERO, Currency.USD);
+        final MockInternationalPrice fixedPrice = new MockInternationalPrice(zeroPrice);
+        final MockPlanPhase phase1 = new MockPlanPhase(null, fixedPrice);
+
+        final BigDecimal cheapAmount = new BigDecimal("24.95");
+        final DefaultPrice cheapPrice = new DefaultPrice(cheapAmount, Currency.USD);
+        final MockInternationalPrice recurringPrice = new MockInternationalPrice(cheapPrice);
+        final MockPlanPhase phase2 = new MockPlanPhase(recurringPrice, null);
+
+        final MockPlan plan = new MockPlan();
+
+        final Subscription subscription = getZombieSubscription();
+        final DateTime effectiveDate1 = buildDateTime(2011, 1, 1);
+
+        final BillingEvent event1 = createMockBillingEvent(null, subscription, effectiveDate1, plan, phase1,
+                                                           fixedPrice.getPrice(currency), null, currency,
+                                                           BillingPeriod.MONTHLY, 1, BillingModeType.IN_ADVANCE,
+                                                           "testEvent1", 1L, SubscriptionTransitionType.CREATE);
+        final BillingEventSet events = new MockBillingEventSet();
         events.add(event1);
 
-        DateTime effectiveDate2 = effectiveDate1.plusDays(30);
-        BillingEvent event2 = createMockBillingEvent(null, subscription, effectiveDate2, plan, phase2, null,
-                recurringPrice.getPrice(currency), currency, BillingPeriod.MONTHLY, 31, BillingModeType.IN_ADVANCE,
-                "testEvent2", 2L, SubscriptionTransitionType.CHANGE);
+        final DateTime effectiveDate2 = effectiveDate1.plusDays(30);
+        final BillingEvent event2 = createMockBillingEvent(null, subscription, effectiveDate2, plan, phase2, null,
+                                                           recurringPrice.getPrice(currency), currency, BillingPeriod.MONTHLY, 31, BillingModeType.IN_ADVANCE,
+                                                           "testEvent2", 2L, SubscriptionTransitionType.CHANGE);
         events.add(event2);
 
-        Invoice invoice = generator.generateInvoice(UUID.randomUUID(), events, null, effectiveDate2, Currency.USD);
+        final Invoice invoice = generator.generateInvoice(UUID.randomUUID(), events, null, effectiveDate2, Currency.USD);
         assertNotNull(invoice);
         assertEquals(invoice.getNumberOfItems(), 2);
         assertEquals(invoice.getBalance().compareTo(cheapAmount), 0);
 
         invoiceDao.create(invoice, context);
-        Invoice savedInvoice = invoiceDao.getById(invoice.getId());
+        final Invoice savedInvoice = invoiceDao.getById(invoice.getId());
 
         assertNotNull(savedInvoice);
         assertEquals(savedInvoice.getNumberOfItems(), 2);
@@ -591,28 +591,28 @@ public class InvoiceDaoTests extends InvoiceDaoTestBase {
 
     @Test
     public void testInvoiceNumber() throws InvoiceApiException {
-        Currency currency = Currency.USD;
-        DateTime targetDate1 = DateTime.now().plusMonths(1);
-        DateTime targetDate2 = DateTime.now().plusMonths(2);
+        final Currency currency = Currency.USD;
+        final DateTime targetDate1 = DateTime.now().plusMonths(1);
+        final DateTime targetDate2 = DateTime.now().plusMonths(2);
 
-        Subscription subscription = getZombieSubscription();
+        final Subscription subscription = getZombieSubscription();
 
-        Plan plan = BrainDeadProxyFactory.createBrainDeadProxyFor(Plan.class);
+        final Plan plan = BrainDeadProxyFactory.createBrainDeadProxyFor(Plan.class);
         ((ZombieControl) plan).addResult("getName", "plan");
 
-        PlanPhase phase1 = BrainDeadProxyFactory.createBrainDeadProxyFor(PlanPhase.class);
+        final PlanPhase phase1 = BrainDeadProxyFactory.createBrainDeadProxyFor(PlanPhase.class);
         ((ZombieControl) phase1).addResult("getName", "plan-phase1");
 
-        PlanPhase phase2 = BrainDeadProxyFactory.createBrainDeadProxyFor(PlanPhase.class);
+        final PlanPhase phase2 = BrainDeadProxyFactory.createBrainDeadProxyFor(PlanPhase.class);
         ((ZombieControl) phase2).addResult("getName", "plan-phase2");
 
-        BillingEventSet events = new MockBillingEventSet();
-        List<Invoice> invoices = new ArrayList<Invoice>();
+        final BillingEventSet events = new MockBillingEventSet();
+        final List<Invoice> invoices = new ArrayList<Invoice>();
 
-        BillingEvent event1 = createMockBillingEvent(null, subscription, targetDate1, plan, phase1, null,
-                TEN, currency,
-                BillingPeriod.MONTHLY, 31, BillingModeType.IN_ADVANCE,
-                "testEvent1", 1L, SubscriptionTransitionType.CHANGE);
+        final BillingEvent event1 = createMockBillingEvent(null, subscription, targetDate1, plan, phase1, null,
+                                                           TEN, currency,
+                                                           BillingPeriod.MONTHLY, 31, BillingModeType.IN_ADVANCE,
+                                                           "testEvent1", 1L, SubscriptionTransitionType.CHANGE);
         events.add(event1);
 
         Invoice invoice1 = generator.generateInvoice(UUID.randomUUID(), events, invoices, targetDate1, Currency.USD);
@@ -621,10 +621,10 @@ public class InvoiceDaoTests extends InvoiceDaoTestBase {
         invoice1 = invoiceDao.getById(invoice1.getId());
         assertNotNull(invoice1.getInvoiceNumber());
 
-        BillingEvent event2 = createMockBillingEvent(null, subscription, targetDate1, plan, phase2, null,
-                TWENTY, currency,
-                BillingPeriod.MONTHLY, 31, BillingModeType.IN_ADVANCE,
-                "testEvent2", 2L, SubscriptionTransitionType.CHANGE);
+        final BillingEvent event2 = createMockBillingEvent(null, subscription, targetDate1, plan, phase2, null,
+                                                           TWENTY, currency,
+                                                           BillingPeriod.MONTHLY, 31, BillingModeType.IN_ADVANCE,
+                                                           "testEvent2", 2L, SubscriptionTransitionType.CHANGE);
         events.add(event2);
         Invoice invoice2 = generator.generateInvoice(UUID.randomUUID(), events, invoices, targetDate2, Currency.USD);
         invoiceDao.create(invoice2, context);
@@ -634,61 +634,61 @@ public class InvoiceDaoTests extends InvoiceDaoTestBase {
 
     @Test
     public void testAddingWrittenOffTag() throws InvoiceApiException, TagApiException {
-        Subscription subscription = getZombieSubscription();
+        final Subscription subscription = getZombieSubscription();
 
-        Plan plan = BrainDeadProxyFactory.createBrainDeadProxyFor(Plan.class);
+        final Plan plan = BrainDeadProxyFactory.createBrainDeadProxyFor(Plan.class);
         ((ZombieControl) plan).addResult("getName", "plan");
 
-        PlanPhase phase1 = BrainDeadProxyFactory.createBrainDeadProxyFor(PlanPhase.class);
+        final PlanPhase phase1 = BrainDeadProxyFactory.createBrainDeadProxyFor(PlanPhase.class);
         ((ZombieControl) phase1).addResult("getName", "plan-phase1");
 
-        DateTime targetDate1 = clock.getUTCNow();
-        Currency currency = Currency.USD;
+        final DateTime targetDate1 = clock.getUTCNow();
+        final Currency currency = Currency.USD;
 
         // create pseudo-random invoice
-        BillingEvent event1 = createMockBillingEvent(null, subscription, targetDate1, plan, phase1, null,
-                TEN, currency,
-                BillingPeriod.MONTHLY, 31, BillingModeType.IN_ADVANCE,
-                "testEvent1", 1L, SubscriptionTransitionType.CHANGE);
-        BillingEventSet events = new MockBillingEventSet();
+        final BillingEvent event1 = createMockBillingEvent(null, subscription, targetDate1, plan, phase1, null,
+                                                           TEN, currency,
+                                                           BillingPeriod.MONTHLY, 31, BillingModeType.IN_ADVANCE,
+                                                           "testEvent1", 1L, SubscriptionTransitionType.CHANGE);
+        final BillingEventSet events = new MockBillingEventSet();
         events.add(event1);
 
-        Invoice invoice = generator.generateInvoice(UUID.randomUUID(), events, null, targetDate1, Currency.USD);
+        final Invoice invoice = generator.generateInvoice(UUID.randomUUID(), events, null, targetDate1, Currency.USD);
         invoiceDao.create(invoice, context);
         invoiceDao.setWrittenOff(invoice.getId(), context);
 
-        TagDao tagDao = new AuditedTagDao(dbi, tagEventBuilder, bus);
-        Map<String, Tag> tags = tagDao.loadEntities(invoice.getId(), ObjectType.INVOICE);
+        final TagDao tagDao = new AuditedTagDao(dbi, tagEventBuilder, bus);
+        final Map<String, Tag> tags = tagDao.loadEntities(invoice.getId(), ObjectType.INVOICE);
         assertEquals(tags.size(), 1);
         assertTrue(tags.containsKey(ControlTagType.WRITTEN_OFF.toString()));
     }
 
     @Test
     public void testRemoveWrittenOffTag() throws InvoiceApiException, TagApiException {
-        Subscription subscription = getZombieSubscription();
+        final Subscription subscription = getZombieSubscription();
 
-        Plan plan = BrainDeadProxyFactory.createBrainDeadProxyFor(Plan.class);
+        final Plan plan = BrainDeadProxyFactory.createBrainDeadProxyFor(Plan.class);
         ((ZombieControl) plan).addResult("getName", "plan");
 
-        PlanPhase phase1 = BrainDeadProxyFactory.createBrainDeadProxyFor(PlanPhase.class);
+        final PlanPhase phase1 = BrainDeadProxyFactory.createBrainDeadProxyFor(PlanPhase.class);
         ((ZombieControl) phase1).addResult("getName", "plan-phase1");
 
-        DateTime targetDate1 = clock.getUTCNow();
-        Currency currency = Currency.USD;
+        final DateTime targetDate1 = clock.getUTCNow();
+        final Currency currency = Currency.USD;
 
         // create pseudo-random invoice
-        BillingEvent event1 = createMockBillingEvent(null, subscription, targetDate1, plan, phase1, null,
-                TEN, currency,
-                BillingPeriod.MONTHLY, 31, BillingModeType.IN_ADVANCE,
-                "testEvent1", 1L, SubscriptionTransitionType.CHANGE);
-        BillingEventSet events = new MockBillingEventSet();
+        final BillingEvent event1 = createMockBillingEvent(null, subscription, targetDate1, plan, phase1, null,
+                                                           TEN, currency,
+                                                           BillingPeriod.MONTHLY, 31, BillingModeType.IN_ADVANCE,
+                                                           "testEvent1", 1L, SubscriptionTransitionType.CHANGE);
+        final BillingEventSet events = new MockBillingEventSet();
         events.add(event1);
 
-        Invoice invoice = generator.generateInvoice(UUID.randomUUID(), events, null, targetDate1, Currency.USD);
+        final Invoice invoice = generator.generateInvoice(UUID.randomUUID(), events, null, targetDate1, Currency.USD);
         invoiceDao.create(invoice, context);
         invoiceDao.setWrittenOff(invoice.getId(), context);
 
-        TagDao tagDao = new AuditedTagDao(dbi, tagEventBuilder, bus);
+        final TagDao tagDao = new AuditedTagDao(dbi, tagEventBuilder, bus);
         Map<String, Tag> tags = tagDao.loadEntities(invoice.getId(), ObjectType.INVOICE);
         assertEquals(tags.size(), 1);
         assertTrue(tags.containsKey(ControlTagType.WRITTEN_OFF.toString()));
diff --git a/invoice/src/test/java/com/ning/billing/invoice/dao/InvoiceItemDaoTests.java b/invoice/src/test/java/com/ning/billing/invoice/dao/InvoiceItemDaoTests.java
index c97e775..ad14b3e 100644
--- a/invoice/src/test/java/com/ning/billing/invoice/dao/InvoiceItemDaoTests.java
+++ b/invoice/src/test/java/com/ning/billing/invoice/dao/InvoiceItemDaoTests.java
@@ -16,42 +16,41 @@
 
 package com.ning.billing.invoice.dao;
 
-import static org.testng.Assert.assertEquals;
-import static org.testng.Assert.assertNotNull;
-import static org.testng.Assert.assertTrue;
-import static org.testng.Assert.fail;
-
 import java.math.BigDecimal;
 import java.util.List;
 import java.util.UUID;
 
-import com.ning.billing.invoice.model.CreditInvoiceItem;
-import com.ning.billing.invoice.model.FixedPriceInvoiceItem;
 import org.joda.time.DateTime;
 import org.testng.annotations.Test;
 
 import com.ning.billing.catalog.api.Currency;
 import com.ning.billing.invoice.api.InvoiceItem;
+import com.ning.billing.invoice.model.CreditInvoiceItem;
 import com.ning.billing.invoice.model.DefaultInvoice;
+import com.ning.billing.invoice.model.FixedPriceInvoiceItem;
 import com.ning.billing.invoice.model.RecurringInvoiceItem;
 
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertNotNull;
+import static org.testng.Assert.assertTrue;
+
 @Test(groups = {"slow", "invoicing", "invoicing-invoiceDao"})
 public class InvoiceItemDaoTests extends InvoiceDaoTestBase {
     @Test
     public void testInvoiceItemCreation() {
-        UUID accountId = UUID.randomUUID();
-        UUID invoiceId = UUID.randomUUID();
-        UUID bundleId = UUID.randomUUID();
-        UUID subscriptionId = UUID.randomUUID();
-        DateTime startDate = new DateTime(2011, 10, 1, 0, 0, 0, 0);
-        DateTime endDate = new DateTime(2011, 11, 1, 0, 0, 0, 0);
-        BigDecimal rate = new BigDecimal("20.00");
-
-        RecurringInvoiceItem item = new RecurringInvoiceItem(invoiceId, accountId, bundleId, subscriptionId, "test plan", "test phase", startDate, endDate,
-                rate, rate, Currency.USD);
+        final UUID accountId = UUID.randomUUID();
+        final UUID invoiceId = UUID.randomUUID();
+        final UUID bundleId = UUID.randomUUID();
+        final UUID subscriptionId = UUID.randomUUID();
+        final DateTime startDate = new DateTime(2011, 10, 1, 0, 0, 0, 0);
+        final DateTime endDate = new DateTime(2011, 11, 1, 0, 0, 0, 0);
+        final BigDecimal rate = new BigDecimal("20.00");
+
+        final RecurringInvoiceItem item = new RecurringInvoiceItem(invoiceId, accountId, bundleId, subscriptionId, "test plan", "test phase", startDate, endDate,
+                                                                   rate, rate, Currency.USD);
         recurringInvoiceItemDao.create(item, context);
 
-        RecurringInvoiceItem thisItem = (RecurringInvoiceItem) recurringInvoiceItemDao.getById(item.getId().toString());
+        final RecurringInvoiceItem thisItem = (RecurringInvoiceItem) recurringInvoiceItemDao.getById(item.getId().toString());
         assertNotNull(thisItem);
         assertEquals(thisItem.getId(), item.getId());
         assertEquals(thisItem.getInvoiceId(), item.getInvoiceId());
@@ -67,95 +66,95 @@ public class InvoiceItemDaoTests extends InvoiceDaoTestBase {
 
     @Test
     public void testGetInvoiceItemsBySubscriptionId() {
-        UUID accountId = UUID.randomUUID();
-        UUID subscriptionId = UUID.randomUUID();
-        UUID bundleId = UUID.randomUUID();
-        DateTime startDate = new DateTime(2011, 3, 1, 0, 0, 0, 0);
-        BigDecimal rate = new BigDecimal("20.00");
+        final UUID accountId = UUID.randomUUID();
+        final UUID subscriptionId = UUID.randomUUID();
+        final UUID bundleId = UUID.randomUUID();
+        final DateTime startDate = new DateTime(2011, 3, 1, 0, 0, 0, 0);
+        final BigDecimal rate = new BigDecimal("20.00");
 
         for (int i = 0; i < 3; i++) {
-            UUID invoiceId = UUID.randomUUID();
+            final UUID invoiceId = UUID.randomUUID();
 
-            RecurringInvoiceItem item = new RecurringInvoiceItem(invoiceId, accountId, bundleId, subscriptionId,
-                    "test plan", "test phase", startDate.plusMonths(i), startDate.plusMonths(i + 1),
-                    rate, rate, Currency.USD);
+            final RecurringInvoiceItem item = new RecurringInvoiceItem(invoiceId, accountId, bundleId, subscriptionId,
+                                                                       "test plan", "test phase", startDate.plusMonths(i), startDate.plusMonths(i + 1),
+                                                                       rate, rate, Currency.USD);
             recurringInvoiceItemDao.create(item, context);
         }
 
-        List<InvoiceItem> items = recurringInvoiceItemDao.getInvoiceItemsBySubscription(subscriptionId.toString());
+        final List<InvoiceItem> items = recurringInvoiceItemDao.getInvoiceItemsBySubscription(subscriptionId.toString());
         assertEquals(items.size(), 3);
     }
 
     @Test
     public void testGetInvoiceItemsByInvoiceId() {
-        UUID accountId = UUID.randomUUID();
-        UUID invoiceId = UUID.randomUUID();
-        UUID bundleId = UUID.randomUUID();
-        DateTime startDate = new DateTime(2011, 3, 1, 0, 0, 0, 0);
-        BigDecimal rate = new BigDecimal("20.00");
+        final UUID accountId = UUID.randomUUID();
+        final UUID invoiceId = UUID.randomUUID();
+        final UUID bundleId = UUID.randomUUID();
+        final DateTime startDate = new DateTime(2011, 3, 1, 0, 0, 0, 0);
+        final BigDecimal rate = new BigDecimal("20.00");
 
         for (int i = 0; i < 5; i++) {
-            UUID subscriptionId = UUID.randomUUID();
-            BigDecimal amount = rate.multiply(new BigDecimal(i + 1));
+            final UUID subscriptionId = UUID.randomUUID();
+            final BigDecimal amount = rate.multiply(new BigDecimal(i + 1));
 
-            RecurringInvoiceItem item = new RecurringInvoiceItem(invoiceId, accountId, bundleId, subscriptionId,
-                    "test plan", "test phase", startDate, startDate.plusMonths(1),
-                    amount, amount, Currency.USD);
+            final RecurringInvoiceItem item = new RecurringInvoiceItem(invoiceId, accountId, bundleId, subscriptionId,
+                                                                       "test plan", "test phase", startDate, startDate.plusMonths(1),
+                                                                       amount, amount, Currency.USD);
             recurringInvoiceItemDao.create(item, context);
         }
 
-        List<InvoiceItem> items = recurringInvoiceItemDao.getInvoiceItemsByInvoice(invoiceId.toString());
+        final List<InvoiceItem> items = recurringInvoiceItemDao.getInvoiceItemsByInvoice(invoiceId.toString());
         assertEquals(items.size(), 5);
     }
 
     @Test
     public void testGetInvoiceItemsByAccountId() {
-        UUID accountId = UUID.randomUUID();
-        UUID bundleId = UUID.randomUUID();
-        DateTime targetDate = new DateTime(2011, 5, 23, 0, 0, 0, 0);
-        DefaultInvoice invoice = new DefaultInvoice(accountId, clock.getUTCNow(), targetDate, Currency.USD);
+        final UUID accountId = UUID.randomUUID();
+        final UUID bundleId = UUID.randomUUID();
+        final DateTime targetDate = new DateTime(2011, 5, 23, 0, 0, 0, 0);
+        final DefaultInvoice invoice = new DefaultInvoice(accountId, clock.getUTCNow(), targetDate, Currency.USD);
 
         invoiceDao.create(invoice, context);
 
-        UUID invoiceId = invoice.getId();
-        DateTime startDate = new DateTime(2011, 3, 1, 0, 0, 0, 0);
-        BigDecimal rate = new BigDecimal("20.00");
+        final UUID invoiceId = invoice.getId();
+        final DateTime startDate = new DateTime(2011, 3, 1, 0, 0, 0, 0);
+        final BigDecimal rate = new BigDecimal("20.00");
 
-        UUID subscriptionId = UUID.randomUUID();
+        final UUID subscriptionId = UUID.randomUUID();
 
-        RecurringInvoiceItem item = new RecurringInvoiceItem(invoiceId, accountId, bundleId, subscriptionId,
-                "test plan", "test phase", startDate, startDate.plusMonths(1),
-                rate, rate, Currency.USD);
+        final RecurringInvoiceItem item = new RecurringInvoiceItem(invoiceId, accountId, bundleId, subscriptionId,
+                                                                   "test plan", "test phase", startDate, startDate.plusMonths(1),
+                                                                   rate, rate, Currency.USD);
         recurringInvoiceItemDao.create(item, context);
 
-        List<InvoiceItem> items = recurringInvoiceItemDao.getInvoiceItemsByAccount(accountId.toString());
+        final List<InvoiceItem> items = recurringInvoiceItemDao.getInvoiceItemsByAccount(accountId.toString());
         assertEquals(items.size(), 1);
     }
 
     @Test
     public void testCreditInvoiceSqlDao() {
-        UUID invoiceId = UUID.randomUUID();
-        UUID accountId = UUID.randomUUID();
-        DateTime creditDate = new DateTime(2012, 4, 1, 0, 10, 22, 0);
+        final UUID invoiceId = UUID.randomUUID();
+        final UUID accountId = UUID.randomUUID();
+        final DateTime creditDate = new DateTime(2012, 4, 1, 0, 10, 22, 0);
 
-        InvoiceItem creditInvoiceItem = new CreditInvoiceItem(invoiceId, accountId, creditDate, TEN, Currency.USD);
+        final InvoiceItem creditInvoiceItem = new CreditInvoiceItem(invoiceId, accountId, creditDate, TEN, Currency.USD);
         creditInvoiceItemSqlDao.create(creditInvoiceItem, context);
 
-        InvoiceItem savedItem = creditInvoiceItemSqlDao.getById(creditInvoiceItem.getId().toString());
+        final InvoiceItem savedItem = creditInvoiceItemSqlDao.getById(creditInvoiceItem.getId().toString());
         assertEquals(savedItem, creditInvoiceItem);
     }
 
     @Test
     public void testFixedPriceInvoiceSqlDao() {
-        UUID invoiceId = UUID.randomUUID();
-        UUID accountId = UUID.randomUUID();
-        DateTime startDate = new DateTime(2012, 4, 1, 0, 10, 22, 0);
+        final UUID invoiceId = UUID.randomUUID();
+        final UUID accountId = UUID.randomUUID();
+        final DateTime startDate = new DateTime(2012, 4, 1, 0, 10, 22, 0);
 
-        InvoiceItem fixedPriceInvoiceItem = new FixedPriceInvoiceItem(invoiceId, accountId, UUID.randomUUID(),
-                UUID.randomUUID(), "test plan", "test phase", startDate, startDate.plusMonths(1), TEN, Currency.USD);
+        final InvoiceItem fixedPriceInvoiceItem = new FixedPriceInvoiceItem(invoiceId, accountId, UUID.randomUUID(),
+                                                                            UUID.randomUUID(), "test plan", "test phase", startDate, startDate.plusMonths(1), TEN, Currency.USD);
         fixedPriceInvoiceItemSqlDao.create(fixedPriceInvoiceItem, context);
 
-        InvoiceItem savedItem = fixedPriceInvoiceItemSqlDao.getById(fixedPriceInvoiceItem.getId().toString());
+        final InvoiceItem savedItem = fixedPriceInvoiceItemSqlDao.getById(fixedPriceInvoiceItem.getId().toString());
         assertEquals(savedItem, fixedPriceInvoiceItem);
     }
 }
diff --git a/invoice/src/test/java/com/ning/billing/invoice/dao/MockInvoiceDao.java b/invoice/src/test/java/com/ning/billing/invoice/dao/MockInvoiceDao.java
index e24effb..68987f8 100644
--- a/invoice/src/test/java/com/ning/billing/invoice/dao/MockInvoiceDao.java
+++ b/invoice/src/test/java/com/ning/billing/invoice/dao/MockInvoiceDao.java
@@ -23,12 +23,12 @@ import java.util.List;
 import java.util.Map;
 import java.util.UUID;
 
-import com.ning.billing.catalog.api.Currency;
-import com.ning.billing.invoice.api.InvoiceApiException;
 import org.joda.time.DateTime;
 
 import com.google.inject.Inject;
+import com.ning.billing.catalog.api.Currency;
 import com.ning.billing.invoice.api.Invoice;
+import com.ning.billing.invoice.api.InvoiceApiException;
 import com.ning.billing.invoice.api.InvoiceItem;
 import com.ning.billing.invoice.api.InvoicePayment;
 import com.ning.billing.invoice.api.user.DefaultInvoiceCreationEvent;
@@ -41,7 +41,7 @@ public class MockInvoiceDao implements InvoiceDao {
     private final Map<UUID, Invoice> invoices = new LinkedHashMap<UUID, Invoice>();
 
     @Inject
-    public MockInvoiceDao(Bus eventBus) {
+    public MockInvoiceDao(final Bus eventBus) {
         this.eventBus = eventBus;
     }
 
@@ -52,16 +52,15 @@ public class MockInvoiceDao implements InvoiceDao {
         }
         try {
             eventBus.post(new DefaultInvoiceCreationEvent(invoice.getId(), invoice.getAccountId(),
-                                                                 invoice.getBalance(), invoice.getCurrency(),
-                                                                 invoice.getInvoiceDate(), null));
-        }
-        catch (Bus.EventBusException ex) {
+                                                          invoice.getBalance(), invoice.getCurrency(),
+                                                          invoice.getInvoiceDate(), null));
+        } catch (Bus.EventBusException ex) {
             throw new RuntimeException(ex);
         }
     }
 
     @Override
-    public Invoice getById(UUID id) {
+    public Invoice getById(final UUID id) {
         synchronized (monitor) {
             return invoices.get(id);
         }
@@ -75,11 +74,11 @@ public class MockInvoiceDao implements InvoiceDao {
     }
 
     @Override
-    public List<Invoice> getInvoicesByAccount(UUID accountId) {
-        List<Invoice> result = new ArrayList<Invoice>();
+    public List<Invoice> getInvoicesByAccount(final UUID accountId) {
+        final List<Invoice> result = new ArrayList<Invoice>();
 
         synchronized (monitor) {
-            for (Invoice invoice : invoices.values()) {
+            for (final Invoice invoice : invoices.values()) {
                 if (accountId.equals(invoice.getAccountId()) && !invoice.isMigrationInvoice()) {
                     result.add(invoice);
                 }
@@ -89,11 +88,11 @@ public class MockInvoiceDao implements InvoiceDao {
     }
 
     @Override
-    public List<Invoice> getInvoicesByAccount(UUID accountId, DateTime fromDate) {
-        List<Invoice> invoicesForAccount = new ArrayList<Invoice>();
+    public List<Invoice> getInvoicesByAccount(final UUID accountId, final DateTime fromDate) {
+        final List<Invoice> invoicesForAccount = new ArrayList<Invoice>();
 
         synchronized (monitor) {
-            for (Invoice invoice : get()) {
+            for (final Invoice invoice : get()) {
                 if (accountId.equals(invoice.getAccountId()) && !invoice.getTargetDate().isBefore(fromDate) && !invoice.isMigrationInvoice()) {
                     invoicesForAccount.add(invoice);
                 }
@@ -104,12 +103,12 @@ public class MockInvoiceDao implements InvoiceDao {
     }
 
     @Override
-    public List<Invoice> getInvoicesBySubscription(UUID subscriptionId) {
-        List<Invoice> result = new ArrayList<Invoice>();
+    public List<Invoice> getInvoicesBySubscription(final UUID subscriptionId) {
+        final List<Invoice> result = new ArrayList<Invoice>();
 
         synchronized (monitor) {
-            for (Invoice invoice : invoices.values()) {
-                for (InvoiceItem item : invoice.getInvoiceItems()) {
+            for (final Invoice invoice : invoices.values()) {
+                for (final InvoiceItem item : invoice.getInvoiceItems()) {
                     if (subscriptionId.equals(item.getSubscriptionId()) && !invoice.isMigrationInvoice()) {
                         result.add(invoice);
                         break;
@@ -125,10 +124,10 @@ public class MockInvoiceDao implements InvoiceDao {
     }
 
     @Override
-    public UUID getInvoiceIdByPaymentAttemptId(UUID paymentAttemptId) {
-        synchronized(monitor) {
-            for (Invoice invoice : invoices.values()) {
-                for (InvoicePayment payment : invoice.getPayments()) {
+    public UUID getInvoiceIdByPaymentAttemptId(final UUID paymentAttemptId) {
+        synchronized (monitor) {
+            for (final Invoice invoice : invoices.values()) {
+                for (final InvoicePayment payment : invoice.getPayments()) {
                     if (paymentAttemptId.equals(payment.getPaymentAttemptId())) {
                         return invoice.getId();
                     }
@@ -139,10 +138,10 @@ public class MockInvoiceDao implements InvoiceDao {
     }
 
     @Override
-    public InvoicePayment getInvoicePayment(UUID paymentAttemptId) {
-        synchronized(monitor) {
-            for (Invoice invoice : invoices.values()) {
-                for (InvoicePayment payment : invoice.getPayments()) {
+    public InvoicePayment getInvoicePayment(final UUID paymentAttemptId) {
+        synchronized (monitor) {
+            for (final Invoice invoice : invoices.values()) {
+                for (final InvoicePayment payment : invoice.getPayments()) {
                     if (paymentAttemptId.equals(payment.getPaymentAttemptId())) {
                         return payment;
                     }
@@ -154,9 +153,9 @@ public class MockInvoiceDao implements InvoiceDao {
     }
 
     @Override
-    public void notifyOfPaymentAttempt(InvoicePayment invoicePayment, CallContext context) {
+    public void notifyOfPaymentAttempt(final InvoicePayment invoicePayment, final CallContext context) {
         synchronized (monitor) {
-            Invoice invoice = invoices.get(invoicePayment.getInvoiceId());
+            final Invoice invoice = invoices.get(invoicePayment.getInvoiceId());
             if (invoice != null) {
                 invoice.addPayment(invoicePayment);
             }
@@ -164,10 +163,10 @@ public class MockInvoiceDao implements InvoiceDao {
     }
 
     @Override
-    public BigDecimal getAccountBalance(UUID accountId) {
+    public BigDecimal getAccountBalance(final UUID accountId) {
         BigDecimal balance = BigDecimal.ZERO;
 
-        for (Invoice invoice : get()) {
+        for (final Invoice invoice : get()) {
             if (accountId.equals(invoice.getAccountId())) {
                 balance = balance.add(invoice.getBalance());
             }
@@ -177,10 +176,10 @@ public class MockInvoiceDao implements InvoiceDao {
     }
 
     @Override
-    public List<Invoice> getUnpaidInvoicesByAccountId(UUID accountId, DateTime upToDate) {
-        List<Invoice> unpaidInvoices = new ArrayList<Invoice>();
+    public List<Invoice> getUnpaidInvoicesByAccountId(final UUID accountId, final DateTime upToDate) {
+        final List<Invoice> unpaidInvoices = new ArrayList<Invoice>();
 
-        for (Invoice invoice : get()) {
+        for (final Invoice invoice : get()) {
             if (accountId.equals(invoice.getAccountId()) && (invoice.getBalance().compareTo(BigDecimal.ZERO) > 0) && !invoice.isMigrationInvoice()) {
                 unpaidInvoices.add(invoice);
             }
@@ -189,67 +188,67 @@ public class MockInvoiceDao implements InvoiceDao {
         return unpaidInvoices;
     }
 
-	@Override
-	public List<Invoice> getAllInvoicesByAccount(UUID accountId) {
-		  List<Invoice> result = new ArrayList<Invoice>();
+    @Override
+    public List<Invoice> getAllInvoicesByAccount(final UUID accountId) {
+        final List<Invoice> result = new ArrayList<Invoice>();
 
-	        synchronized (monitor) {
-	            for (Invoice invoice : invoices.values()) {
-	                if (accountId.equals(invoice.getAccountId())) {
-	                    result.add(invoice);
-	                }
-	            }
-	        }
-	        return result;
-	}
+        synchronized (monitor) {
+            for (final Invoice invoice : invoices.values()) {
+                if (accountId.equals(invoice.getAccountId())) {
+                    result.add(invoice);
+                }
+            }
+        }
+        return result;
+    }
 
     @Override
-    public void setWrittenOff(UUID objectId, CallContext context) {
+    public void setWrittenOff(final UUID objectId, final CallContext context) {
         throw new UnsupportedOperationException();
     }
 
     @Override
-    public void removeWrittenOff(UUID objectId, CallContext context) {
+    public void removeWrittenOff(final UUID objectId, final CallContext context) {
         throw new UnsupportedOperationException();
     }
 
     @Override
-    public void postChargeback(UUID invoicePaymentId, BigDecimal amount, CallContext context) throws InvoiceApiException {
+    public void postChargeback(final UUID invoicePaymentId, final BigDecimal amount, final CallContext context) throws InvoiceApiException {
         throw new UnsupportedOperationException();
     }
 
     @Override
-    public BigDecimal getRemainingAmountPaid(UUID invoicePaymentId) {
+    public BigDecimal getRemainingAmountPaid(final UUID invoicePaymentId) {
         throw new UnsupportedOperationException();
     }
 
     @Override
-    public UUID getAccountIdFromInvoicePaymentId(UUID invoicePaymentId) throws InvoiceApiException {
+    public UUID getAccountIdFromInvoicePaymentId(final UUID invoicePaymentId) throws InvoiceApiException {
         throw new UnsupportedOperationException();
     }
 
     @Override
-    public List<InvoicePayment> getChargebacksByAccountId(UUID accountId) {
+    public List<InvoicePayment> getChargebacksByAccountId(final UUID accountId) {
         throw new UnsupportedOperationException();
     }
 
     @Override
-    public List<InvoicePayment> getChargebacksByPaymentAttemptId(UUID paymentAttemptId) {
+    public List<InvoicePayment> getChargebacksByPaymentAttemptId(final UUID paymentAttemptId) {
         throw new UnsupportedOperationException();
     }
 
     @Override
-    public InvoicePayment getChargebackById(UUID chargebackId) throws InvoiceApiException {
+    public InvoicePayment getChargebackById(final UUID chargebackId) throws InvoiceApiException {
         throw new UnsupportedOperationException();
     }
 
     @Override
-    public InvoiceItem getCreditById(UUID creditId) throws InvoiceApiException {
+    public InvoiceItem getCreditById(final UUID creditId) throws InvoiceApiException {
         throw new UnsupportedOperationException();
     }
 
     @Override
-    public InvoiceItem insertCredit(UUID accountId, BigDecimal amount, DateTime effectiveDate, Currency currency, CallContext context) {
+    public InvoiceItem insertCredit(final UUID accountId, final BigDecimal amount, final DateTime effectiveDate, final Currency currency, final CallContext context) {
         throw new UnsupportedOperationException();
     }
 }
diff --git a/invoice/src/test/java/com/ning/billing/invoice/glue/InvoiceModuleWithEmbeddedDb.java b/invoice/src/test/java/com/ning/billing/invoice/glue/InvoiceModuleWithEmbeddedDb.java
index 33feebe..6017a5a 100644
--- a/invoice/src/test/java/com/ning/billing/invoice/glue/InvoiceModuleWithEmbeddedDb.java
+++ b/invoice/src/test/java/com/ning/billing/invoice/glue/InvoiceModuleWithEmbeddedDb.java
@@ -16,8 +16,6 @@
 
 package com.ning.billing.invoice.glue;
 
-import static org.testng.Assert.assertNotNull;
-
 import java.io.IOException;
 import java.net.URL;
 
@@ -52,6 +50,8 @@ import com.ning.billing.util.glue.TagStoreModule;
 import com.ning.billing.util.notificationq.MockNotificationQueueService;
 import com.ning.billing.util.notificationq.NotificationQueueService;
 
+import static org.testng.Assert.assertNotNull;
+
 public class InvoiceModuleWithEmbeddedDb extends DefaultInvoiceModule {
     private final MysqlTestingHelper helper = new MysqlTestingHelper();
     private IDBI dbi;
@@ -107,7 +107,7 @@ public class InvoiceModuleWithEmbeddedDb extends DefaultInvoiceModule {
 //      install(new AccountModule());
         bind(AccountUserApi.class).toInstance(BrainDeadProxyFactory.createBrainDeadProxyFor(AccountUserApi.class));
 
-        BillingApi billingApi = BrainDeadProxyFactory.createBrainDeadProxyFor(BillingApi.class);
+        final BillingApi billingApi = BrainDeadProxyFactory.createBrainDeadProxyFor(BillingApi.class);
         ((ZombieControl) billingApi).addResult("setChargedThroughDateFromTransaction", BrainDeadProxyFactory.ZOMBIE_VOID);
         bind(BillingApi.class).toInstance(billingApi);
 
@@ -127,7 +127,7 @@ public class InvoiceModuleWithEmbeddedDb extends DefaultInvoiceModule {
         final URL url = InvoiceModuleWithEmbeddedDb.class.getResource(resource);
         assertNotNull(url);
         try {
-            System.getProperties().load( url.openStream() );
+            System.getProperties().load(url.openStream());
         } catch (IOException e) {
             throw new RuntimeException(e);
         }
diff --git a/invoice/src/test/java/com/ning/billing/invoice/glue/InvoiceModuleWithMocks.java b/invoice/src/test/java/com/ning/billing/invoice/glue/InvoiceModuleWithMocks.java
index 49a90bc..5e4a2c3 100644
--- a/invoice/src/test/java/com/ning/billing/invoice/glue/InvoiceModuleWithMocks.java
+++ b/invoice/src/test/java/com/ning/billing/invoice/glue/InvoiceModuleWithMocks.java
@@ -25,7 +25,7 @@ import com.ning.billing.util.globallocker.MockGlobalLocker;
 
 
 public class InvoiceModuleWithMocks extends DefaultInvoiceModule {
-    @Override 
+    @Override
     protected void installInvoiceDao() {
         bind(MockInvoiceDao.class).asEagerSingleton();
         bind(InvoiceDao.class).to(MockInvoiceDao.class);
diff --git a/invoice/src/test/java/com/ning/billing/invoice/HtmlInvoiceGeneratorTest.java b/invoice/src/test/java/com/ning/billing/invoice/HtmlInvoiceGeneratorTest.java
index 144fb13..c9ca94b 100644
--- a/invoice/src/test/java/com/ning/billing/invoice/HtmlInvoiceGeneratorTest.java
+++ b/invoice/src/test/java/com/ning/billing/invoice/HtmlInvoiceGeneratorTest.java
@@ -16,6 +16,16 @@
 
 package com.ning.billing.invoice;
 
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+
+import org.joda.time.DateTime;
+import org.skife.config.ConfigurationObjectFactory;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
 import com.ning.billing.account.api.Account;
 import com.ning.billing.catalog.api.Currency;
 import com.ning.billing.invoice.api.Invoice;
@@ -28,41 +38,32 @@ import com.ning.billing.mock.BrainDeadProxyFactory.ZombieControl;
 import com.ning.billing.util.email.templates.MustacheTemplateEngine;
 import com.ning.billing.util.email.templates.TemplateEngine;
 import com.ning.billing.util.template.translation.TranslatorConfig;
-import org.joda.time.DateTime;
-import org.skife.config.ConfigurationObjectFactory;
-import org.testng.annotations.BeforeClass;
-import org.testng.annotations.Test;
-
-import java.math.BigDecimal;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Locale;
 
 import static org.testng.Assert.assertNotNull;
 
 @Test(groups = {"fast", "email"})
 public class HtmlInvoiceGeneratorTest {
     private HtmlInvoiceGenerator g;
-    private final static String TEST_TEMPLATE_NAME = "HtmlInvoiceTemplate";
+    private static final String TEST_TEMPLATE_NAME = "HtmlInvoiceTemplate";
 
     @BeforeClass
     public void setup() {
-        TranslatorConfig config = new ConfigurationObjectFactory(System.getProperties()).build(TranslatorConfig.class);
-        TemplateEngine templateEngine = new MustacheTemplateEngine();
-        InvoiceFormatterFactory factory = new DefaultInvoiceFormatterFactory();
+        final TranslatorConfig config = new ConfigurationObjectFactory(System.getProperties()).build(TranslatorConfig.class);
+        final TemplateEngine templateEngine = new MustacheTemplateEngine();
+        final InvoiceFormatterFactory factory = new DefaultInvoiceFormatterFactory();
         g = new HtmlInvoiceGenerator(factory, templateEngine, config);
     }
 
     @Test
     public void testGenerateInvoice() throws Exception {
-        String output = g.generateInvoice(createAccount(), createInvoice(), TEST_TEMPLATE_NAME);
+        final String output = g.generateInvoice(createAccount(), createInvoice(), TEST_TEMPLATE_NAME);
         assertNotNull(output);
         System.out.print(output);
     }
 
     private Account createAccount() {
-        Account account = BrainDeadProxyFactory.createBrainDeadProxyFor(Account.class);
-        ZombieControl zombieControl = (ZombieControl) account;
+        final Account account = BrainDeadProxyFactory.createBrainDeadProxyFor(Account.class);
+        final ZombieControl zombieControl = (ZombieControl) account;
         zombieControl.addResult("getExternalKey", "1234abcd");
         zombieControl.addResult("getName", "Jim Smith");
         zombieControl.addResult("getFirstNameLength", 3);
@@ -80,13 +81,13 @@ public class HtmlInvoiceGeneratorTest {
     }
 
     private Invoice createInvoice() {
-        DateTime startDate = new DateTime().minusMonths(1);
-        DateTime endDate = new DateTime();
+        final DateTime startDate = new DateTime().minusMonths(1);
+        final DateTime endDate = new DateTime();
 
-        BigDecimal price1 = new BigDecimal("29.95");
-        BigDecimal price2 = new BigDecimal("59.95");
-        Invoice dummyInvoice = BrainDeadProxyFactory.createBrainDeadProxyFor(Invoice.class);
-        ZombieControl zombie = (ZombieControl) dummyInvoice;
+        final BigDecimal price1 = new BigDecimal("29.95");
+        final BigDecimal price2 = new BigDecimal("59.95");
+        final Invoice dummyInvoice = BrainDeadProxyFactory.createBrainDeadProxyFor(Invoice.class);
+        final ZombieControl zombie = (ZombieControl) dummyInvoice;
         zombie.addResult("getInvoiceDate", startDate);
         zombie.addResult("getInvoiceNumber", 42);
         zombie.addResult("getCurrency", Currency.USD);
@@ -94,7 +95,7 @@ public class HtmlInvoiceGeneratorTest {
         zombie.addResult("getAmountPaid", BigDecimal.ZERO);
         zombie.addResult("getBalance", price1.add(price2));
 
-        List<InvoiceItem> items = new ArrayList<InvoiceItem>();
+        final List<InvoiceItem> items = new ArrayList<InvoiceItem>();
         items.add(createInvoiceItem(price1, "Domain 1", startDate, endDate, "ning-plus"));
         items.add(createInvoiceItem(price2, "Domain 2", startDate, endDate, "ning-pro"));
         zombie.addResult("getInvoiceItems", items);
@@ -102,9 +103,9 @@ public class HtmlInvoiceGeneratorTest {
         return dummyInvoice;
     }
 
-    private InvoiceItem createInvoiceItem(BigDecimal amount, String networkName, DateTime startDate, DateTime endDate, String planName) {
-        InvoiceItem item = BrainDeadProxyFactory.createBrainDeadProxyFor(InvoiceItem.class);
-        ZombieControl zombie = (ZombieControl) item;
+    private InvoiceItem createInvoiceItem(final BigDecimal amount, final String networkName, final DateTime startDate, final DateTime endDate, final String planName) {
+        final InvoiceItem item = BrainDeadProxyFactory.createBrainDeadProxyFor(InvoiceItem.class);
+        final ZombieControl zombie = (ZombieControl) item;
         zombie.addResult("getAmount", amount);
         zombie.addResult("getStartDate", startDate);
         zombie.addResult("getEndDate", endDate);
diff --git a/invoice/src/test/java/com/ning/billing/invoice/MockBillingEventSet.java b/invoice/src/test/java/com/ning/billing/invoice/MockBillingEventSet.java
index e8002f0..c8ecf34 100644
--- a/invoice/src/test/java/com/ning/billing/invoice/MockBillingEventSet.java
+++ b/invoice/src/test/java/com/ning/billing/invoice/MockBillingEventSet.java
@@ -31,14 +31,14 @@ public class MockBillingEventSet extends TreeSet<BillingEvent> implements Billin
     private boolean isAccountInvoiceOff;
     private List<UUID> subscriptionIdsWithAutoInvoiceOff = new ArrayList<UUID>();
 
-    public void addSubscriptionWithAutoInvoiceOff(UUID subscriptionId) {
+    public void addSubscriptionWithAutoInvoiceOff(final UUID subscriptionId) {
         subscriptionIdsWithAutoInvoiceOff.add(subscriptionId);
     }
 
     @Override
-    public boolean isLast(BillingEvent event) {
+    public boolean isLast(final BillingEvent event) {
         return event == last();
-     }
+    }
 
     @Override
     public boolean isAccountAutoInvoiceOff() {
@@ -50,11 +50,11 @@ public class MockBillingEventSet extends TreeSet<BillingEvent> implements Billin
         return subscriptionIdsWithAutoInvoiceOff;
     }
 
-    public void setAccountInvoiceOff(boolean isAccountInvoiceOff) {
+    public void setAccountInvoiceOff(final boolean isAccountInvoiceOff) {
         this.isAccountInvoiceOff = isAccountInvoiceOff;
     }
 
-    public void setSubscriptionIdsWithAutoInvoiceOff(List<UUID> subscriptionIdsWithAutoInvoiceOff) {
+    public void setSubscriptionIdsWithAutoInvoiceOff(final List<UUID> subscriptionIdsWithAutoInvoiceOff) {
         this.subscriptionIdsWithAutoInvoiceOff = subscriptionIdsWithAutoInvoiceOff;
     }
 
diff --git a/invoice/src/test/java/com/ning/billing/invoice/MockModule.java b/invoice/src/test/java/com/ning/billing/invoice/MockModule.java
index 816cd42..120ab0e 100644
--- a/invoice/src/test/java/com/ning/billing/invoice/MockModule.java
+++ b/invoice/src/test/java/com/ning/billing/invoice/MockModule.java
@@ -56,7 +56,7 @@ public class MockModule extends AbstractModule {
             final DbiConfig config = new ConfigurationObjectFactory(System.getProperties()).build(DbiConfig.class);
             bind(DbiConfig.class).toInstance(config);
         } else {
-            final IDBI dbi = helper.getDBI(); 
+            final IDBI dbi = helper.getDBI();
             bind(IDBI.class).toInstance(dbi);
         }
 
@@ -74,6 +74,6 @@ public class MockModule extends AbstractModule {
     }
 
     protected void installInvoiceModule() {
-    	install(new DefaultInvoiceModule());
+        install(new DefaultInvoiceModule());
     }
 }
diff --git a/invoice/src/test/java/com/ning/billing/invoice/notification/MockNextBillingDatePoster.java b/invoice/src/test/java/com/ning/billing/invoice/notification/MockNextBillingDatePoster.java
index 88ff62a..1079a2f 100644
--- a/invoice/src/test/java/com/ning/billing/invoice/notification/MockNextBillingDatePoster.java
+++ b/invoice/src/test/java/com/ning/billing/invoice/notification/MockNextBillingDatePoster.java
@@ -23,7 +23,7 @@ import org.skife.jdbi.v2.sqlobject.mixins.Transmogrifier;
 
 public class MockNextBillingDatePoster implements NextBillingDatePoster {
     @Override
-    public void insertNextBillingNotification(Transmogrifier transactionalDao, UUID subscriptionId, DateTime futureNotificationTime) {
+    public void insertNextBillingNotification(final Transmogrifier transactionalDao, final UUID subscriptionId, final DateTime futureNotificationTime) {
         // do nothing
     }
 }
diff --git a/invoice/src/test/java/com/ning/billing/invoice/notification/TestNextBillingDateNotifier.java b/invoice/src/test/java/com/ning/billing/invoice/notification/TestNextBillingDateNotifier.java
index 0164fb6..e56006f 100644
--- a/invoice/src/test/java/com/ning/billing/invoice/notification/TestNextBillingDateNotifier.java
+++ b/invoice/src/test/java/com/ning/billing/invoice/notification/TestNextBillingDateNotifier.java
@@ -16,9 +16,6 @@
 
 package com.ning.billing.invoice.notification;
 
-import static com.jayway.awaitility.Awaitility.await;
-import static java.util.concurrent.TimeUnit.MINUTES;
-
 import java.io.IOException;
 import java.sql.SQLException;
 import java.util.UUID;
@@ -67,51 +64,54 @@ import com.ning.billing.util.notificationq.DummySqlTest;
 import com.ning.billing.util.notificationq.NotificationQueueService;
 import com.ning.billing.util.notificationq.dao.NotificationSqlDao;
 
+import static com.jayway.awaitility.Awaitility.await;
+import static java.util.concurrent.TimeUnit.MINUTES;
+
 public class TestNextBillingDateNotifier {
-	private Clock clock;
-	private DefaultNextBillingDateNotifier notifier;
-	private DummySqlTest dao;
-	private Bus eventBus;
-	private MysqlTestingHelper helper;
-	private InvoiceListenerMock listener;
-	private NotificationQueueService notificationQueueService;
-
-	
-	private static final class InvoiceListenerMock extends InvoiceListener {
-		int eventCount = 0;
-		UUID latestSubscriptionId = null;
-
-		public InvoiceListenerMock(CallContextFactory factory, InvoiceDispatcher dispatcher) {
-			super(factory, dispatcher);
-		}
-
-		@Override
-		public void handleNextBillingDateEvent(UUID subscriptionId,
-				DateTime eventDateTime) {
-			eventCount++;
-			latestSubscriptionId=subscriptionId;
-		}
-
-		public int getEventCount() {
-			return eventCount;
-		}
-
-		public UUID getLatestSubscriptionId(){
-			return latestSubscriptionId;
-		}
-
-	}
-
-	@BeforeMethod(groups={"slow"})
+    private Clock clock;
+    private DefaultNextBillingDateNotifier notifier;
+    private DummySqlTest dao;
+    private Bus eventBus;
+    private MysqlTestingHelper helper;
+    private InvoiceListenerMock listener;
+    private NotificationQueueService notificationQueueService;
+
+
+    private static final class InvoiceListenerMock extends InvoiceListener {
+        int eventCount = 0;
+        UUID latestSubscriptionId = null;
+
+        public InvoiceListenerMock(final CallContextFactory factory, final InvoiceDispatcher dispatcher) {
+            super(factory, dispatcher);
+        }
+
+        @Override
+        public void handleNextBillingDateEvent(final UUID subscriptionId,
+                                               final DateTime eventDateTime) {
+            eventCount++;
+            latestSubscriptionId = subscriptionId;
+        }
+
+        public int getEventCount() {
+            return eventCount;
+        }
+
+        public UUID getLatestSubscriptionId() {
+            return latestSubscriptionId;
+        }
+
+    }
+
+    @BeforeMethod(groups = {"slow"})
     public void cleanDb() {
-	    helper.cleanupAllTables();
-	}
-
-	@BeforeClass(groups={"slow"})
-	public void setup() throws KillbillService.ServiceException, IOException, ClassNotFoundException, SQLException {
-		//TestApiBase.loadSystemPropertiesFromClasspath("/entitlement.properties");
-        final Injector g = Guice.createInjector(Stage.PRODUCTION,  new AbstractModule() {
-			
+        helper.cleanupAllTables();
+    }
+
+    @BeforeClass(groups = {"slow"})
+    public void setup() throws KillbillService.ServiceException, IOException, ClassNotFoundException, SQLException {
+        //TestApiBase.loadSystemPropertiesFromClasspath("/entitlement.properties");
+        final Injector g = Guice.createInjector(Stage.PRODUCTION, new AbstractModule() {
+
             protected void configure() {
                 install(new MockClockModule());
                 install(new BusModule(BusType.MEMORY));
@@ -119,7 +119,7 @@ public class TestNextBillingDateNotifier {
                 install(new MockJunctionModule());
                 install(new MockCatalogModule());
                 install(new NotificationQueueModule());
-                
+
                 final MysqlTestingHelper helper = new MysqlTestingHelper();
                 bind(MysqlTestingHelper.class).toInstance(helper);
                 if (helper.isUsingLocalInstance()) {
@@ -130,80 +130,80 @@ public class TestNextBillingDateNotifier {
                     final IDBI dbi = helper.getDBI();
                     bind(IDBI.class).toInstance(dbi);
                 }
-                
-            
+
+
             }
         });
 
         clock = g.getInstance(Clock.class);
-        IDBI dbi = g.getInstance(IDBI.class);
+        final IDBI dbi = g.getInstance(IDBI.class);
         dao = dbi.onDemand(DummySqlTest.class);
         eventBus = g.getInstance(Bus.class);
         helper = g.getInstance(MysqlTestingHelper.class);
         notificationQueueService = g.getInstance(NotificationQueueService.class);
-        InvoiceDispatcher dispatcher = g.getInstance(InvoiceDispatcher.class);
+        final InvoiceDispatcher dispatcher = g.getInstance(InvoiceDispatcher.class);
 
-        Subscription subscription = BrainDeadProxyFactory.createBrainDeadProxyFor(Subscription.class);
-        EntitlementUserApi entitlementUserApi = BrainDeadProxyFactory.createBrainDeadProxyFor(EntitlementUserApi.class);
+        final Subscription subscription = BrainDeadProxyFactory.createBrainDeadProxyFor(Subscription.class);
+        final EntitlementUserApi entitlementUserApi = BrainDeadProxyFactory.createBrainDeadProxyFor(EntitlementUserApi.class);
         ((ZombieControl) entitlementUserApi).addResult("getSubscriptionFromId", subscription);
 
-        CallContextFactory factory = new DefaultCallContextFactory(clock);
+        final CallContextFactory factory = new DefaultCallContextFactory(clock);
         listener = new InvoiceListenerMock(factory, dispatcher);
-        notifier = new DefaultNextBillingDateNotifier(notificationQueueService,g.getInstance(InvoiceConfig.class), entitlementUserApi, listener);
+        notifier = new DefaultNextBillingDateNotifier(notificationQueueService, g.getInstance(InvoiceConfig.class), entitlementUserApi, listener);
         startMysql();
-	}
+    }
 
-	private void startMysql() throws IOException, ClassNotFoundException, SQLException {
-		final String ddl = IOUtils.toString(NotificationSqlDao.class.getResourceAsStream("/com/ning/billing/util/ddl.sql"));
-		final String testDdl = IOUtils.toString(NotificationSqlDao.class.getResourceAsStream("/com/ning/billing/util/ddl_test.sql"));
-		helper.startMysql();
-		helper.initDb(ddl);
-		helper.initDb(testDdl);
-	}
+    private void startMysql() throws IOException, ClassNotFoundException, SQLException {
+        final String ddl = IOUtils.toString(NotificationSqlDao.class.getResourceAsStream("/com/ning/billing/util/ddl.sql"));
+        final String testDdl = IOUtils.toString(NotificationSqlDao.class.getResourceAsStream("/com/ning/billing/util/ddl_test.sql"));
+        helper.startMysql();
+        helper.initDb(ddl);
+        helper.initDb(testDdl);
+    }
 
 
-	@Test(enabled=true, groups="slow")
-	public void testInvoiceNotifier() throws Exception {
-		final UUID subscriptionId = new UUID(0L,1L);
-		final DateTime now = new DateTime();
-		final DateTime readyTime = now.plusMillis(2000);
-		final NextBillingDatePoster poster = new DefaultNextBillingDatePoster(notificationQueueService);
+    @Test(enabled = true, groups = "slow")
+    public void testInvoiceNotifier() throws Exception {
+        final UUID subscriptionId = new UUID(0L, 1L);
+        final DateTime now = new DateTime();
+        final DateTime readyTime = now.plusMillis(2000);
+        final NextBillingDatePoster poster = new DefaultNextBillingDatePoster(notificationQueueService);
 
-		eventBus.start();
-		notifier.initialize();
-		notifier.start();
+        eventBus.start();
+        notifier.initialize();
+        notifier.start();
 
 
-		dao.inTransaction(new Transaction<Void, DummySqlTest>() {
-			@Override
-			public Void inTransaction(DummySqlTest transactional,
-					TransactionStatus status) throws Exception {
+        dao.inTransaction(new Transaction<Void, DummySqlTest>() {
+            @Override
+            public Void inTransaction(final DummySqlTest transactional,
+                                      final TransactionStatus status) throws Exception {
 
-				poster.insertNextBillingNotification(transactional, subscriptionId, readyTime);
-				return null;
-			}
-		});
+                poster.insertNextBillingNotification(transactional, subscriptionId, readyTime);
+                return null;
+            }
+        });
 
 
-		// Move time in the future after the notification effectiveDate
-		((ClockMock) clock).setDeltaFromReality(3000);
+        // Move time in the future after the notification effectiveDate
+        ((ClockMock) clock).setDeltaFromReality(3000);
 
 
-	    await().atMost(1, MINUTES).until(new Callable<Boolean>() {
-	            @Override
-	            public Boolean call() throws Exception {
-	                return listener.getEventCount() == 1;
-	            }
-	        });
+        await().atMost(1, MINUTES).until(new Callable<Boolean>() {
+            @Override
+            public Boolean call() throws Exception {
+                return listener.getEventCount() == 1;
+            }
+        });
 
-		Assert.assertEquals(listener.getEventCount(), 1);
-		Assert.assertEquals(listener.getLatestSubscriptionId(), subscriptionId);
-	}
+        Assert.assertEquals(listener.getEventCount(), 1);
+        Assert.assertEquals(listener.getLatestSubscriptionId(), subscriptionId);
+    }
 
-	@AfterClass(groups="slow")
+    @AfterClass(groups = "slow")
     public void tearDown() throws Exception {
-	    notifier.stop();
-    	helper.stopMysql();
+        notifier.stop();
+        helper.stopMysql();
     }
 
 }
diff --git a/invoice/src/test/java/com/ning/billing/invoice/TestInvoiceDispatcher.java b/invoice/src/test/java/com/ning/billing/invoice/TestInvoiceDispatcher.java
index 679049a..f864108 100644
--- a/invoice/src/test/java/com/ning/billing/invoice/TestInvoiceDispatcher.java
+++ b/invoice/src/test/java/com/ning/billing/invoice/TestInvoiceDispatcher.java
@@ -67,22 +67,22 @@ import com.ning.billing.util.globallocker.GlobalLocker;
 @Test(groups = "slow")
 @Guice(modules = {MockModule.class})
 public class TestInvoiceDispatcher extends InvoicingTestBase {
-	private Logger log = LoggerFactory.getLogger(TestInvoiceDispatcher.class);
+    private final Logger log = LoggerFactory.getLogger(TestInvoiceDispatcher.class);
 
-	@Inject
-	private InvoiceGenerator generator;
+    @Inject
+    private InvoiceGenerator generator;
 
-	@Inject
-	private InvoiceDao invoiceDao;
+    @Inject
+    private InvoiceDao invoiceDao;
 
-	@Inject
-	private GlobalLocker locker;
+    @Inject
+    private GlobalLocker locker;
 
-	@Inject
-	private MysqlTestingHelper helper;
+    @Inject
+    private MysqlTestingHelper helper;
 
-	@Inject
-	private NextBillingDateNotifier notifier;
+    @Inject
+    private NextBillingDateNotifier notifier;
 
     @Inject
     private BusService busService;
@@ -96,91 +96,90 @@ public class TestInvoiceDispatcher extends InvoicingTestBase {
     private CallContext context;
 
     @BeforeSuite(groups = "slow")
-    public void setup() throws Exception
-    {
-		final String invoiceDdl = IOUtils.toString(TestInvoiceDispatcher.class.getResourceAsStream("/com/ning/billing/invoice/ddl.sql"));
-		final String utilDdl = IOUtils.toString(TestInvoiceDispatcher.class.getResourceAsStream("/com/ning/billing/util/ddl.sql"));
+    public void setup() throws Exception {
+        final String invoiceDdl = IOUtils.toString(TestInvoiceDispatcher.class.getResourceAsStream("/com/ning/billing/invoice/ddl.sql"));
+        final String utilDdl = IOUtils.toString(TestInvoiceDispatcher.class.getResourceAsStream("/com/ning/billing/util/ddl.sql"));
 
-		helper.startMysql();
+        helper.startMysql();
 
-		helper.initDb(invoiceDdl);
-		helper.initDb(utilDdl);
-		notifier.initialize();
-		notifier.start();
+        helper.initDb(invoiceDdl);
+        helper.initDb(utilDdl);
+        notifier.initialize();
+        notifier.start();
 
         context = new DefaultCallContextFactory(clock).createCallContext("Miracle Max", CallOrigin.TEST, UserType.TEST);
 
-		busService.getBus().start();
-		((ZombieControl)billingApi).addResult("setChargedThroughDate", BrainDeadProxyFactory.ZOMBIE_VOID);
-	}
-
-	@AfterClass(alwaysRun = true)
-	public void tearDown() {
-		try {
-			((DefaultBusService) busService).stopBus();
-			notifier.stop();
-			helper.stopMysql();
-		} catch (Exception e) {
-			log.warn("Failed to tearDown test properly ", e);
-		}
+        busService.getBus().start();
+        ((ZombieControl) billingApi).addResult("setChargedThroughDate", BrainDeadProxyFactory.ZOMBIE_VOID);
     }
-	    
-    @Test(groups={"slow"}, enabled=true)
+
+    @AfterClass(alwaysRun = true)
+    public void tearDown() {
+        try {
+            ((DefaultBusService) busService).stopBus();
+            notifier.stop();
+            helper.stopMysql();
+        } catch (Exception e) {
+            log.warn("Failed to tearDown test properly ", e);
+        }
+    }
+
+    @Test(groups = {"slow"}, enabled = true)
     public void testDryRunInvoice() throws InvoiceApiException {
-        UUID accountId = UUID.randomUUID();
-        UUID subscriptionId = UUID.randomUUID();
+        final UUID accountId = UUID.randomUUID();
+        final UUID subscriptionId = UUID.randomUUID();
 
-		AccountUserApi accountUserApi = BrainDeadProxyFactory.createBrainDeadProxyFor(AccountUserApi.class);
-		Account account = BrainDeadProxyFactory.createBrainDeadProxyFor(Account.class);
+        final AccountUserApi accountUserApi = BrainDeadProxyFactory.createBrainDeadProxyFor(AccountUserApi.class);
+        final Account account = BrainDeadProxyFactory.createBrainDeadProxyFor(Account.class);
 
-		((ZombieControl)accountUserApi).addResult("getAccountById", account);
-		((ZombieControl)account).addResult("getCurrency", Currency.USD);
-		((ZombieControl)account).addResult("getId", accountId);
-        ((ZombieControl)account).addResult(("isNotifiedForInvoices"), true);
+        ((ZombieControl) accountUserApi).addResult("getAccountById", account);
+        ((ZombieControl) account).addResult("getCurrency", Currency.USD);
+        ((ZombieControl) account).addResult("getId", accountId);
+        ((ZombieControl) account).addResult(("isNotifiedForInvoices"), true);
 
-		Subscription subscription =  BrainDeadProxyFactory.createBrainDeadProxyFor(Subscription.class);
-        ((ZombieControl)subscription).addResult("getId", subscriptionId);
-        ((ZombieControl)subscription).addResult("getBundleId", new UUID(0L,0L));
-        BillingEventSet events = new MockBillingEventSet();
-		Plan plan = MockPlan.createBicycleNoTrialEvergreen1USD();
-		PlanPhase planPhase = MockPlanPhase.create1USDMonthlyEvergreen();
-		DateTime effectiveDate = new DateTime().minusDays(1);
-		Currency currency = Currency.USD;
-		BigDecimal fixedPrice = null;
-		events.add(createMockBillingEvent(account, subscription, effectiveDate, plan, planPhase,
-                fixedPrice, BigDecimal.ONE, currency, BillingPeriod.MONTHLY, 1,
-                BillingModeType.IN_ADVANCE, "", 1L, SubscriptionTransitionType.CREATE));
+        final Subscription subscription = BrainDeadProxyFactory.createBrainDeadProxyFor(Subscription.class);
+        ((ZombieControl) subscription).addResult("getId", subscriptionId);
+        ((ZombieControl) subscription).addResult("getBundleId", new UUID(0L, 0L));
+        final BillingEventSet events = new MockBillingEventSet();
+        final Plan plan = MockPlan.createBicycleNoTrialEvergreen1USD();
+        final PlanPhase planPhase = MockPlanPhase.create1USDMonthlyEvergreen();
+        final DateTime effectiveDate = new DateTime().minusDays(1);
+        final Currency currency = Currency.USD;
+        final BigDecimal fixedPrice = null;
+        events.add(createMockBillingEvent(account, subscription, effectiveDate, plan, planPhase,
+                                          fixedPrice, BigDecimal.ONE, currency, BillingPeriod.MONTHLY, 1,
+                                          BillingModeType.IN_ADVANCE, "", 1L, SubscriptionTransitionType.CREATE));
 
-		((ZombieControl) billingApi).addResult("getBillingEventsForAccountAndUpdateAccountBCD", events);
+        ((ZombieControl) billingApi).addResult("getBillingEventsForAccountAndUpdateAccountBCD", events);
 
-		DateTime target = new DateTime();
+        final DateTime target = new DateTime();
 
-        InvoiceNotifier invoiceNotifier = new NullInvoiceNotifier();
-		InvoiceDispatcher dispatcher = new InvoiceDispatcher(generator, accountUserApi, billingApi, invoiceDao,
-                                                             invoiceNotifier, locker, busService.getBus(), clock);
+        final InvoiceNotifier invoiceNotifier = new NullInvoiceNotifier();
+        final InvoiceDispatcher dispatcher = new InvoiceDispatcher(generator, accountUserApi, billingApi, invoiceDao,
+                                                                   invoiceNotifier, locker, busService.getBus(), clock);
 
-		Invoice invoice = dispatcher.processAccount(accountId, target, true, context);
-		Assert.assertNotNull(invoice);
+        Invoice invoice = dispatcher.processAccount(accountId, target, true, context);
+        Assert.assertNotNull(invoice);
 
-		List<Invoice> invoices = invoiceDao.getInvoicesByAccount(accountId);
-		Assert.assertEquals(invoices.size(), 0);
+        List<Invoice> invoices = invoiceDao.getInvoicesByAccount(accountId);
+        Assert.assertEquals(invoices.size(), 0);
 
-		// Try it again to double check
-		invoice = dispatcher.processAccount(accountId, target, true, context);
-		Assert.assertNotNull(invoice);
+        // Try it again to double check
+        invoice = dispatcher.processAccount(accountId, target, true, context);
+        Assert.assertNotNull(invoice);
 
-		invoices = invoiceDao.getInvoicesByAccount(accountId);
-		Assert.assertEquals(invoices.size(), 0);
+        invoices = invoiceDao.getInvoicesByAccount(accountId);
+        Assert.assertEquals(invoices.size(), 0);
 
-		// This time no dry run
-		invoice = dispatcher.processAccount(accountId, target, false, context);
-		Assert.assertNotNull(invoice);
+        // This time no dry run
+        invoice = dispatcher.processAccount(accountId, target, false, context);
+        Assert.assertNotNull(invoice);
 
-		invoices = invoiceDao.getInvoicesByAccount(accountId);
-		Assert.assertEquals(invoices.size(),1);
+        invoices = invoiceDao.getInvoicesByAccount(accountId);
+        Assert.assertEquals(invoices.size(), 1);
+
+    }
 
-	}
-    
     //MDW add a test to cover when the account auto-invoice-off tag is present
 
 }
diff --git a/invoice/src/test/java/com/ning/billing/invoice/tests/ChargeBackTests.java b/invoice/src/test/java/com/ning/billing/invoice/tests/ChargeBackTests.java
index 8d5ac43..ce941b9 100644
--- a/invoice/src/test/java/com/ning/billing/invoice/tests/ChargeBackTests.java
+++ b/invoice/src/test/java/com/ning/billing/invoice/tests/ChargeBackTests.java
@@ -16,6 +16,15 @@
 
 package com.ning.billing.invoice.tests;
 
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+
+import org.skife.jdbi.v2.IDBI;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
 import com.ning.billing.catalog.api.Currency;
 import com.ning.billing.dbi.MysqlTestingHelper;
 import com.ning.billing.invoice.api.Invoice;
@@ -43,43 +52,33 @@ import com.ning.billing.util.tag.dao.MockTagDefinitionDao;
 import com.ning.billing.util.tag.dao.TagDao;
 import com.ning.billing.util.tag.dao.TagDefinitionDao;
 
-import org.skife.jdbi.v2.IDBI;
-import org.testng.annotations.BeforeClass;
-import org.testng.annotations.Test;
-
-import java.math.BigDecimal;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.UUID;
-
 import static org.testng.Assert.assertEquals;
 import static org.testng.Assert.assertNotNull;
 import static org.testng.Assert.assertTrue;
-import static org.testng.Assert.fail;
 
 @Test(groups = {"slow", "invoicing"})
 public class ChargeBackTests {
-    private final static BigDecimal FIFTEEN = new BigDecimal("15.00");
-    private final static BigDecimal THIRTY = new BigDecimal("30.00");
-    private final static BigDecimal ONE_MILLION = new BigDecimal("1000000.00");
+    private static final BigDecimal FIFTEEN = new BigDecimal("15.00");
+    private static final BigDecimal THIRTY = new BigDecimal("30.00");
+    private static final BigDecimal ONE_MILLION = new BigDecimal("1000000.00");
     private InvoiceSqlDao invoiceSqlDao;
     private InvoicePaymentApi invoicePaymentApi;
     private CallContext context;
     private final Clock clock = new ClockMock();
-    private final static Currency CURRENCY = Currency.EUR;
+    private static final Currency CURRENCY = Currency.EUR;
 
     @BeforeClass
     public void setup() {
-        MysqlTestingHelper helper = new MysqlTestingHelper();
-        IDBI dbi = helper.getDBI();
+        final MysqlTestingHelper helper = new MysqlTestingHelper();
+        final IDBI dbi = helper.getDBI();
         invoiceSqlDao = dbi.onDemand(InvoiceSqlDao.class);
         invoiceSqlDao.test();
 
-        NextBillingDatePoster nextBillingDatePoster = new MockNextBillingDatePoster();
+        final NextBillingDatePoster nextBillingDatePoster = new MockNextBillingDatePoster();
         final TagDefinitionDao tagDefinitionDao = new MockTagDefinitionDao();
         final TagDao tagDao = new MockTagDao();
         final TagUserApi tagUserApi = new DefaultTagUserApi(tagDefinitionDao, tagDao);
-        InvoiceDao invoiceDao = new DefaultInvoiceDao(dbi, nextBillingDatePoster, tagUserApi);
+        final InvoiceDao invoiceDao = new DefaultInvoiceDao(dbi, nextBillingDatePoster, tagUserApi);
         invoicePaymentApi = new DefaultInvoicePaymentApi(invoiceDao);
 
         context = new TestCallContext("Charge back tests");
@@ -87,34 +86,34 @@ public class ChargeBackTests {
 
     @Test
     public void testCompleteChargeBack() throws InvoiceApiException {
-        Invoice invoice = createAndPersistInvoice(THIRTY);
-        InvoicePayment payment = createAndPersistPayment(invoice.getId(), THIRTY);
+        final Invoice invoice = createAndPersistInvoice(THIRTY);
+        final InvoicePayment payment = createAndPersistPayment(invoice.getId(), THIRTY);
 
         // create a full charge back
         invoicePaymentApi.processChargeback(payment.getId(), THIRTY, context);
 
         // check amount owed
-        BigDecimal amount = invoicePaymentApi.getRemainingAmountPaid(payment.getId());
+        final BigDecimal amount = invoicePaymentApi.getRemainingAmountPaid(payment.getId());
         assertTrue(amount.compareTo(BigDecimal.ZERO) == 0);
     }
 
     @Test
     public void testPartialChargeBack() throws InvoiceApiException {
-        Invoice invoice = createAndPersistInvoice(THIRTY);
-        InvoicePayment payment = createAndPersistPayment(invoice.getId(), THIRTY);
+        final Invoice invoice = createAndPersistInvoice(THIRTY);
+        final InvoicePayment payment = createAndPersistPayment(invoice.getId(), THIRTY);
 
         // create a partial charge back
         invoicePaymentApi.processChargeback(payment.getId(), FIFTEEN, context);
 
         // check amount owed
-        BigDecimal amount = invoicePaymentApi.getRemainingAmountPaid(payment.getId());
+        final BigDecimal amount = invoicePaymentApi.getRemainingAmountPaid(payment.getId());
         assertTrue(amount.compareTo(FIFTEEN) == 0);
     }
 
     @Test(expectedExceptions = InvoiceApiException.class)
     public void testChargeBackLargerThanPaymentAmount() throws InvoiceApiException {
-        Invoice invoice = createAndPersistInvoice(THIRTY);
-        InvoicePayment payment = createAndPersistPayment(invoice.getId(), THIRTY);
+        final Invoice invoice = createAndPersistInvoice(THIRTY);
+        final InvoicePayment payment = createAndPersistPayment(invoice.getId(), THIRTY);
 
         // create a large charge back
         invoicePaymentApi.processChargeback(payment.getId(), ONE_MILLION, context);
@@ -122,8 +121,8 @@ public class ChargeBackTests {
 
     @Test(expectedExceptions = InvoiceApiException.class)
     public void testNegativeChargeBackAmount() throws InvoiceApiException {
-        Invoice invoice = createAndPersistInvoice(THIRTY);
-        InvoicePayment payment = createAndPersistPayment(invoice.getId(), THIRTY);
+        final Invoice invoice = createAndPersistInvoice(THIRTY);
+        final InvoicePayment payment = createAndPersistPayment(invoice.getId(), THIRTY);
 
         // create a partial charge back
         invoicePaymentApi.processChargeback(payment.getId(), BigDecimal.ONE.negate(), context);
@@ -131,9 +130,9 @@ public class ChargeBackTests {
 
     @Test
     public void testGetAccountIdFromPaymentIdHappyPath() throws InvoiceApiException {
-        Invoice invoice = createAndPersistInvoice(THIRTY);
-        InvoicePayment payment = createAndPersistPayment(invoice.getId(), THIRTY);
-        UUID accountId = invoicePaymentApi.getAccountIdFromInvoicePaymentId(payment.getId());
+        final Invoice invoice = createAndPersistInvoice(THIRTY);
+        final InvoicePayment payment = createAndPersistPayment(invoice.getId(), THIRTY);
+        final UUID accountId = invoicePaymentApi.getAccountIdFromInvoicePaymentId(payment.getId());
         assertEquals(accountId, invoice.getAccountId());
     }
 
@@ -144,20 +143,20 @@ public class ChargeBackTests {
 
     @Test
     public void testGetChargeBacksByAccountIdWithEmptyReturnSet() throws InvoiceApiException {
-        List<InvoicePayment> chargebacks = invoicePaymentApi.getChargebacksByAccountId(UUID.randomUUID());
+        final List<InvoicePayment> chargebacks = invoicePaymentApi.getChargebacksByAccountId(UUID.randomUUID());
         assertNotNull(chargebacks);
         assertEquals(chargebacks.size(), 0);
     }
 
     @Test
     public void testGetChargeBacksByAccountIdHappyPath() throws InvoiceApiException {
-        Invoice invoice = createAndPersistInvoice(THIRTY);
-        InvoicePayment payment = createAndPersistPayment(invoice.getId(), THIRTY);
+        final Invoice invoice = createAndPersistInvoice(THIRTY);
+        final InvoicePayment payment = createAndPersistPayment(invoice.getId(), THIRTY);
 
         // create a partial charge back
         invoicePaymentApi.processChargeback(payment.getId(), FIFTEEN, context);
 
-        List<InvoicePayment> chargebacks = invoicePaymentApi.getChargebacksByAccountId(invoice.getAccountId());
+        final List<InvoicePayment> chargebacks = invoicePaymentApi.getChargebacksByAccountId(invoice.getAccountId());
         assertNotNull(chargebacks);
         assertEquals(chargebacks.size(), 1);
         assertEquals(chargebacks.get(0).getReversedInvoicePaymentId(), payment.getId());
@@ -165,30 +164,30 @@ public class ChargeBackTests {
 
     @Test
     public void testGetChargeBacksByPaymentAttemptIdWithEmptyReturnSet() throws InvoiceApiException {
-        List<InvoicePayment> chargebacks = invoicePaymentApi.getChargebacksByPaymentAttemptId(UUID.randomUUID());
+        final List<InvoicePayment> chargebacks = invoicePaymentApi.getChargebacksByPaymentAttemptId(UUID.randomUUID());
         assertNotNull(chargebacks);
         assertEquals(chargebacks.size(), 0);
     }
 
     @Test
     public void testGetChargeBacksByInvoicePaymentIdHappyPath() throws InvoiceApiException {
-        Invoice invoice = createAndPersistInvoice(THIRTY);
-        InvoicePayment payment = createAndPersistPayment(invoice.getId(), THIRTY);
+        final Invoice invoice = createAndPersistInvoice(THIRTY);
+        final InvoicePayment payment = createAndPersistPayment(invoice.getId(), THIRTY);
 
         // create a partial charge back
         invoicePaymentApi.processChargeback(payment.getId(), FIFTEEN, context);
 
-        List<InvoicePayment> chargebacks = invoicePaymentApi.getChargebacksByPaymentAttemptId(payment.getPaymentAttemptId());
+        final List<InvoicePayment> chargebacks = invoicePaymentApi.getChargebacksByPaymentAttemptId(payment.getPaymentAttemptId());
         assertNotNull(chargebacks);
         assertEquals(chargebacks.size(), 1);
         assertEquals(chargebacks.get(0).getReversedInvoicePaymentId(), payment.getId());
     }
 
-    private Invoice createAndPersistInvoice(BigDecimal amount) {
-        Invoice invoice = BrainDeadProxyFactory.createBrainDeadProxyFor(Invoice.class);
-        UUID invoiceId = UUID.randomUUID();
-        UUID accountId = UUID.randomUUID();
-        ZombieControl zombie = (ZombieControl) invoice;
+    private Invoice createAndPersistInvoice(final BigDecimal amount) {
+        final Invoice invoice = BrainDeadProxyFactory.createBrainDeadProxyFor(Invoice.class);
+        final UUID invoiceId = UUID.randomUUID();
+        final UUID accountId = UUID.randomUUID();
+        final ZombieControl zombie = (ZombieControl) invoice;
         zombie.addResult("getId", invoiceId);
         zombie.addResult("getAccountId", accountId);
         zombie.addResult("getInvoiceDate", clock.getUTCNow());
@@ -196,7 +195,7 @@ public class ChargeBackTests {
         zombie.addResult("getCurrency", CURRENCY);
         zombie.addResult("isMigrationInvoice", false);
 
-        List<InvoiceItem> items = new ArrayList<InvoiceItem>();
+        final List<InvoiceItem> items = new ArrayList<InvoiceItem>();
         items.add(createInvoiceItem(invoiceId, accountId, amount));
         zombie.addResult("getInvoiceItems", items);
 
@@ -205,14 +204,14 @@ public class ChargeBackTests {
         return invoice;
     }
 
-    private InvoiceItem createInvoiceItem(UUID invoiceId, UUID accountId, BigDecimal amount) {
+    private InvoiceItem createInvoiceItem(final UUID invoiceId, final UUID accountId, final BigDecimal amount) {
         return new FixedPriceInvoiceItem(invoiceId, accountId, UUID.randomUUID(), UUID.randomUUID(),
-                "charge back test", "charge back phase", clock.getUTCNow(), clock.getUTCNow(), amount, CURRENCY);
+                                         "charge back test", "charge back phase", clock.getUTCNow(), clock.getUTCNow(), amount, CURRENCY);
     }
 
-    private InvoicePayment createAndPersistPayment(UUID invoiceId, BigDecimal amount) {
-        InvoicePayment payment = BrainDeadProxyFactory.createBrainDeadProxyFor(InvoicePayment.class);
-        ZombieControl zombie = (ZombieControl) payment;
+    private InvoicePayment createAndPersistPayment(final UUID invoiceId, final BigDecimal amount) {
+        final InvoicePayment payment = BrainDeadProxyFactory.createBrainDeadProxyFor(InvoicePayment.class);
+        final ZombieControl zombie = (ZombieControl) payment;
         zombie.addResult("getId", UUID.randomUUID());
         zombie.addResult("getInvoiceId", invoiceId);
         zombie.addResult("getPaymentAttemptId", UUID.randomUUID());
diff --git a/invoice/src/test/java/com/ning/billing/invoice/tests/DefaultInvoiceGeneratorTests.java b/invoice/src/test/java/com/ning/billing/invoice/tests/DefaultInvoiceGeneratorTests.java
index 8f381bc..7441173 100644
--- a/invoice/src/test/java/com/ning/billing/invoice/tests/DefaultInvoiceGeneratorTests.java
+++ b/invoice/src/test/java/com/ning/billing/invoice/tests/DefaultInvoiceGeneratorTests.java
@@ -16,11 +16,7 @@
 
 package com.ning.billing.invoice.tests;
 
-import static org.testng.Assert.assertEquals;
-import static org.testng.Assert.assertNotNull;
-import static org.testng.Assert.assertNull;
-import static org.testng.Assert.assertTrue;
-
+import javax.annotation.Nullable;
 import java.math.BigDecimal;
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -29,8 +25,6 @@ import java.util.List;
 import java.util.Map;
 import java.util.UUID;
 
-import javax.annotation.Nullable;
-
 import org.joda.time.DateTime;
 import org.testng.annotations.Test;
 
@@ -54,8 +48,8 @@ import com.ning.billing.invoice.api.Invoice;
 import com.ning.billing.invoice.api.InvoiceApiException;
 import com.ning.billing.invoice.api.InvoiceItem;
 import com.ning.billing.invoice.model.CreditInvoiceItem;
-import com.ning.billing.invoice.model.DefaultInvoiceGenerator;
 import com.ning.billing.invoice.model.DefaultInvoice;
+import com.ning.billing.invoice.model.DefaultInvoiceGenerator;
 import com.ning.billing.invoice.model.DefaultInvoicePayment;
 import com.ning.billing.invoice.model.FixedPriceInvoiceItem;
 import com.ning.billing.invoice.model.InvoiceGenerator;
@@ -66,6 +60,11 @@ import com.ning.billing.mock.BrainDeadProxyFactory.ZombieControl;
 import com.ning.billing.util.clock.Clock;
 import com.ning.billing.util.clock.DefaultClock;
 
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertNotNull;
+import static org.testng.Assert.assertNull;
+import static org.testng.Assert.assertTrue;
+
 @Test(groups = {"fast", "invoicing", "invoiceGenerator"})
 public class DefaultInvoiceGeneratorTests extends InvoicingTestBase {
     private final InvoiceGenerator generator;
@@ -73,8 +72,8 @@ public class DefaultInvoiceGeneratorTests extends InvoicingTestBase {
     public DefaultInvoiceGeneratorTests() {
         super();
 
-        Clock clock = new DefaultClock();
-        InvoiceConfig invoiceConfig = new InvoiceConfig() {
+        final Clock clock = new DefaultClock();
+        final InvoiceConfig invoiceConfig = new InvoiceConfig() {
             @Override
             public long getSleepTimeMs() {
                 throw new UnsupportedOperationException();
@@ -95,39 +94,39 @@ public class DefaultInvoiceGeneratorTests extends InvoicingTestBase {
 
     @Test
     public void testWithNullEventSetAndNullInvoiceSet() throws InvoiceApiException {
-        UUID accountId = UUID.randomUUID();
-        Invoice invoice = generator.generateInvoice(accountId, null, null, new DateTime(), Currency.USD);
+        final UUID accountId = UUID.randomUUID();
+        final Invoice invoice = generator.generateInvoice(accountId, null, null, new DateTime(), Currency.USD);
 
         assertNull(invoice);
     }
 
     @Test
     public void testWithEmptyEventSet() throws InvoiceApiException {
-        BillingEventSet events = new MockBillingEventSet();
+        final BillingEventSet events = new MockBillingEventSet();
 
-        UUID accountId = UUID.randomUUID();
-        Invoice invoice = generator.generateInvoice(accountId, events, null, new DateTime(), Currency.USD);
+        final UUID accountId = UUID.randomUUID();
+        final Invoice invoice = generator.generateInvoice(accountId, events, null, new DateTime(), Currency.USD);
 
         assertNull(invoice);
     }
 
     @Test
     public void testWithSingleMonthlyEvent() throws InvoiceApiException, CatalogApiException {
-        BillingEventSet events = new MockBillingEventSet();
+        final BillingEventSet events = new MockBillingEventSet();
 
-        Subscription sub = createZombieSubscription();
-        DateTime startDate = buildDateTime(2011, 9, 1);
+        final Subscription sub = createZombieSubscription();
+        final DateTime startDate = buildDateTime(2011, 9, 1);
 
-        Plan plan = new MockPlan();
-        BigDecimal rate1 = TEN;
-        PlanPhase phase = createMockMonthlyPlanPhase(rate1);
+        final Plan plan = new MockPlan();
+        final BigDecimal rate1 = TEN;
+        final PlanPhase phase = createMockMonthlyPlanPhase(rate1);
 
-        BillingEvent event = createBillingEvent(sub.getId(), startDate, plan, phase, 1);
+        final BillingEvent event = createBillingEvent(sub.getId(), startDate, plan, phase, 1);
         events.add(event);
 
-        DateTime targetDate = buildDateTime(2011, 10, 3);
-        UUID accountId = UUID.randomUUID();
-        Invoice invoice = generator.generateInvoice(accountId, events, null, targetDate, Currency.USD);
+        final DateTime targetDate = buildDateTime(2011, 10, 3);
+        final UUID accountId = UUID.randomUUID();
+        final Invoice invoice = generator.generateInvoice(accountId, events, null, targetDate, Currency.USD);
 
         assertNotNull(invoice);
         assertEquals(invoice.getNumberOfItems(), 2);
@@ -139,8 +138,8 @@ public class DefaultInvoiceGeneratorTests extends InvoicingTestBase {
         return createZombieSubscription(UUID.randomUUID());
     }
 
-    private Subscription createZombieSubscription(UUID subscriptionId) {
-        Subscription sub = BrainDeadProxyFactory.createBrainDeadProxyFor(Subscription.class);
+    private Subscription createZombieSubscription(final UUID subscriptionId) {
+        final Subscription sub = BrainDeadProxyFactory.createBrainDeadProxyFor(Subscription.class);
         ((ZombieControl) sub).addResult("getId", subscriptionId);
         ((ZombieControl) sub).addResult("getBundleId", UUID.randomUUID());
 
@@ -149,53 +148,53 @@ public class DefaultInvoiceGeneratorTests extends InvoicingTestBase {
 
     @Test
     public void testWithSingleMonthlyEventWithLeadingProRation() throws InvoiceApiException, CatalogApiException {
-        BillingEventSet events = new MockBillingEventSet();
+        final BillingEventSet events = new MockBillingEventSet();
 
-        Subscription sub = createZombieSubscription();
-        DateTime startDate = buildDateTime(2011, 9, 1);
+        final Subscription sub = createZombieSubscription();
+        final DateTime startDate = buildDateTime(2011, 9, 1);
 
-        Plan plan = new MockPlan();
-        BigDecimal rate = TEN;
-        PlanPhase phase = createMockMonthlyPlanPhase(rate);
-        BillingEvent event = createBillingEvent(sub.getId(), startDate, plan, phase, 15);
+        final Plan plan = new MockPlan();
+        final BigDecimal rate = TEN;
+        final PlanPhase phase = createMockMonthlyPlanPhase(rate);
+        final BillingEvent event = createBillingEvent(sub.getId(), startDate, plan, phase, 15);
         events.add(event);
 
-        DateTime targetDate = buildDateTime(2011, 10, 3);
-        UUID accountId = UUID.randomUUID();
-        Invoice invoice = generator.generateInvoice(accountId, events, null, targetDate, Currency.USD);
+        final DateTime targetDate = buildDateTime(2011, 10, 3);
+        final UUID accountId = UUID.randomUUID();
+        final Invoice invoice = generator.generateInvoice(accountId, events, null, targetDate, Currency.USD);
 
         assertNotNull(invoice);
         assertEquals(invoice.getNumberOfItems(), 2);
 
-        BigDecimal expectedNumberOfBillingCycles;
+        final BigDecimal expectedNumberOfBillingCycles;
         expectedNumberOfBillingCycles = ONE.add(FOURTEEN.divide(THIRTY_ONE, 2 * NUMBER_OF_DECIMALS, ROUNDING_METHOD));
-        BigDecimal expectedAmount = expectedNumberOfBillingCycles.multiply(rate).setScale(NUMBER_OF_DECIMALS, ROUNDING_METHOD);
+        final BigDecimal expectedAmount = expectedNumberOfBillingCycles.multiply(rate).setScale(NUMBER_OF_DECIMALS, ROUNDING_METHOD);
         assertEquals(invoice.getBalance(), expectedAmount);
     }
 
     @Test
     public void testTwoMonthlySubscriptionsWithAlignedBillingDates() throws InvoiceApiException, CatalogApiException {
-        BillingEventSet events = new MockBillingEventSet();
+        final BillingEventSet events = new MockBillingEventSet();
 
-        Plan plan1 = new MockPlan();
-        BigDecimal rate1 = FIVE;
-        PlanPhase phase1 = createMockMonthlyPlanPhase(rate1);
+        final Plan plan1 = new MockPlan();
+        final BigDecimal rate1 = FIVE;
+        final PlanPhase phase1 = createMockMonthlyPlanPhase(rate1);
 
-        Plan plan2 = new MockPlan();
-        BigDecimal rate2 = TEN;
-        PlanPhase phase2 = createMockMonthlyPlanPhase(rate2);
+        final Plan plan2 = new MockPlan();
+        final BigDecimal rate2 = TEN;
+        final PlanPhase phase2 = createMockMonthlyPlanPhase(rate2);
 
-        Subscription sub = createZombieSubscription();
+        final Subscription sub = createZombieSubscription();
 
-        BillingEvent event1 = createBillingEvent(sub.getId(), buildDateTime(2011, 9, 1), plan1, phase1, 1);
+        final BillingEvent event1 = createBillingEvent(sub.getId(), buildDateTime(2011, 9, 1), plan1, phase1, 1);
         events.add(event1);
 
-        BillingEvent event2 = createBillingEvent(sub.getId(), buildDateTime(2011, 10, 1), plan2, phase2, 1);
+        final BillingEvent event2 = createBillingEvent(sub.getId(), buildDateTime(2011, 10, 1), plan2, phase2, 1);
         events.add(event2);
 
-        DateTime targetDate = buildDateTime(2011, 10, 3);
-        UUID accountId = UUID.randomUUID();
-        Invoice invoice = generator.generateInvoice(accountId, events, null, targetDate, Currency.USD);
+        final DateTime targetDate = buildDateTime(2011, 10, 3);
+        final UUID accountId = UUID.randomUUID();
+        final Invoice invoice = generator.generateInvoice(accountId, events, null, targetDate, Currency.USD);
 
         assertNotNull(invoice);
         assertEquals(invoice.getNumberOfItems(), 2);
@@ -204,32 +203,32 @@ public class DefaultInvoiceGeneratorTests extends InvoicingTestBase {
 
     @Test
     public void testOnePlan_TwoMonthlyPhases_ChangeImmediate() throws InvoiceApiException, CatalogApiException {
-        BillingEventSet events = new MockBillingEventSet();
+        final BillingEventSet events = new MockBillingEventSet();
 
-        Plan plan1 = new MockPlan();
-        BigDecimal rate1 = FIVE;
-        PlanPhase phase1 = createMockMonthlyPlanPhase(rate1);
+        final Plan plan1 = new MockPlan();
+        final BigDecimal rate1 = FIVE;
+        final PlanPhase phase1 = createMockMonthlyPlanPhase(rate1);
 
-        Subscription sub = createZombieSubscription();
-        BillingEvent event1 = createBillingEvent(sub.getId(), buildDateTime(2011, 9, 1), plan1,phase1, 1);
+        final Subscription sub = createZombieSubscription();
+        final BillingEvent event1 = createBillingEvent(sub.getId(), buildDateTime(2011, 9, 1), plan1, phase1, 1);
         events.add(event1);
 
-        BigDecimal rate2 = TEN;
-        PlanPhase phase2 = createMockMonthlyPlanPhase(rate2);
-        BillingEvent event2 = createBillingEvent(sub.getId(), buildDateTime(2011, 10, 15), plan1, phase2, 15);
+        final BigDecimal rate2 = TEN;
+        final PlanPhase phase2 = createMockMonthlyPlanPhase(rate2);
+        final BillingEvent event2 = createBillingEvent(sub.getId(), buildDateTime(2011, 10, 15), plan1, phase2, 15);
         events.add(event2);
 
-        DateTime targetDate = buildDateTime(2011, 12, 3);
-        UUID accountId = UUID.randomUUID();
-        Invoice invoice = generator.generateInvoice(accountId, events, null, targetDate, Currency.USD);
+        final DateTime targetDate = buildDateTime(2011, 12, 3);
+        final UUID accountId = UUID.randomUUID();
+        final Invoice invoice = generator.generateInvoice(accountId, events, null, targetDate, Currency.USD);
 
         assertNotNull(invoice);
         assertEquals(invoice.getNumberOfItems(), 4);
 
-        BigDecimal numberOfCyclesEvent1;
+        final BigDecimal numberOfCyclesEvent1;
         numberOfCyclesEvent1 = ONE.add(FOURTEEN.divide(THIRTY_ONE, 2 * NUMBER_OF_DECIMALS, ROUNDING_METHOD));
 
-        BigDecimal numberOfCyclesEvent2 = TWO;
+        final BigDecimal numberOfCyclesEvent2 = TWO;
 
         BigDecimal expectedValue;
         expectedValue = numberOfCyclesEvent1.multiply(rate1);
@@ -241,29 +240,29 @@ public class DefaultInvoiceGeneratorTests extends InvoicingTestBase {
 
     @Test
     public void testOnePlan_ThreeMonthlyPhases_ChangeEOT() throws InvoiceApiException, CatalogApiException {
-        BillingEventSet events = new MockBillingEventSet();
+        final BillingEventSet events = new MockBillingEventSet();
 
-        Plan plan1 = new MockPlan();
-        BigDecimal rate1 = FIVE;
-        PlanPhase phase1 = createMockMonthlyPlanPhase(rate1);
+        final Plan plan1 = new MockPlan();
+        final BigDecimal rate1 = FIVE;
+        final PlanPhase phase1 = createMockMonthlyPlanPhase(rate1);
 
-        Subscription sub = createZombieSubscription();
-        BillingEvent event1 = createBillingEvent(sub.getId(), buildDateTime(2011, 9, 1), plan1, phase1, 1);
+        final Subscription sub = createZombieSubscription();
+        final BillingEvent event1 = createBillingEvent(sub.getId(), buildDateTime(2011, 9, 1), plan1, phase1, 1);
         events.add(event1);
 
-        BigDecimal rate2 = TEN;
-        PlanPhase phase2 = createMockMonthlyPlanPhase(rate2);
-        BillingEvent event2 = createBillingEvent(sub.getId(), buildDateTime(2011, 10, 1), plan1, phase2, 1);
+        final BigDecimal rate2 = TEN;
+        final PlanPhase phase2 = createMockMonthlyPlanPhase(rate2);
+        final BillingEvent event2 = createBillingEvent(sub.getId(), buildDateTime(2011, 10, 1), plan1, phase2, 1);
         events.add(event2);
 
-        BigDecimal rate3 = THIRTY;
-        PlanPhase phase3 = createMockMonthlyPlanPhase(rate3);
-        BillingEvent event3 = createBillingEvent(sub.getId(), buildDateTime(2011, 11, 1), plan1, phase3, 1);
+        final BigDecimal rate3 = THIRTY;
+        final PlanPhase phase3 = createMockMonthlyPlanPhase(rate3);
+        final BillingEvent event3 = createBillingEvent(sub.getId(), buildDateTime(2011, 11, 1), plan1, phase3, 1);
         events.add(event3);
 
-        DateTime targetDate = buildDateTime(2011, 12, 3);
-        UUID accountId = UUID.randomUUID();
-        Invoice invoice = generator.generateInvoice(accountId, events, null, targetDate, Currency.USD);
+        final DateTime targetDate = buildDateTime(2011, 12, 3);
+        final UUID accountId = UUID.randomUUID();
+        final Invoice invoice = generator.generateInvoice(accountId, events, null, targetDate, Currency.USD);
 
         assertNotNull(invoice);
         assertEquals(invoice.getNumberOfItems(), 4);
@@ -272,26 +271,26 @@ public class DefaultInvoiceGeneratorTests extends InvoicingTestBase {
 
     @Test
     public void testSingleEventWithExistingInvoice() throws InvoiceApiException, CatalogApiException {
-        BillingEventSet events = new MockBillingEventSet();
+        final BillingEventSet events = new MockBillingEventSet();
 
-        Subscription sub = createZombieSubscription();
-        DateTime startDate = buildDateTime(2011, 9, 1);
+        final Subscription sub = createZombieSubscription();
+        final DateTime startDate = buildDateTime(2011, 9, 1);
 
-        Plan plan1 = new MockPlan();
-        BigDecimal rate = FIVE;
-        PlanPhase phase1 = createMockMonthlyPlanPhase(rate);
+        final Plan plan1 = new MockPlan();
+        final BigDecimal rate = FIVE;
+        final PlanPhase phase1 = createMockMonthlyPlanPhase(rate);
 
-        BillingEvent event1 = createBillingEvent(sub.getId(), startDate, plan1, phase1, 1);
+        final BillingEvent event1 = createBillingEvent(sub.getId(), startDate, plan1, phase1, 1);
         events.add(event1);
 
         DateTime targetDate = buildDateTime(2011, 12, 1);
-        UUID accountId = UUID.randomUUID();
-        Invoice invoice1 = generator.generateInvoice(accountId, events, null, targetDate, Currency.USD);
-        List<Invoice> existingInvoices = new ArrayList<Invoice>();
+        final UUID accountId = UUID.randomUUID();
+        final Invoice invoice1 = generator.generateInvoice(accountId, events, null, targetDate, Currency.USD);
+        final List<Invoice> existingInvoices = new ArrayList<Invoice>();
         existingInvoices.add(invoice1);
 
         targetDate = buildDateTime(2011, 12, 3);
-        Invoice invoice2 = generator.generateInvoice(accountId, events, existingInvoices, targetDate, Currency.USD);
+        final Invoice invoice2 = generator.generateInvoice(accountId, events, existingInvoices, targetDate, Currency.USD);
 
         assertNull(invoice2);
     }
@@ -304,52 +303,52 @@ public class DefaultInvoiceGeneratorTests extends InvoicingTestBase {
         // plan 3: change of term from monthly (BCD = 20) to annual (BCD = 31; immediate)
         // plan 4: change of plan, effective EOT, BCD = 7 (covers change of plan)
         // plan 5: addon to plan 2, with bill cycle alignment to plan; immediate cancellation
-        UUID accountId = UUID.randomUUID();
-        UUID subscriptionId1 = UUID.randomUUID();
-        UUID subscriptionId2 = UUID.randomUUID();
-        UUID subscriptionId3 = UUID.randomUUID();
-        UUID subscriptionId4 = UUID.randomUUID();
-        UUID subscriptionId5 = UUID.randomUUID();
-
-        Plan plan1 = new MockPlan("Change from trial to discount with immediate cancellation");
-        PlanPhase plan1Phase1 = createMockMonthlyPlanPhase(EIGHT, PhaseType.TRIAL);
-        PlanPhase plan1Phase2 = createMockMonthlyPlanPhase(TWELVE, PhaseType.DISCOUNT);
-        PlanPhase plan1Phase3 = createMockMonthlyPlanPhase();
-        DateTime plan1StartDate = buildDateTime(2011, 1, 5);
-        DateTime plan1PhaseChangeDate = buildDateTime(2011, 4, 5);
-        DateTime plan1CancelDate = buildDateTime(2011, 4, 29);
-
-        Plan plan2 = new MockPlan("Change phase from trial to discount to evergreen");
-        PlanPhase plan2Phase1 = createMockMonthlyPlanPhase(TWENTY, PhaseType.TRIAL);
-        PlanPhase plan2Phase2 = createMockMonthlyPlanPhase(THIRTY, PhaseType.DISCOUNT);
-        PlanPhase plan2Phase3 = createMockMonthlyPlanPhase(FORTY, PhaseType.EVERGREEN);
-        DateTime plan2StartDate = buildDateTime(2011, 3, 10);
-        DateTime plan2PhaseChangeToDiscountDate = buildDateTime(2011, 6, 10);
-        DateTime plan2PhaseChangeToEvergreenDate = buildDateTime(2011, 9, 10);
-
-        Plan plan3 = new MockPlan("Upgrade with immediate change, BCD = 31");
-        PlanPhase plan3Phase1 = createMockMonthlyPlanPhase(TEN, PhaseType.EVERGREEN);
-        PlanPhase plan3Phase2 = createMockAnnualPlanPhase(ONE_HUNDRED, PhaseType.EVERGREEN);
-        DateTime plan3StartDate = buildDateTime(2011, 5, 20);
-        DateTime plan3UpgradeToAnnualDate = buildDateTime(2011, 7, 31);
-
-        Plan plan4a = new MockPlan("Plan change effective EOT; plan 1");
-        Plan plan4b = new MockPlan("Plan change effective EOT; plan 2");
-        PlanPhase plan4aPhase1 = createMockMonthlyPlanPhase(FIFTEEN);
-        PlanPhase plan4bPhase1 = createMockMonthlyPlanPhase(TWENTY_FOUR);
-
-        DateTime plan4StartDate = buildDateTime(2011, 6, 7);
-        DateTime plan4ChangeOfPlanDate = buildDateTime(2011, 8, 7);
-
-        Plan plan5 = new MockPlan("Add-on");
-        PlanPhase plan5Phase1 = createMockMonthlyPlanPhase(TWENTY);
-        PlanPhase plan5Phase2 = createMockMonthlyPlanPhase();
-        DateTime plan5StartDate = buildDateTime(2011, 6, 21);
-        DateTime plan5CancelDate = buildDateTime(2011, 10, 7);
+        final UUID accountId = UUID.randomUUID();
+        final UUID subscriptionId1 = UUID.randomUUID();
+        final UUID subscriptionId2 = UUID.randomUUID();
+        final UUID subscriptionId3 = UUID.randomUUID();
+        final UUID subscriptionId4 = UUID.randomUUID();
+        final UUID subscriptionId5 = UUID.randomUUID();
+
+        final Plan plan1 = new MockPlan("Change from trial to discount with immediate cancellation");
+        final PlanPhase plan1Phase1 = createMockMonthlyPlanPhase(EIGHT, PhaseType.TRIAL);
+        final PlanPhase plan1Phase2 = createMockMonthlyPlanPhase(TWELVE, PhaseType.DISCOUNT);
+        final PlanPhase plan1Phase3 = createMockMonthlyPlanPhase();
+        final DateTime plan1StartDate = buildDateTime(2011, 1, 5);
+        final DateTime plan1PhaseChangeDate = buildDateTime(2011, 4, 5);
+        final DateTime plan1CancelDate = buildDateTime(2011, 4, 29);
+
+        final Plan plan2 = new MockPlan("Change phase from trial to discount to evergreen");
+        final PlanPhase plan2Phase1 = createMockMonthlyPlanPhase(TWENTY, PhaseType.TRIAL);
+        final PlanPhase plan2Phase2 = createMockMonthlyPlanPhase(THIRTY, PhaseType.DISCOUNT);
+        final PlanPhase plan2Phase3 = createMockMonthlyPlanPhase(FORTY, PhaseType.EVERGREEN);
+        final DateTime plan2StartDate = buildDateTime(2011, 3, 10);
+        final DateTime plan2PhaseChangeToDiscountDate = buildDateTime(2011, 6, 10);
+        final DateTime plan2PhaseChangeToEvergreenDate = buildDateTime(2011, 9, 10);
+
+        final Plan plan3 = new MockPlan("Upgrade with immediate change, BCD = 31");
+        final PlanPhase plan3Phase1 = createMockMonthlyPlanPhase(TEN, PhaseType.EVERGREEN);
+        final PlanPhase plan3Phase2 = createMockAnnualPlanPhase(ONE_HUNDRED, PhaseType.EVERGREEN);
+        final DateTime plan3StartDate = buildDateTime(2011, 5, 20);
+        final DateTime plan3UpgradeToAnnualDate = buildDateTime(2011, 7, 31);
+
+        final Plan plan4a = new MockPlan("Plan change effective EOT; plan 1");
+        final Plan plan4b = new MockPlan("Plan change effective EOT; plan 2");
+        final PlanPhase plan4aPhase1 = createMockMonthlyPlanPhase(FIFTEEN);
+        final PlanPhase plan4bPhase1 = createMockMonthlyPlanPhase(TWENTY_FOUR);
+
+        final DateTime plan4StartDate = buildDateTime(2011, 6, 7);
+        final DateTime plan4ChangeOfPlanDate = buildDateTime(2011, 8, 7);
+
+        final Plan plan5 = new MockPlan("Add-on");
+        final PlanPhase plan5Phase1 = createMockMonthlyPlanPhase(TWENTY);
+        final PlanPhase plan5Phase2 = createMockMonthlyPlanPhase();
+        final DateTime plan5StartDate = buildDateTime(2011, 6, 21);
+        final DateTime plan5CancelDate = buildDateTime(2011, 10, 7);
 
         BigDecimal expectedAmount;
-        List<Invoice> invoices = new ArrayList<Invoice>();
-        BillingEventSet events = new MockBillingEventSet();
+        final List<Invoice> invoices = new ArrayList<Invoice>();
+        final BillingEventSet events = new MockBillingEventSet();
 
         // on 1/5/2011, create subscription 1 (trial)
         events.add(createBillingEvent(subscriptionId1, plan1StartDate, plan1, plan1Phase1, 5));
@@ -358,7 +357,7 @@ public class DefaultInvoiceGeneratorTests extends InvoicingTestBase {
 
         // on 2/5/2011, invoice subscription 1 (trial)
         expectedAmount = EIGHT;
-        testInvoiceGeneration(accountId, events, invoices, buildDateTime(2011, 2, 5) , 1, expectedAmount);
+        testInvoiceGeneration(accountId, events, invoices, buildDateTime(2011, 2, 5), 1, expectedAmount);
 
         // on 3/5/2011, invoice subscription 1 (trial)
         expectedAmount = EIGHT;
@@ -454,33 +453,33 @@ public class DefaultInvoiceGeneratorTests extends InvoicingTestBase {
         testInvoiceGeneration(accountId, events, invoices, plan5CancelDate, 3, expectedAmount);
 
         // on 10/10/2011, invoice plan 2 (evergreen)
-        expectedAmount = FORTY ;
+        expectedAmount = FORTY;
         testInvoiceGeneration(accountId, events, invoices, buildDateTime(2011, 10, 10), 1, expectedAmount);
     }
 
     @Test
     public void testZeroDollarEvents() throws InvoiceApiException, CatalogApiException {
-        Plan plan = new MockPlan();
-        PlanPhase planPhase = createMockMonthlyPlanPhase(ZERO);
-        BillingEventSet events = new MockBillingEventSet();
-        DateTime targetDate = buildDateTime(2011, 1, 1);
+        final Plan plan = new MockPlan();
+        final PlanPhase planPhase = createMockMonthlyPlanPhase(ZERO);
+        final BillingEventSet events = new MockBillingEventSet();
+        final DateTime targetDate = buildDateTime(2011, 1, 1);
         events.add(createBillingEvent(UUID.randomUUID(), targetDate, plan, planPhase, 1));
 
-        Invoice invoice = generator.generateInvoice(UUID.randomUUID(), events, null, targetDate, Currency.USD);
+        final Invoice invoice = generator.generateInvoice(UUID.randomUUID(), events, null, targetDate, Currency.USD);
 
         assertEquals(invoice.getNumberOfItems(), 1);
     }
 
     @Test
     public void testEndDateIsCorrect() throws InvoiceApiException, CatalogApiException {
-        Plan plan = new MockPlan();
-        PlanPhase planPhase = createMockMonthlyPlanPhase(ZERO);
-        BillingEventSet events = new MockBillingEventSet();
-        DateTime targetDate = new DateTime();
+        final Plan plan = new MockPlan();
+        final PlanPhase planPhase = createMockMonthlyPlanPhase(ZERO);
+        final BillingEventSet events = new MockBillingEventSet();
+        final DateTime targetDate = new DateTime();
         events.add(createBillingEvent(UUID.randomUUID(), targetDate, plan, planPhase, targetDate.getDayOfMonth()));
 
-        Invoice invoice = generator.generateInvoice(UUID.randomUUID(), events, null, targetDate, Currency.USD);
-        RecurringInvoiceItem item = (RecurringInvoiceItem) invoice.getInvoiceItems().get(0);
+        final Invoice invoice = generator.generateInvoice(UUID.randomUUID(), events, null, targetDate, Currency.USD);
+        final RecurringInvoiceItem item = (RecurringInvoiceItem) invoice.getInvoiceItems().get(0);
 
         // end date of the invoice item should be equal to exactly one month later
         assertEquals(item.getEndDate().compareTo(targetDate.plusMonths(1)), 0);
@@ -488,77 +487,77 @@ public class DefaultInvoiceGeneratorTests extends InvoicingTestBase {
 
     @Test
     public void testFixedPriceLifeCycle() throws InvoiceApiException {
-        UUID accountId = UUID.randomUUID();
-        Subscription subscription = createZombieSubscription();
+        final UUID accountId = UUID.randomUUID();
+        final Subscription subscription = createZombieSubscription();
 
-        Plan plan = new MockPlan("plan 1");
-        MockInternationalPrice zeroPrice = new MockInternationalPrice(new DefaultPrice(ZERO, Currency.USD));
-        MockInternationalPrice cheapPrice = new MockInternationalPrice(new DefaultPrice(ONE, Currency.USD));
+        final Plan plan = new MockPlan("plan 1");
+        final MockInternationalPrice zeroPrice = new MockInternationalPrice(new DefaultPrice(ZERO, Currency.USD));
+        final MockInternationalPrice cheapPrice = new MockInternationalPrice(new DefaultPrice(ONE, Currency.USD));
 
-        PlanPhase phase1 = new MockPlanPhase(null, zeroPrice, BillingPeriod.NO_BILLING_PERIOD, PhaseType.TRIAL);
-        PlanPhase phase2 = new MockPlanPhase(cheapPrice, null, BillingPeriod.MONTHLY, PhaseType.DISCOUNT);
+        final PlanPhase phase1 = new MockPlanPhase(null, zeroPrice, BillingPeriod.NO_BILLING_PERIOD, PhaseType.TRIAL);
+        final PlanPhase phase2 = new MockPlanPhase(cheapPrice, null, BillingPeriod.MONTHLY, PhaseType.DISCOUNT);
 
-        DateTime changeDate = new DateTime("2012-04-1T00:00:00.000-08:00");
+        final DateTime changeDate = new DateTime("2012-04-1T00:00:00.000-08:00");
 
-        BillingEventSet events = new MockBillingEventSet();
+        final BillingEventSet events = new MockBillingEventSet();
 
-        BillingEvent event1 = createMockBillingEvent(null, subscription, new DateTime("2012-01-1T00:00:00.000-08:00"),
-                plan, phase1,
-                ZERO, null, Currency.USD, BillingPeriod.NO_BILLING_PERIOD, 1,
-                BillingModeType.IN_ADVANCE, "Test Event 1", 1L,
-                SubscriptionTransitionType.CREATE);
+        final BillingEvent event1 = createMockBillingEvent(null, subscription, new DateTime("2012-01-1T00:00:00.000-08:00"),
+                                                           plan, phase1,
+                                                           ZERO, null, Currency.USD, BillingPeriod.NO_BILLING_PERIOD, 1,
+                                                           BillingModeType.IN_ADVANCE, "Test Event 1", 1L,
+                                                           SubscriptionTransitionType.CREATE);
 
-        BillingEvent event2 = createMockBillingEvent(null, subscription, changeDate,
-                plan, phase2,
-                ZERO, null, Currency.USD, BillingPeriod.NO_BILLING_PERIOD, 1,
-                BillingModeType.IN_ADVANCE, "Test Event 2", 2L,
-                SubscriptionTransitionType.PHASE);
+        final BillingEvent event2 = createMockBillingEvent(null, subscription, changeDate,
+                                                           plan, phase2,
+                                                           ZERO, null, Currency.USD, BillingPeriod.NO_BILLING_PERIOD, 1,
+                                                           BillingModeType.IN_ADVANCE, "Test Event 2", 2L,
+                                                           SubscriptionTransitionType.PHASE);
 
         events.add(event2);
         events.add(event1);
-        Invoice invoice1 = generator.generateInvoice(accountId, events, null, new DateTime("2012-02-01T00:01:00.000-08:00"), Currency.USD);
+        final Invoice invoice1 = generator.generateInvoice(accountId, events, null, new DateTime("2012-02-01T00:01:00.000-08:00"), Currency.USD);
         assertNotNull(invoice1);
         assertEquals(invoice1.getNumberOfItems(), 1);
 
-        List<Invoice> invoiceList = new ArrayList<Invoice>();
+        final List<Invoice> invoiceList = new ArrayList<Invoice>();
         invoiceList.add(invoice1);
-        Invoice invoice2 = generator.generateInvoice(accountId, events, invoiceList, new DateTime("2012-04-05T00:01:00.000-08:00"), Currency.USD);
+        final Invoice invoice2 = generator.generateInvoice(accountId, events, invoiceList, new DateTime("2012-04-05T00:01:00.000-08:00"), Currency.USD);
         assertNotNull(invoice2);
         assertEquals(invoice2.getNumberOfItems(), 1);
-        FixedPriceInvoiceItem item = (FixedPriceInvoiceItem) invoice2.getInvoiceItems().get(0);
+        final FixedPriceInvoiceItem item = (FixedPriceInvoiceItem) invoice2.getInvoiceItems().get(0);
         assertEquals(item.getStartDate().compareTo(changeDate), 0);
-   }
+    }
 
     @Test
     public void testMixedModeLifeCycle() throws InvoiceApiException, CatalogApiException {
         // create a subscription with a fixed price and recurring price
-        Plan plan1 = new MockPlan();
-        BigDecimal monthlyRate = FIVE;
-        BigDecimal fixedCost = TEN;
-        PlanPhase phase1 = createMockMonthlyPlanPhase(monthlyRate, fixedCost, PhaseType.TRIAL);
+        final Plan plan1 = new MockPlan();
+        final BigDecimal monthlyRate = FIVE;
+        final BigDecimal fixedCost = TEN;
+        final PlanPhase phase1 = createMockMonthlyPlanPhase(monthlyRate, fixedCost, PhaseType.TRIAL);
 
-        BillingEventSet events = new MockBillingEventSet();
-        UUID subscriptionId = UUID.randomUUID();
-        UUID accountId = UUID.randomUUID();
+        final BillingEventSet events = new MockBillingEventSet();
+        final UUID subscriptionId = UUID.randomUUID();
+        final UUID accountId = UUID.randomUUID();
 
-        DateTime startDate = new DateTime(2011, 1, 1, 3, 40, 27, 0);
-        BillingEvent event1 = createBillingEvent(subscriptionId, startDate, plan1, phase1, 1);
+        final DateTime startDate = new DateTime(2011, 1, 1, 3, 40, 27, 0);
+        final BillingEvent event1 = createBillingEvent(subscriptionId, startDate, plan1, phase1, 1);
         events.add(event1);
 
         // ensure both components are invoiced
-        Invoice invoice1 = generator.generateInvoice(accountId, events, null, startDate, Currency.USD);
+        final Invoice invoice1 = generator.generateInvoice(accountId, events, null, startDate, Currency.USD);
         assertNotNull(invoice1);
         assertEquals(invoice1.getNumberOfItems(), 2);
         assertEquals(invoice1.getBalance(), FIFTEEN);
 
-        List<Invoice> invoiceList = new ArrayList<Invoice>();
+        final List<Invoice> invoiceList = new ArrayList<Invoice>();
         invoiceList.add(invoice1);
 
         // move forward in time one billing period
-        DateTime currentDate = startDate.plusMonths(1);
+        final DateTime currentDate = startDate.plusMonths(1);
 
         // ensure that only the recurring price is invoiced
-        Invoice invoice2 = generator.generateInvoice(accountId, events, invoiceList, currentDate, Currency.USD);
+        final Invoice invoice2 = generator.generateInvoice(accountId, events, invoiceList, currentDate, Currency.USD);
         assertNotNull(invoice2);
         assertEquals(invoice2.getNumberOfItems(), 1);
         assertEquals(invoice2.getBalance(), FIVE);
@@ -567,36 +566,36 @@ public class DefaultInvoiceGeneratorTests extends InvoicingTestBase {
     @Test
     public void testFixedModePlanChange() throws InvoiceApiException, CatalogApiException {
         // create a subscription with a fixed price and recurring price
-        Plan plan1 = new MockPlan();
-        BigDecimal fixedCost1 = TEN;
-        BigDecimal fixedCost2 = TWENTY;
-        PlanPhase phase1 = createMockMonthlyPlanPhase(null, fixedCost1, PhaseType.TRIAL);
-        PlanPhase phase2 = createMockMonthlyPlanPhase(null, fixedCost2, PhaseType.EVERGREEN);
-
-        BillingEventSet events = new MockBillingEventSet();
-        UUID subscriptionId = UUID.randomUUID();
-        UUID accountId = UUID.randomUUID();
-
-        DateTime startDate = new DateTime(2011, 1, 1, 3, 40, 27, 0);
-        BillingEvent event1 = createBillingEvent(subscriptionId, startDate, plan1, phase1, 1);
+        final Plan plan1 = new MockPlan();
+        final BigDecimal fixedCost1 = TEN;
+        final BigDecimal fixedCost2 = TWENTY;
+        final PlanPhase phase1 = createMockMonthlyPlanPhase(null, fixedCost1, PhaseType.TRIAL);
+        final PlanPhase phase2 = createMockMonthlyPlanPhase(null, fixedCost2, PhaseType.EVERGREEN);
+
+        final BillingEventSet events = new MockBillingEventSet();
+        final UUID subscriptionId = UUID.randomUUID();
+        final UUID accountId = UUID.randomUUID();
+
+        final DateTime startDate = new DateTime(2011, 1, 1, 3, 40, 27, 0);
+        final BillingEvent event1 = createBillingEvent(subscriptionId, startDate, plan1, phase1, 1);
         events.add(event1);
 
         // ensure that a single invoice item is generated for the fixed cost
-        Invoice invoice1 = generator.generateInvoice(accountId, events, null, startDate, Currency.USD);
+        final Invoice invoice1 = generator.generateInvoice(accountId, events, null, startDate, Currency.USD);
         assertNotNull(invoice1);
         assertEquals(invoice1.getNumberOfItems(), 1);
         assertEquals(invoice1.getBalance(), fixedCost1);
 
-        List<Invoice> invoiceList = new ArrayList<Invoice>();
+        final List<Invoice> invoiceList = new ArrayList<Invoice>();
         invoiceList.add(invoice1);
 
         // move forward in time one billing period
-        DateTime phaseChangeDate = startDate.plusMonths(1);
-        BillingEvent event2 = createBillingEvent(subscriptionId, phaseChangeDate, plan1, phase2, 1);
+        final DateTime phaseChangeDate = startDate.plusMonths(1);
+        final BillingEvent event2 = createBillingEvent(subscriptionId, phaseChangeDate, plan1, phase2, 1);
         events.add(event2);
 
         // ensure that a single invoice item is generated for the fixed cost
-        Invoice invoice2 = generator.generateInvoice(accountId, events, invoiceList, phaseChangeDate, Currency.USD);
+        final Invoice invoice2 = generator.generateInvoice(accountId, events, invoiceList, phaseChangeDate, Currency.USD);
         assertNotNull(invoice2);
         assertEquals(invoice2.getNumberOfItems(), 1);
         assertEquals(invoice2.getBalance(), fixedCost2);
@@ -604,39 +603,39 @@ public class DefaultInvoiceGeneratorTests extends InvoicingTestBase {
 
     @Test
     public void testInvoiceGenerationFailureScenario() throws InvoiceApiException, CatalogApiException {
-        BillingEventSet events = new MockBillingEventSet();
-        UUID subscriptionId = UUID.randomUUID();
-        UUID accountId = UUID.randomUUID();
+        final BillingEventSet events = new MockBillingEventSet();
+        final UUID subscriptionId = UUID.randomUUID();
+        final UUID accountId = UUID.randomUUID();
         final int BILL_CYCLE_DAY = 15;
 
         // create subscription with a zero-dollar trial, a monthly discount period and a monthly evergreen
-        Plan plan1 = new MockPlan();
-        PlanPhase phase1 = createMockMonthlyPlanPhase(null, ZERO, PhaseType.TRIAL);
+        final Plan plan1 = new MockPlan();
+        final PlanPhase phase1 = createMockMonthlyPlanPhase(null, ZERO, PhaseType.TRIAL);
         final BigDecimal DISCOUNT_PRICE = new BigDecimal("9.95");
-        PlanPhase phase2 = createMockMonthlyPlanPhase(DISCOUNT_PRICE, null, PhaseType.DISCOUNT);
-        PlanPhase phase3 = createMockMonthlyPlanPhase(new BigDecimal("19.95"), null, PhaseType.EVERGREEN);
+        final PlanPhase phase2 = createMockMonthlyPlanPhase(DISCOUNT_PRICE, null, PhaseType.DISCOUNT);
+        final PlanPhase phase3 = createMockMonthlyPlanPhase(new BigDecimal("19.95"), null, PhaseType.EVERGREEN);
 
         // set up billing events
-        DateTime creationDate = new DateTime(2012, 3, 6, 21, 36, 18, 896);
+        final DateTime creationDate = new DateTime(2012, 3, 6, 21, 36, 18, 896);
         events.add(createBillingEvent(subscriptionId, creationDate, plan1, phase1, BILL_CYCLE_DAY));
 
         // trialPhaseEndDate = 2012/4/5
-        DateTime trialPhaseEndDate = creationDate.plusDays(30);
+        final DateTime trialPhaseEndDate = creationDate.plusDays(30);
         events.add(createBillingEvent(subscriptionId, trialPhaseEndDate, plan1, phase2, BILL_CYCLE_DAY));
 
         // discountPhaseEndDate = 2012/10/5
-        DateTime discountPhaseEndDate = trialPhaseEndDate.plusMonths(6);
+        final DateTime discountPhaseEndDate = trialPhaseEndDate.plusMonths(6);
         events.add(createBillingEvent(subscriptionId, discountPhaseEndDate, plan1, phase3, BILL_CYCLE_DAY));
 
-        Invoice invoice1 = generator.generateInvoice(accountId, events, null, creationDate, Currency.USD);
+        final Invoice invoice1 = generator.generateInvoice(accountId, events, null, creationDate, Currency.USD);
         assertNotNull(invoice1);
         assertEquals(invoice1.getNumberOfItems(), 1);
         assertEquals(invoice1.getBalance().compareTo(ZERO), 0);
 
-        List<Invoice> invoiceList = new ArrayList<Invoice>();
+        final List<Invoice> invoiceList = new ArrayList<Invoice>();
         invoiceList.add(invoice1);
 
-        Invoice invoice2 = generator.generateInvoice(accountId, events, invoiceList, trialPhaseEndDate, Currency.USD);
+        final Invoice invoice2 = generator.generateInvoice(accountId, events, invoiceList, trialPhaseEndDate, Currency.USD);
         assertNotNull(invoice2);
         assertEquals(invoice2.getNumberOfItems(), 1);
         assertEquals(invoice2.getInvoiceItems().get(0).getStartDate().compareTo(trialPhaseEndDate), 0);
@@ -644,7 +643,7 @@ public class DefaultInvoiceGeneratorTests extends InvoicingTestBase {
 
         invoiceList.add(invoice2);
         DateTime targetDate = trialPhaseEndDate.toMutableDateTime().dayOfMonth().set(BILL_CYCLE_DAY).toDateTime();
-        Invoice invoice3 = generator.generateInvoice(accountId, events, invoiceList, targetDate, Currency.USD);
+        final Invoice invoice3 = generator.generateInvoice(accountId, events, invoiceList, targetDate, Currency.USD);
         assertNotNull(invoice3);
         assertEquals(invoice3.getNumberOfItems(), 1);
         assertEquals(invoice3.getInvoiceItems().get(0).getStartDate().compareTo(targetDate), 0);
@@ -652,17 +651,17 @@ public class DefaultInvoiceGeneratorTests extends InvoicingTestBase {
 
         invoiceList.add(invoice3);
         targetDate = targetDate.plusMonths(6);
-        Invoice invoice4 = generator.generateInvoice(accountId, events, invoiceList, targetDate, Currency.USD);
+        final Invoice invoice4 = generator.generateInvoice(accountId, events, invoiceList, targetDate, Currency.USD);
         assertNotNull(invoice4);
         assertEquals(invoice4.getNumberOfItems(), 7);
     }
 
     @Test(expectedExceptions = {InvoiceApiException.class})
     public void testTargetDateRestrictionFailure() throws InvoiceApiException, CatalogApiException {
-        DateTime targetDate = DateTime.now().plusMonths(60);
-        BillingEventSet events = new MockBillingEventSet();
-        Plan plan1 = new MockPlan();
-        PlanPhase phase1 = createMockMonthlyPlanPhase(null, ZERO, PhaseType.TRIAL);
+        final DateTime targetDate = DateTime.now().plusMonths(60);
+        final BillingEventSet events = new MockBillingEventSet();
+        final Plan plan1 = new MockPlan();
+        final PlanPhase phase1 = createMockMonthlyPlanPhase(null, ZERO, PhaseType.TRIAL);
         events.add(createBillingEvent(UUID.randomUUID(), DateTime.now(), plan1, phase1, 1));
         generator.generateInvoice(UUID.randomUUID(), events, null, targetDate, Currency.USD);
     }
@@ -681,11 +680,11 @@ public class DefaultInvoiceGeneratorTests extends InvoicingTestBase {
                                  null, BillingPeriod.MONTHLY, phaseType);
     }
 
-    private MockPlanPhase createMockMonthlyPlanPhase(@Nullable BigDecimal recurringRate,
+    private MockPlanPhase createMockMonthlyPlanPhase(@Nullable final BigDecimal recurringRate,
                                                      @Nullable final BigDecimal fixedCost,
                                                      final PhaseType phaseType) {
-        MockInternationalPrice recurringPrice = (recurringRate == null) ? null : new MockInternationalPrice(new DefaultPrice(recurringRate, Currency.USD));
-        MockInternationalPrice fixedPrice = (fixedCost == null) ? null : new MockInternationalPrice(new DefaultPrice(fixedCost, Currency.USD));
+        final MockInternationalPrice recurringPrice = (recurringRate == null) ? null : new MockInternationalPrice(new DefaultPrice(recurringRate, Currency.USD));
+        final MockInternationalPrice fixedPrice = (fixedCost == null) ? null : new MockInternationalPrice(new DefaultPrice(fixedCost, Currency.USD));
 
         return new MockPlanPhase(recurringPrice, fixedPrice, BillingPeriod.MONTHLY, phaseType);
     }
@@ -696,22 +695,22 @@ public class DefaultInvoiceGeneratorTests extends InvoicingTestBase {
     }
 
     private BillingEvent createBillingEvent(final UUID subscriptionId, final DateTime startDate,
-                                                   final Plan plan, final PlanPhase planPhase, final int billCycleDay) throws CatalogApiException {
-        Subscription sub = createZombieSubscription(subscriptionId);
-        Currency currency = Currency.USD;
+                                            final Plan plan, final PlanPhase planPhase, final int billCycleDay) throws CatalogApiException {
+        final Subscription sub = createZombieSubscription(subscriptionId);
+        final Currency currency = Currency.USD;
 
         return createMockBillingEvent(null, sub, startDate, plan, planPhase,
-                planPhase.getFixedPrice() == null ? null : planPhase.getFixedPrice().getPrice(currency),
-                planPhase.getRecurringPrice() == null ? null : planPhase.getRecurringPrice().getPrice(currency),
-                currency, planPhase.getBillingPeriod(),
-                billCycleDay, BillingModeType.IN_ADVANCE, "Test", 1L, SubscriptionTransitionType.CREATE);
+                                      planPhase.getFixedPrice() == null ? null : planPhase.getFixedPrice().getPrice(currency),
+                                      planPhase.getRecurringPrice() == null ? null : planPhase.getRecurringPrice().getPrice(currency),
+                                      currency, planPhase.getBillingPeriod(),
+                                      billCycleDay, BillingModeType.IN_ADVANCE, "Test", 1L, SubscriptionTransitionType.CREATE);
     }
 
     private void testInvoiceGeneration(final UUID accountId, final BillingEventSet events, final List<Invoice> existingInvoices,
                                        final DateTime targetDate, final int expectedNumberOfItems,
                                        final BigDecimal expectedAmount) throws InvoiceApiException {
-        Currency currency = Currency.USD;
-        Invoice invoice = generator.generateInvoice(accountId, events, existingInvoices, targetDate, currency);
+        final Currency currency = Currency.USD;
+        final Invoice invoice = generator.generateInvoice(accountId, events, existingInvoices, targetDate, currency);
         assertNotNull(invoice);
         assertEquals(invoice.getNumberOfItems(), expectedNumberOfItems);
         existingInvoices.add(invoice);
@@ -722,44 +721,44 @@ public class DefaultInvoiceGeneratorTests extends InvoicingTestBase {
 
     @Test
     public void testAddOnInvoiceGeneration() throws CatalogApiException, InvoiceApiException {
-        DateTime april25 = new DateTime(2012, 4, 25, 0, 0, 0, 0);
+        final DateTime april25 = new DateTime(2012, 4, 25, 0, 0, 0, 0);
 
         // create a base plan on April 25th
-        UUID accountId = UUID.randomUUID();
-        Subscription baseSubscription = createZombieSubscription();
+        final UUID accountId = UUID.randomUUID();
+        final Subscription baseSubscription = createZombieSubscription();
 
-        Plan basePlan = new MockPlan("base Plan");
-        MockInternationalPrice price5 = new MockInternationalPrice(new DefaultPrice(FIVE, Currency.USD));
-        MockInternationalPrice price10 = new MockInternationalPrice(new DefaultPrice(TEN, Currency.USD));
-        MockInternationalPrice price20 = new MockInternationalPrice(new DefaultPrice(TWENTY, Currency.USD));
-        PlanPhase basePlanEvergreen = new MockPlanPhase(price10, null, BillingPeriod.MONTHLY, PhaseType.EVERGREEN);
+        final Plan basePlan = new MockPlan("base Plan");
+        final MockInternationalPrice price5 = new MockInternationalPrice(new DefaultPrice(FIVE, Currency.USD));
+        final MockInternationalPrice price10 = new MockInternationalPrice(new DefaultPrice(TEN, Currency.USD));
+        final MockInternationalPrice price20 = new MockInternationalPrice(new DefaultPrice(TWENTY, Currency.USD));
+        final PlanPhase basePlanEvergreen = new MockPlanPhase(price10, null, BillingPeriod.MONTHLY, PhaseType.EVERGREEN);
 
-        BillingEventSet events = new MockBillingEventSet();
+        final BillingEventSet events = new MockBillingEventSet();
         events.add(createBillingEvent(baseSubscription.getId(), april25, basePlan, basePlanEvergreen, 25));
 
         // generate invoice
-        Invoice invoice1 = generator.generateInvoice(accountId, events, null, april25, Currency.USD);
+        final Invoice invoice1 = generator.generateInvoice(accountId, events, null, april25, Currency.USD);
         assertNotNull(invoice1);
         assertEquals(invoice1.getNumberOfItems(), 1);
         assertEquals(invoice1.getBalance().compareTo(TEN), 0);
 
-        List<Invoice> invoices = new ArrayList<Invoice>();
+        final List<Invoice> invoices = new ArrayList<Invoice>();
         invoices.add(invoice1);
 
         // create 2 add ons on April 28th
-        DateTime april28 = new DateTime(2012, 4, 28, 0, 0, 0, 0);
-        Subscription addOnSubscription1 = createZombieSubscription();
-        Plan addOn1Plan = new MockPlan("add on 1");
-        PlanPhase addOn1PlanPhaseEvergreen = new MockPlanPhase(price5, null, BillingPeriod.MONTHLY, PhaseType.EVERGREEN);
+        final DateTime april28 = new DateTime(2012, 4, 28, 0, 0, 0, 0);
+        final Subscription addOnSubscription1 = createZombieSubscription();
+        final Plan addOn1Plan = new MockPlan("add on 1");
+        final PlanPhase addOn1PlanPhaseEvergreen = new MockPlanPhase(price5, null, BillingPeriod.MONTHLY, PhaseType.EVERGREEN);
         events.add(createBillingEvent(addOnSubscription1.getId(), april28, addOn1Plan, addOn1PlanPhaseEvergreen, 25));
 
-        Subscription addOnSubscription2 = createZombieSubscription();
-        Plan addOn2Plan = new MockPlan("add on 2");
-        PlanPhase addOn2PlanPhaseEvergreen = new MockPlanPhase(price20, null, BillingPeriod.MONTHLY, PhaseType.EVERGREEN);
+        final Subscription addOnSubscription2 = createZombieSubscription();
+        final Plan addOn2Plan = new MockPlan("add on 2");
+        final PlanPhase addOn2PlanPhaseEvergreen = new MockPlanPhase(price20, null, BillingPeriod.MONTHLY, PhaseType.EVERGREEN);
         events.add(createBillingEvent(addOnSubscription2.getId(), april28, addOn2Plan, addOn2PlanPhaseEvergreen, 25));
 
         // generate invoice
-        Invoice invoice2 = generator.generateInvoice(accountId, events, invoices, april28, Currency.USD);
+        final Invoice invoice2 = generator.generateInvoice(accountId, events, invoices, april28, Currency.USD);
         invoices.add(invoice2);
         assertNotNull(invoice2);
         assertEquals(invoice2.getNumberOfItems(), 2);
@@ -767,16 +766,16 @@ public class DefaultInvoiceGeneratorTests extends InvoicingTestBase {
 
         // perform a repair (change base plan; remove one add-on)
         // event stream should include just two plans
-        MockBillingEventSet newEvents = new MockBillingEventSet();
-        Plan basePlan2 = new MockPlan("base plan 2");
-        MockInternationalPrice price13 = new MockInternationalPrice(new DefaultPrice(THIRTEEN, Currency.USD));
-        PlanPhase basePlan2Phase = new MockPlanPhase(price13, null, BillingPeriod.MONTHLY, PhaseType.EVERGREEN);
+        final MockBillingEventSet newEvents = new MockBillingEventSet();
+        final Plan basePlan2 = new MockPlan("base plan 2");
+        final MockInternationalPrice price13 = new MockInternationalPrice(new DefaultPrice(THIRTEEN, Currency.USD));
+        final PlanPhase basePlan2Phase = new MockPlanPhase(price13, null, BillingPeriod.MONTHLY, PhaseType.EVERGREEN);
         newEvents.add(createBillingEvent(baseSubscription.getId(), april25, basePlan2, basePlan2Phase, 25));
         newEvents.add(createBillingEvent(addOnSubscription1.getId(), april28, addOn1Plan, addOn1PlanPhaseEvergreen, 25));
 
         // generate invoice
-        DateTime may1 = new DateTime(2012, 5, 1, 0, 0, 0, 0);
-        Invoice invoice3 = generator.generateInvoice(accountId, newEvents, invoices, may1, Currency.USD);
+        final DateTime may1 = new DateTime(2012, 5, 1, 0, 0, 0, 0);
+        final Invoice invoice3 = generator.generateInvoice(accountId, newEvents, invoices, may1, Currency.USD);
         assertNotNull(invoice3);
         assertEquals(invoice3.getNumberOfItems(), 5);
         // -4.50 -18 - 10 (to correct the previous 2 invoices) + 4.50 + 13
@@ -786,22 +785,22 @@ public class DefaultInvoiceGeneratorTests extends InvoicingTestBase {
     @Test
     public void testRepairForPaidInvoice() throws CatalogApiException, InvoiceApiException {
         // create an invoice
-        DateTime april25 = new DateTime(2012, 4, 25, 0, 0, 0, 0);
+        final DateTime april25 = new DateTime(2012, 4, 25, 0, 0, 0, 0);
 
         // create a base plan on April 25th
-        UUID accountId = UUID.randomUUID();
-        Subscription originalSubscription = createZombieSubscription();
+        final UUID accountId = UUID.randomUUID();
+        final Subscription originalSubscription = createZombieSubscription();
 
-        Plan originalPlan = new MockPlan("original plan");
-        MockInternationalPrice price10 = new MockInternationalPrice(new DefaultPrice(TEN, Currency.USD));
-        PlanPhase originalPlanEvergreen = new MockPlanPhase(price10, null, BillingPeriod.MONTHLY, PhaseType.EVERGREEN);
+        final Plan originalPlan = new MockPlan("original plan");
+        final MockInternationalPrice price10 = new MockInternationalPrice(new DefaultPrice(TEN, Currency.USD));
+        final PlanPhase originalPlanEvergreen = new MockPlanPhase(price10, null, BillingPeriod.MONTHLY, PhaseType.EVERGREEN);
 
-        BillingEventSet events = new MockBillingEventSet();
+        final BillingEventSet events = new MockBillingEventSet();
         events.add(createBillingEvent(originalSubscription.getId(), april25, originalPlan, originalPlanEvergreen, 25));
 
-        Invoice invoice1 = generator.generateInvoice(accountId, events, null, april25, Currency.USD);
+        final Invoice invoice1 = generator.generateInvoice(accountId, events, null, april25, Currency.USD);
         assertEquals(invoice1.getNumberOfItems(), 1);
-        List<Invoice> invoices = new ArrayList<Invoice>();
+        final List<Invoice> invoices = new ArrayList<Invoice>();
         invoices.add(invoice1);
 
         // pay the invoice
@@ -810,14 +809,14 @@ public class DefaultInvoiceGeneratorTests extends InvoicingTestBase {
 
         // change the plan (i.e. repair) on start date
         events.clear();
-        Subscription newSubscription = createZombieSubscription();
-        Plan newPlan = new MockPlan("new plan");
-        MockInternationalPrice price5 = new MockInternationalPrice(new DefaultPrice(FIVE, Currency.USD));
-        PlanPhase newPlanEvergreen = new MockPlanPhase(price5, null, BillingPeriod.MONTHLY, PhaseType.EVERGREEN);
+        final Subscription newSubscription = createZombieSubscription();
+        final Plan newPlan = new MockPlan("new plan");
+        final MockInternationalPrice price5 = new MockInternationalPrice(new DefaultPrice(FIVE, Currency.USD));
+        final PlanPhase newPlanEvergreen = new MockPlanPhase(price5, null, BillingPeriod.MONTHLY, PhaseType.EVERGREEN);
         events.add(createBillingEvent(newSubscription.getId(), april25, newPlan, newPlanEvergreen, 25));
 
         // generate a new invoice
-        Invoice invoice2 = generator.generateInvoice(accountId, events, invoices, april25, Currency.USD);
+        final Invoice invoice2 = generator.generateInvoice(accountId, events, invoices, april25, Currency.USD);
         assertEquals(invoice2.getNumberOfItems(), 4);
         invoices.add(invoice2);
 
@@ -831,26 +830,26 @@ public class DefaultInvoiceGeneratorTests extends InvoicingTestBase {
         assertEquals(invoice2.getBalance().compareTo(ZERO), 0);
 
         // ensure that the account has a credit balance
-        BigDecimal creditBalance = invoice1.getAmountCredited().add(invoice2.getAmountCredited());
+        final BigDecimal creditBalance = invoice1.getAmountCredited().add(invoice2.getAmountCredited());
         assertTrue(creditBalance.compareTo(FIVE) == 0);
     }
 
-    private void distributeItems(List<Invoice> invoices) {
-        Map<UUID, Invoice> invoiceMap = new HashMap<UUID, Invoice>();
+    private void distributeItems(final List<Invoice> invoices) {
+        final Map<UUID, Invoice> invoiceMap = new HashMap<UUID, Invoice>();
 
-        for (Invoice invoice : invoices) {
+        for (final Invoice invoice : invoices) {
             invoiceMap.put(invoice.getId(), invoice);
         }
 
-        for (final Invoice invoice: invoices) {
-            Iterator<InvoiceItem> itemIterator = invoice.getInvoiceItems().iterator();
+        for (final Invoice invoice : invoices) {
+            final Iterator<InvoiceItem> itemIterator = invoice.getInvoiceItems().iterator();
             final UUID invoiceId = invoice.getId();
 
             while (itemIterator.hasNext()) {
-                InvoiceItem item = itemIterator.next();
+                final InvoiceItem item = itemIterator.next();
 
                 if (!item.getInvoiceId().equals(invoiceId)) {
-                    Invoice thisInvoice = invoiceMap.get(item.getInvoiceId());
+                    final Invoice thisInvoice = invoiceMap.get(item.getInvoiceId());
                     if (thisInvoice == null) {
                         throw new NullPointerException();
                     }
@@ -863,49 +862,49 @@ public class DefaultInvoiceGeneratorTests extends InvoicingTestBase {
 
     @Test
     public void testAutoInvoiceOffAccount() throws Exception {
-        MockBillingEventSet events = new MockBillingEventSet();
+        final MockBillingEventSet events = new MockBillingEventSet();
         events.setAccountInvoiceOff(true);
 
-        Subscription sub = createZombieSubscription();
-        DateTime startDate = buildDateTime(2011, 9, 1);
+        final Subscription sub = createZombieSubscription();
+        final DateTime startDate = buildDateTime(2011, 9, 1);
 
-        Plan plan = new MockPlan();
-        BigDecimal rate1 = TEN;
-        PlanPhase phase = createMockMonthlyPlanPhase(rate1);
+        final Plan plan = new MockPlan();
+        final BigDecimal rate1 = TEN;
+        final PlanPhase phase = createMockMonthlyPlanPhase(rate1);
 
-        BillingEvent event = createBillingEvent(sub.getId(), startDate, plan, phase, 1);
+        final BillingEvent event = createBillingEvent(sub.getId(), startDate, plan, phase, 1);
         events.add(event);
 
-        DateTime targetDate = buildDateTime(2011, 10, 3);
-        UUID accountId = UUID.randomUUID();
-        Invoice invoice = generator.generateInvoice(accountId, events, null, targetDate, Currency.USD);
+        final DateTime targetDate = buildDateTime(2011, 10, 3);
+        final UUID accountId = UUID.randomUUID();
+        final Invoice invoice = generator.generateInvoice(accountId, events, null, targetDate, Currency.USD);
 
         assertNull(invoice);
     }
-    
+
     public void testAutoInvoiceOffWithCredits() throws CatalogApiException, InvoiceApiException {
-        Currency currency = Currency.USD;
-        List<Invoice> invoices = new ArrayList<Invoice>();
-        MockBillingEventSet eventSet = new MockBillingEventSet();
-        UUID accountId = UUID.randomUUID();
+        final Currency currency = Currency.USD;
+        final List<Invoice> invoices = new ArrayList<Invoice>();
+        final MockBillingEventSet eventSet = new MockBillingEventSet();
+        final UUID accountId = UUID.randomUUID();
 
-        DateTime startDate = new DateTime(2012, 1, 1, 0, 12, 34, 0);
+        final DateTime startDate = new DateTime(2012, 1, 1, 0, 12, 34, 0);
 
         // add first subscription creation event
-        UUID subscriptionId1 = UUID.randomUUID();
-        Plan plan1 = new MockPlan();
-        PlanPhase plan1phase1 = createMockMonthlyPlanPhase(FIFTEEN, null, PhaseType.DISCOUNT);
-        BillingEvent subscription1creation = createBillingEvent(subscriptionId1, startDate, plan1, plan1phase1, 1);
+        final UUID subscriptionId1 = UUID.randomUUID();
+        final Plan plan1 = new MockPlan();
+        final PlanPhase plan1phase1 = createMockMonthlyPlanPhase(FIFTEEN, null, PhaseType.DISCOUNT);
+        final BillingEvent subscription1creation = createBillingEvent(subscriptionId1, startDate, plan1, plan1phase1, 1);
         eventSet.add(subscription1creation);
 
         // add second subscription creation event
-        UUID subscriptionId2 = UUID.randomUUID();
-        Plan plan2 = new MockPlan();
-        PlanPhase plan2phase1 = createMockMonthlyPlanPhase(TWELVE, null, PhaseType.EVERGREEN);
+        final UUID subscriptionId2 = UUID.randomUUID();
+        final Plan plan2 = new MockPlan();
+        final PlanPhase plan2phase1 = createMockMonthlyPlanPhase(TWELVE, null, PhaseType.EVERGREEN);
         eventSet.add(createBillingEvent(subscriptionId2, startDate, plan2, plan2phase1, 1));
 
         // generate the first invoice
-        Invoice invoice1 = generator.generateInvoice(accountId, eventSet, invoices, startDate, currency);
+        final Invoice invoice1 = generator.generateInvoice(accountId, eventSet, invoices, startDate, currency);
         assertNotNull(invoice1);
         assertTrue(invoice1.getBalance().compareTo(FIFTEEN.add(TWELVE)) == 0);
         invoices.add(invoice1);
@@ -915,51 +914,51 @@ public class DefaultInvoiceGeneratorTests extends InvoicingTestBase {
         eventSet.remove(subscription1creation);
         eventSet.addSubscriptionWithAutoInvoiceOff(subscriptionId1);
 
-        DateTime targetDate2 = startDate.plusMonths(1);
-        Invoice invoice2 = generator.generateInvoice(accountId, eventSet, invoices, targetDate2, currency);
+        final DateTime targetDate2 = startDate.plusMonths(1);
+        final Invoice invoice2 = generator.generateInvoice(accountId, eventSet, invoices, targetDate2, currency);
         assertNotNull(invoice2);
         assertTrue(invoice2.getBalance().compareTo(TWELVE) == 0);
         invoices.add(invoice2);
 
-        DateTime targetDate3 = targetDate2.plusMonths(1);
+        final DateTime targetDate3 = targetDate2.plusMonths(1);
         eventSet.clearSubscriptionsWithAutoInvoiceOff();
         eventSet.add(subscription1creation);
-        Invoice invoice3 = generator.generateInvoice(accountId, eventSet, invoices, targetDate3, currency);
+        final Invoice invoice3 = generator.generateInvoice(accountId, eventSet, invoices, targetDate3, currency);
         assertNotNull(invoice3);
         assertTrue(invoice3.getBalance().compareTo(FIFTEEN.multiply(TWO).add(TWELVE)) == 0);
     }
 
     @Test
     public void testAccountCredit() throws CatalogApiException, InvoiceApiException {
-        BillingEventSet billingEventSet = new MockBillingEventSet();
-
-        DateTime startDate = new DateTime(2012, 3, 1, 0, 0, 0, 0);
-        UUID accountId = UUID.randomUUID();
-        UUID subscriptionId = UUID.randomUUID();
-        Plan plan = new MockPlan("original plan");
-        MockInternationalPrice price10 = new MockInternationalPrice(new DefaultPrice(TEN, Currency.USD));
-        PlanPhase planPhase = new MockPlanPhase(price10, null, BillingPeriod.MONTHLY, PhaseType.EVERGREEN);
-        BillingEvent creation = createBillingEvent(subscriptionId, startDate, plan, planPhase, 1);
+        final BillingEventSet billingEventSet = new MockBillingEventSet();
+
+        final DateTime startDate = new DateTime(2012, 3, 1, 0, 0, 0, 0);
+        final UUID accountId = UUID.randomUUID();
+        final UUID subscriptionId = UUID.randomUUID();
+        final Plan plan = new MockPlan("original plan");
+        final MockInternationalPrice price10 = new MockInternationalPrice(new DefaultPrice(TEN, Currency.USD));
+        final PlanPhase planPhase = new MockPlanPhase(price10, null, BillingPeriod.MONTHLY, PhaseType.EVERGREEN);
+        final BillingEvent creation = createBillingEvent(subscriptionId, startDate, plan, planPhase, 1);
         billingEventSet.add(creation);
 
-        List<Invoice> invoices = new ArrayList<Invoice>();
+        final List<Invoice> invoices = new ArrayList<Invoice>();
 
-        Invoice initialInvoice = generator.generateInvoice(accountId, billingEventSet, null, startDate, Currency.USD);
+        final Invoice initialInvoice = generator.generateInvoice(accountId, billingEventSet, null, startDate, Currency.USD);
         assertNotNull(initialInvoice);
         assertEquals(initialInvoice.getNumberOfItems(), 1);
         assertEquals(initialInvoice.getBalance().compareTo(TEN), 0);
         invoices.add(initialInvoice);
 
         // add account-level credit
-        DateTime creditDate = startDate.plusDays(5);
-        Invoice invoiceWithCredit = new DefaultInvoice(accountId, creditDate, creditDate, Currency.USD);
-        InvoiceItem accountCredit = new CreditInvoiceItem(invoiceWithCredit.getId(), accountId, creditDate, FIVE, Currency.USD);
+        final DateTime creditDate = startDate.plusDays(5);
+        final Invoice invoiceWithCredit = new DefaultInvoice(accountId, creditDate, creditDate, Currency.USD);
+        final InvoiceItem accountCredit = new CreditInvoiceItem(invoiceWithCredit.getId(), accountId, creditDate, FIVE, Currency.USD);
         invoiceWithCredit.addInvoiceItem(accountCredit);
         invoices.add(invoiceWithCredit);
 
         // invoice one month after the initial subscription
-        Invoice finalInvoice = generator.generateInvoice(accountId, billingEventSet, invoices, startDate.plusMonths(1), Currency.USD);
+        final Invoice finalInvoice = generator.generateInvoice(accountId, billingEventSet, invoices, startDate.plusMonths(1), Currency.USD);
         assertEquals(finalInvoice.getBalance().compareTo(FIVE), 0);
         assertEquals(finalInvoice.getNumberOfItems(), 2);
     }
-}
\ No newline at end of file
+}
diff --git a/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/annual/DoubleProRationTests.java b/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/annual/DoubleProRationTests.java
index c08c8b8..524e666 100644
--- a/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/annual/DoubleProRationTests.java
+++ b/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/annual/DoubleProRationTests.java
@@ -34,39 +34,39 @@ public class DoubleProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testDoubleProRation_TargetDateOnStartDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 1, 1);
-        DateTime targetDate = buildDateTime(2011, 1, 1);
-        DateTime endDate = buildDateTime(2012, 1, 27);
+        final DateTime startDate = buildDateTime(2011, 1, 1);
+        final DateTime targetDate = buildDateTime(2011, 1, 1);
+        final DateTime endDate = buildDateTime(2012, 1, 27);
 
-        BigDecimal expectedValue = FOURTEEN.divide(THREE_HUNDRED_AND_SIXTY_FIVE, NUMBER_OF_DECIMALS, ROUNDING_METHOD);
+        final BigDecimal expectedValue = FOURTEEN.divide(THREE_HUNDRED_AND_SIXTY_FIVE, NUMBER_OF_DECIMALS, ROUNDING_METHOD);
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 15, expectedValue);
     }
 
     @Test
     public void testDoubleProRation_TargetDateInFirstProRationPeriod() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 1, 1);
-        DateTime targetDate = buildDateTime(2011, 1, 7);
-        DateTime endDate = buildDateTime(2012, 1, 27);
+        final DateTime startDate = buildDateTime(2011, 1, 1);
+        final DateTime targetDate = buildDateTime(2011, 1, 7);
+        final DateTime endDate = buildDateTime(2012, 1, 27);
 
-        BigDecimal expectedValue = FOURTEEN.divide(THREE_HUNDRED_AND_SIXTY_FIVE, NUMBER_OF_DECIMALS, ROUNDING_METHOD);
+        final BigDecimal expectedValue = FOURTEEN.divide(THREE_HUNDRED_AND_SIXTY_FIVE, NUMBER_OF_DECIMALS, ROUNDING_METHOD);
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 15, expectedValue);
     }
 
     @Test
     public void testDoubleProRation_TargetDateOnFirstBillingCycleDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 1, 1);
-        DateTime targetDate = buildDateTime(2011, 1, 15);
-        DateTime endDate = buildDateTime(2012, 1, 27);
+        final DateTime startDate = buildDateTime(2011, 1, 1);
+        final DateTime targetDate = buildDateTime(2011, 1, 15);
+        final DateTime endDate = buildDateTime(2012, 1, 27);
 
-        BigDecimal expectedValue = ONE.add(FOURTEEN.divide(THREE_HUNDRED_AND_SIXTY_FIVE, NUMBER_OF_DECIMALS, ROUNDING_METHOD));
+        final BigDecimal expectedValue = ONE.add(FOURTEEN.divide(THREE_HUNDRED_AND_SIXTY_FIVE, NUMBER_OF_DECIMALS, ROUNDING_METHOD));
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 15, expectedValue);
     }
 
     @Test
     public void testDoubleProRation_TargetDateInFullBillingPeriod() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 1, 1);
-        DateTime targetDate = buildDateTime(2011, 1, 22);
-        DateTime endDate = buildDateTime(2012, 1, 27);
+        final DateTime startDate = buildDateTime(2011, 1, 1);
+        final DateTime targetDate = buildDateTime(2011, 1, 22);
+        final DateTime endDate = buildDateTime(2012, 1, 27);
 
         BigDecimal expectedValue;
         expectedValue = FOURTEEN.divide(THREE_HUNDRED_AND_SIXTY_FIVE, NUMBER_OF_DECIMALS, ROUNDING_METHOD);
@@ -77,9 +77,9 @@ public class DoubleProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testDoubleProRation_TargetDateOnSecondBillingCycleDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 1, 1);
-        DateTime targetDate = buildDateTime(2012, 1, 15);
-        DateTime endDate = buildDateTime(2012, 1, 27);
+        final DateTime startDate = buildDateTime(2011, 1, 1);
+        final DateTime targetDate = buildDateTime(2012, 1, 15);
+        final DateTime endDate = buildDateTime(2012, 1, 27);
 
         BigDecimal expectedValue;
         expectedValue = FOURTEEN.divide(THREE_HUNDRED_AND_SIXTY_FIVE, 2 * NUMBER_OF_DECIMALS, ROUNDING_METHOD);
@@ -92,9 +92,9 @@ public class DoubleProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testDoubleProRation_TargetDateInSecondProRationPeriod() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 1, 1);
-        DateTime targetDate = buildDateTime(2012, 1, 17);
-        DateTime endDate = buildDateTime(2012, 1, 27);
+        final DateTime startDate = buildDateTime(2011, 1, 1);
+        final DateTime targetDate = buildDateTime(2012, 1, 17);
+        final DateTime endDate = buildDateTime(2012, 1, 27);
 
         BigDecimal expectedValue;
         expectedValue = FOURTEEN.divide(THREE_HUNDRED_AND_SIXTY_FIVE, 2 * NUMBER_OF_DECIMALS, ROUNDING_METHOD);
@@ -107,9 +107,9 @@ public class DoubleProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testDoubleProRation_TargetDateOnEndDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 1, 1);
-        DateTime targetDate = buildDateTime(2012, 1, 27);
-        DateTime endDate = buildDateTime(2012, 1, 27);
+        final DateTime startDate = buildDateTime(2011, 1, 1);
+        final DateTime targetDate = buildDateTime(2012, 1, 27);
+        final DateTime endDate = buildDateTime(2012, 1, 27);
 
         BigDecimal expectedValue;
         expectedValue = FOURTEEN.divide(THREE_HUNDRED_AND_SIXTY_FIVE, 2 * NUMBER_OF_DECIMALS, ROUNDING_METHOD);
@@ -122,9 +122,9 @@ public class DoubleProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testDoubleProRation_TargetDateAfterEndDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 1, 1);
-        DateTime targetDate = buildDateTime(2012, 3, 7);
-        DateTime endDate = buildDateTime(2012, 1, 27);
+        final DateTime startDate = buildDateTime(2011, 1, 1);
+        final DateTime targetDate = buildDateTime(2012, 3, 7);
+        final DateTime endDate = buildDateTime(2012, 1, 27);
 
         BigDecimal expectedValue;
         expectedValue = FOURTEEN.divide(THREE_HUNDRED_AND_SIXTY_FIVE, 2 * NUMBER_OF_DECIMALS, ROUNDING_METHOD);
@@ -137,9 +137,9 @@ public class DoubleProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testDoubleProRationWithMultiplePeriods_TargetDateInSecondFullBillingPeriod() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 1, 1);
-        DateTime targetDate = buildDateTime(2012, 2, 26);
-        DateTime endDate = buildDateTime(2013, 4, 27);
+        final DateTime startDate = buildDateTime(2011, 1, 1);
+        final DateTime targetDate = buildDateTime(2012, 2, 26);
+        final DateTime endDate = buildDateTime(2013, 4, 27);
 
         BigDecimal expectedValue;
         expectedValue = FOURTEEN.divide(THREE_HUNDRED_AND_SIXTY_FIVE, NUMBER_OF_DECIMALS, ROUNDING_METHOD);
diff --git a/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/annual/LeadingProRationTests.java b/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/annual/LeadingProRationTests.java
index 68611f7..facea50 100644
--- a/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/annual/LeadingProRationTests.java
+++ b/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/annual/LeadingProRationTests.java
@@ -34,10 +34,10 @@ public class LeadingProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testLeadingProRation_Evergreen_TargetDateOnStartDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 1);
-        DateTime targetDate = buildDateTime(2011, 2, 1);
+        final DateTime startDate = buildDateTime(2011, 2, 1);
+        final DateTime targetDate = buildDateTime(2011, 2, 1);
 
-        BigDecimal expectedValue;
+        final BigDecimal expectedValue;
         expectedValue = TWELVE.divide(THREE_HUNDRED_AND_SIXTY_FIVE, NUMBER_OF_DECIMALS, ROUNDING_METHOD);
 
         testCalculateNumberOfBillingCycles(startDate, targetDate, 13, expectedValue);
@@ -45,10 +45,10 @@ public class LeadingProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testLeadingProRation_Evergreen_TargetDateInProRationPeriod() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 1);
-        DateTime targetDate = buildDateTime(2011, 2, 4);
+        final DateTime startDate = buildDateTime(2011, 2, 1);
+        final DateTime targetDate = buildDateTime(2011, 2, 4);
 
-        BigDecimal expectedValue;
+        final BigDecimal expectedValue;
         expectedValue = TWELVE.divide(THREE_HUNDRED_AND_SIXTY_FIVE, NUMBER_OF_DECIMALS, ROUNDING_METHOD);
 
         testCalculateNumberOfBillingCycles(startDate, targetDate, 13, expectedValue);
@@ -56,10 +56,10 @@ public class LeadingProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testLeadingProRation_Evergreen_TargetDateOnFirstBillingDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 1);
-        DateTime targetDate = buildDateTime(2011, 2, 13);
+        final DateTime startDate = buildDateTime(2011, 2, 1);
+        final DateTime targetDate = buildDateTime(2011, 2, 13);
 
-        BigDecimal expectedValue;
+        final BigDecimal expectedValue;
         expectedValue = TWELVE.divide(THREE_HUNDRED_AND_SIXTY_FIVE, NUMBER_OF_DECIMALS, ROUNDING_METHOD).add(ONE);
 
         testCalculateNumberOfBillingCycles(startDate, targetDate, 13, expectedValue);
@@ -67,10 +67,10 @@ public class LeadingProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testLeadingProRation_Evergreen_TargetDateAfterFirstBillingPeriod() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 1);
-        DateTime targetDate = buildDateTime(2011, 4, 13);
+        final DateTime startDate = buildDateTime(2011, 2, 1);
+        final DateTime targetDate = buildDateTime(2011, 4, 13);
 
-        BigDecimal expectedValue;
+        final BigDecimal expectedValue;
         expectedValue = TWELVE.divide(THREE_HUNDRED_AND_SIXTY_FIVE, NUMBER_OF_DECIMALS, ROUNDING_METHOD).add(ONE);
 
         testCalculateNumberOfBillingCycles(startDate, targetDate, 13, expectedValue);
@@ -78,11 +78,11 @@ public class LeadingProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testLeadingProRation_WithEndDate_TargetDateOnStartDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 1);
-        DateTime targetDate = buildDateTime(2011, 2, 1);
-        DateTime endDate = buildDateTime(2012, 2, 13);
+        final DateTime startDate = buildDateTime(2011, 2, 1);
+        final DateTime targetDate = buildDateTime(2011, 2, 1);
+        final DateTime endDate = buildDateTime(2012, 2, 13);
 
-        BigDecimal expectedValue;
+        final BigDecimal expectedValue;
         expectedValue = TWELVE.divide(THREE_HUNDRED_AND_SIXTY_FIVE, NUMBER_OF_DECIMALS, ROUNDING_METHOD);
 
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 13, expectedValue);
@@ -90,11 +90,11 @@ public class LeadingProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testLeadingProRation_WithEndDate_TargetDateInProRationPeriod() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 1);
-        DateTime targetDate = buildDateTime(2011, 2, 4);
-        DateTime endDate = buildDateTime(2012, 2, 13);
+        final DateTime startDate = buildDateTime(2011, 2, 1);
+        final DateTime targetDate = buildDateTime(2011, 2, 4);
+        final DateTime endDate = buildDateTime(2012, 2, 13);
 
-        BigDecimal expectedValue;
+        final BigDecimal expectedValue;
         expectedValue = TWELVE.divide(THREE_HUNDRED_AND_SIXTY_FIVE, NUMBER_OF_DECIMALS, ROUNDING_METHOD);
 
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 13, expectedValue);
@@ -102,11 +102,11 @@ public class LeadingProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testLeadingProRation_WithEndDate_TargetDateOnFirstBillingDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 1);
-        DateTime targetDate = buildDateTime(2011, 2, 13);
-        DateTime endDate = buildDateTime(2012, 2, 13);
+        final DateTime startDate = buildDateTime(2011, 2, 1);
+        final DateTime targetDate = buildDateTime(2011, 2, 13);
+        final DateTime endDate = buildDateTime(2012, 2, 13);
 
-        BigDecimal expectedValue;
+        final BigDecimal expectedValue;
         expectedValue = TWELVE.divide(THREE_HUNDRED_AND_SIXTY_FIVE, NUMBER_OF_DECIMALS, ROUNDING_METHOD).add(ONE);
 
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 13, expectedValue);
@@ -114,11 +114,11 @@ public class LeadingProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testLeadingProRation_WithEndDate_TargetDateInFinalBillingPeriod() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 1);
-        DateTime targetDate = buildDateTime(2011, 4, 10);
-        DateTime endDate = buildDateTime(2012, 2, 13);
+        final DateTime startDate = buildDateTime(2011, 2, 1);
+        final DateTime targetDate = buildDateTime(2011, 4, 10);
+        final DateTime endDate = buildDateTime(2012, 2, 13);
 
-        BigDecimal expectedValue;
+        final BigDecimal expectedValue;
         expectedValue = TWELVE.divide(THREE_HUNDRED_AND_SIXTY_FIVE, NUMBER_OF_DECIMALS, ROUNDING_METHOD).add(ONE);
 
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 13, expectedValue);
@@ -126,11 +126,11 @@ public class LeadingProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testLeadingProRation_WithEndDate_TargetDateOnEndDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 1);
-        DateTime targetDate = buildDateTime(2012, 2, 13);
-        DateTime endDate = buildDateTime(2012, 2, 13);
+        final DateTime startDate = buildDateTime(2011, 2, 1);
+        final DateTime targetDate = buildDateTime(2012, 2, 13);
+        final DateTime endDate = buildDateTime(2012, 2, 13);
 
-        BigDecimal expectedValue;
+        final BigDecimal expectedValue;
         expectedValue = TWELVE.divide(THREE_HUNDRED_AND_SIXTY_FIVE, NUMBER_OF_DECIMALS, ROUNDING_METHOD).add(ONE);
 
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 13, expectedValue);
@@ -138,11 +138,11 @@ public class LeadingProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testLeadingProRation_WithEndDate_TargetDateAfterEndDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 1);
-        DateTime targetDate = buildDateTime(2012, 4, 10);
-        DateTime endDate = buildDateTime(2012, 2, 13);
+        final DateTime startDate = buildDateTime(2011, 2, 1);
+        final DateTime targetDate = buildDateTime(2012, 4, 10);
+        final DateTime endDate = buildDateTime(2012, 2, 13);
 
-        BigDecimal expectedValue;
+        final BigDecimal expectedValue;
         expectedValue = TWELVE.divide(THREE_HUNDRED_AND_SIXTY_FIVE, NUMBER_OF_DECIMALS, ROUNDING_METHOD).add(ONE);
 
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 13, expectedValue);
diff --git a/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/annual/ProRationTests.java b/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/annual/ProRationTests.java
index 88922e2..4c9b88b 100644
--- a/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/annual/ProRationTests.java
+++ b/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/annual/ProRationTests.java
@@ -34,29 +34,29 @@ public class ProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testSinglePlan_PrecedingProRation() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 1, 31);
-        DateTime targetDate = buildDateTime(2011, 2, 24);
+        final DateTime startDate = buildDateTime(2011, 1, 31);
+        final DateTime targetDate = buildDateTime(2011, 2, 24);
 
-        BigDecimal expectedValue = ONE.add(FIFTEEN.divide(THREE_HUNDRED_AND_SIXTY_FIVE, NUMBER_OF_DECIMALS, ROUNDING_METHOD));
+        final BigDecimal expectedValue = ONE.add(FIFTEEN.divide(THREE_HUNDRED_AND_SIXTY_FIVE, NUMBER_OF_DECIMALS, ROUNDING_METHOD));
         testCalculateNumberOfBillingCycles(startDate, targetDate, 15, expectedValue);
     }
 
     @Test
     public void testSinglePlan_PrecedingProRation_CrossingYearBoundary() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2010, 12, 15);
-        DateTime targetDate = buildDateTime(2011, 1, 13);
+        final DateTime startDate = buildDateTime(2010, 12, 15);
+        final DateTime targetDate = buildDateTime(2011, 1, 13);
 
-        BigDecimal expectedValue = ONE.add(TWENTY.divide(THREE_HUNDRED_AND_SIXTY_FIVE, NUMBER_OF_DECIMALS, ROUNDING_METHOD));
+        final BigDecimal expectedValue = ONE.add(TWENTY.divide(THREE_HUNDRED_AND_SIXTY_FIVE, NUMBER_OF_DECIMALS, ROUNDING_METHOD));
         testCalculateNumberOfBillingCycles(startDate, targetDate, 4, expectedValue);
     }
 
     @Test(enabled = false)
     public void testSinglePlanDoubleProRation() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 1, 10);
-        DateTime endDate = buildDateTime(2012, 3, 4);
-        DateTime targetDate = buildDateTime(2012, 4, 5);
+        final DateTime startDate = buildDateTime(2011, 1, 10);
+        final DateTime endDate = buildDateTime(2012, 3, 4);
+        final DateTime targetDate = buildDateTime(2012, 4, 5);
 
-        BigDecimal expectedValue = BigDecimal.ZERO;
+        final BigDecimal expectedValue = BigDecimal.ZERO;
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 17, expectedValue);
     }
 }
diff --git a/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/annual/TrailingProRationTests.java b/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/annual/TrailingProRationTests.java
index d1c2013..8861890 100644
--- a/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/annual/TrailingProRationTests.java
+++ b/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/annual/TrailingProRationTests.java
@@ -34,58 +34,58 @@ public class TrailingProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testTargetDateOnStartDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2010, 6, 17);
-        DateTime endDate = buildDateTime(2012, 6, 25);
-        DateTime targetDate = buildDateTime(2010, 6, 17);
+        final DateTime startDate = buildDateTime(2010, 6, 17);
+        final DateTime endDate = buildDateTime(2012, 6, 25);
+        final DateTime targetDate = buildDateTime(2010, 6, 17);
 
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 17, ONE);
     }
 
     @Test
     public void testTargetDateInFirstBillingPeriod() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2010, 6, 17);
-        DateTime endDate = buildDateTime(2011, 6, 25);
-        DateTime targetDate = buildDateTime(2010, 6, 20);
+        final DateTime startDate = buildDateTime(2010, 6, 17);
+        final DateTime endDate = buildDateTime(2011, 6, 25);
+        final DateTime targetDate = buildDateTime(2010, 6, 20);
 
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 17, ONE);
     }
 
     @Test
     public void testTargetDateAtEndOfFirstBillingCycle() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2010, 6, 17);
-        DateTime endDate = buildDateTime(2011, 6, 25);
-        DateTime targetDate = buildDateTime(2011, 6, 17);
+        final DateTime startDate = buildDateTime(2010, 6, 17);
+        final DateTime endDate = buildDateTime(2011, 6, 25);
+        final DateTime targetDate = buildDateTime(2011, 6, 17);
 
-        BigDecimal expectedValue = ONE.add(EIGHT.divide(THREE_HUNDRED_AND_SIXTY_FIVE, NUMBER_OF_DECIMALS, ROUNDING_METHOD));
+        final BigDecimal expectedValue = ONE.add(EIGHT.divide(THREE_HUNDRED_AND_SIXTY_FIVE, NUMBER_OF_DECIMALS, ROUNDING_METHOD));
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 17, expectedValue);
     }
 
     @Test
     public void testTargetDateInProRationPeriod() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2010, 6, 17);
-        DateTime endDate = buildDateTime(2011, 6, 25);
-        DateTime targetDate = buildDateTime(2011, 6, 18);
+        final DateTime startDate = buildDateTime(2010, 6, 17);
+        final DateTime endDate = buildDateTime(2011, 6, 25);
+        final DateTime targetDate = buildDateTime(2011, 6, 18);
 
-        BigDecimal expectedValue = ONE.add(EIGHT.divide(THREE_HUNDRED_AND_SIXTY_SIX, NUMBER_OF_DECIMALS, ROUNDING_METHOD));
+        final BigDecimal expectedValue = ONE.add(EIGHT.divide(THREE_HUNDRED_AND_SIXTY_SIX, NUMBER_OF_DECIMALS, ROUNDING_METHOD));
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 17, expectedValue);
     }
 
     @Test
     public void testTargetDateOnEndDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2010, 6, 17);
-        DateTime endDate = buildDateTime(2011, 6, 25);
+        final DateTime startDate = buildDateTime(2010, 6, 17);
+        final DateTime endDate = buildDateTime(2011, 6, 25);
 
-        BigDecimal expectedValue = ONE.add(EIGHT.divide(THREE_HUNDRED_AND_SIXTY_SIX, NUMBER_OF_DECIMALS, ROUNDING_METHOD));
+        final BigDecimal expectedValue = ONE.add(EIGHT.divide(THREE_HUNDRED_AND_SIXTY_SIX, NUMBER_OF_DECIMALS, ROUNDING_METHOD));
         testCalculateNumberOfBillingCycles(startDate, endDate, endDate, 17, expectedValue);
     }
 
     @Test
     public void testTargetDateAfterEndDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2010, 6, 17);
-        DateTime endDate = buildDateTime(2011, 6, 25);
-        DateTime targetDate = buildDateTime(2011, 7, 30);
+        final DateTime startDate = buildDateTime(2010, 6, 17);
+        final DateTime endDate = buildDateTime(2011, 6, 25);
+        final DateTime targetDate = buildDateTime(2011, 7, 30);
 
-        BigDecimal expectedValue = ONE.add(EIGHT.divide(THREE_HUNDRED_AND_SIXTY_SIX, NUMBER_OF_DECIMALS, ROUNDING_METHOD));
+        final BigDecimal expectedValue = ONE.add(EIGHT.divide(THREE_HUNDRED_AND_SIXTY_SIX, NUMBER_OF_DECIMALS, ROUNDING_METHOD));
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 17, expectedValue);
     }
-}
\ No newline at end of file
+}
diff --git a/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/GenericProRationTestBase.java b/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/GenericProRationTestBase.java
index 70f1f8f..ea37848 100644
--- a/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/GenericProRationTestBase.java
+++ b/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/GenericProRationTestBase.java
@@ -27,53 +27,54 @@ import com.ning.billing.invoice.model.InvalidDateSequenceException;
 public abstract class GenericProRationTestBase extends ProRationInAdvanceTestBase {
     /**
      * used for testing cancellation in less than a single billing period
+     *
      * @return BigDecimal the number of days in the billing period beginning 2011/1/1
      */
     protected abstract BigDecimal getDaysInTestPeriod();
-    
+
     @Test
     public void testSinglePlan_OnStartDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 15);
+        final DateTime startDate = buildDateTime(2011, 2, 15);
 
         testCalculateNumberOfBillingCycles(startDate, startDate, 15, ONE);
     }
 
     @Test
     public void testSinglePlan_LessThanOnePeriod() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 15);
-        DateTime targetDate = buildDateTime(2011, 3, 1);
+        final DateTime startDate = buildDateTime(2011, 2, 15);
+        final DateTime targetDate = buildDateTime(2011, 3, 1);
 
         testCalculateNumberOfBillingCycles(startDate, targetDate, 15, ONE);
     }
 
     @Test
     public void testSinglePlan_OnePeriodLessADayAfterStart() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 15);
-        DateTime targetDate = startDate.plusMonths(getBillingPeriod().getNumberOfMonths()).plusDays(-1);
+        final DateTime startDate = buildDateTime(2011, 2, 15);
+        final DateTime targetDate = startDate.plusMonths(getBillingPeriod().getNumberOfMonths()).plusDays(-1);
 
         testCalculateNumberOfBillingCycles(startDate, targetDate, 15, ONE);
     }
 
     @Test
     public void testSinglePlan_ExactlyOnePeriodAfterStart() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 15);
-        DateTime targetDate = startDate.plusMonths(getBillingPeriod().getNumberOfMonths());
+        final DateTime startDate = buildDateTime(2011, 2, 15);
+        final DateTime targetDate = startDate.plusMonths(getBillingPeriod().getNumberOfMonths());
 
         testCalculateNumberOfBillingCycles(startDate, targetDate, 15, TWO);
     }
 
     @Test
     public void testSinglePlan_SlightlyMoreThanOnePeriodAfterStart() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 15);
-        DateTime targetDate = startDate.plusMonths(getBillingPeriod().getNumberOfMonths()).plusDays(1);
+        final DateTime startDate = buildDateTime(2011, 2, 15);
+        final DateTime targetDate = startDate.plusMonths(getBillingPeriod().getNumberOfMonths()).plusDays(1);
 
         testCalculateNumberOfBillingCycles(startDate, targetDate, 15, TWO);
     }
 
     @Test
     public void testSinglePlan_CrossingYearBoundary() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 12, 15);
-        DateTime oneCycleLater = startDate.plusMonths(getBillingPeriod().getNumberOfMonths());
+        final DateTime startDate = buildDateTime(2011, 12, 15);
+        final DateTime oneCycleLater = startDate.plusMonths(getBillingPeriod().getNumberOfMonths());
 
         // test just before the billing cycle day
         testCalculateNumberOfBillingCycles(startDate, oneCycleLater.plusDays(-1), 15, ONE);
@@ -87,27 +88,27 @@ public abstract class GenericProRationTestBase extends ProRationInAdvanceTestBas
 
     @Test
     public void testSinglePlan_StartingMidFebruary() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 15);
-        DateTime targetDate = startDate.plusMonths(getBillingPeriod().getNumberOfMonths());
+        final DateTime startDate = buildDateTime(2011, 2, 15);
+        final DateTime targetDate = startDate.plusMonths(getBillingPeriod().getNumberOfMonths());
 
         testCalculateNumberOfBillingCycles(startDate, targetDate, 15, TWO);
     }
 
     @Test
     public void testSinglePlan_StartingMidFebruaryOfLeapYear() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2012, 2, 15);
-        DateTime targetDate = startDate.plusMonths(getBillingPeriod().getNumberOfMonths());
+        final DateTime startDate = buildDateTime(2012, 2, 15);
+        final DateTime targetDate = startDate.plusMonths(getBillingPeriod().getNumberOfMonths());
 
         testCalculateNumberOfBillingCycles(startDate, targetDate, 15, TWO);
     }
 
     @Test
     public void testSinglePlan_MovingForwardThroughTime() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 1, 31);
+        final DateTime startDate = buildDateTime(2011, 1, 31);
         BigDecimal expectedValue = ONE;
 
         for (int i = 1; i <= 12; i++) {
-            DateTime oneCycleLater = startDate.plusMonths(i * getBillingPeriod().getNumberOfMonths());
+            final DateTime oneCycleLater = startDate.plusMonths(i * getBillingPeriod().getNumberOfMonths());
             // test just before the billing cycle day
             testCalculateNumberOfBillingCycles(startDate, oneCycleLater.plusDays(-1), 31, expectedValue);
 
@@ -120,65 +121,65 @@ public abstract class GenericProRationTestBase extends ProRationInAdvanceTestBas
             testCalculateNumberOfBillingCycles(startDate, oneCycleLater.plusDays(1), 31, expectedValue);
         }
     }
-    
+
     // tests for cancellation in less than one period, beginning Jan 1
     @Test
     public void testCancelledBeforeOnePeriod_TargetDateInStartDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 1, 1);
-        DateTime targetDate = buildDateTime(2011, 1, 1);
-        DateTime endDate = buildDateTime(2011, 1, 15);
+        final DateTime startDate = buildDateTime(2011, 1, 1);
+        final DateTime targetDate = buildDateTime(2011, 1, 1);
+        final DateTime endDate = buildDateTime(2011, 1, 15);
 
-        BigDecimal expectedValue = FOURTEEN.divide(getDaysInTestPeriod(), NUMBER_OF_DECIMALS, ROUNDING_METHOD);
+        final BigDecimal expectedValue = FOURTEEN.divide(getDaysInTestPeriod(), NUMBER_OF_DECIMALS, ROUNDING_METHOD);
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 1, expectedValue);
     }
 
     @Test
     public void testCancelledBeforeOnePeriod_TargetDateInSubscriptionPeriod() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 1, 1);
-        DateTime targetDate = buildDateTime(2011, 1, 7);
-        DateTime endDate = buildDateTime(2011, 1, 15);
+        final DateTime startDate = buildDateTime(2011, 1, 1);
+        final DateTime targetDate = buildDateTime(2011, 1, 7);
+        final DateTime endDate = buildDateTime(2011, 1, 15);
 
-        BigDecimal expectedValue = FOURTEEN.divide(getDaysInTestPeriod(), NUMBER_OF_DECIMALS, ROUNDING_METHOD);
+        final BigDecimal expectedValue = FOURTEEN.divide(getDaysInTestPeriod(), NUMBER_OF_DECIMALS, ROUNDING_METHOD);
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 1, expectedValue);
     }
 
     @Test
     public void testCancelledBeforeOnePeriod_TargetDateOnEndDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 1, 1);
-        DateTime targetDate = buildDateTime(2011, 1, 15);
-        DateTime endDate = buildDateTime(2011, 1, 15);
+        final DateTime startDate = buildDateTime(2011, 1, 1);
+        final DateTime targetDate = buildDateTime(2011, 1, 15);
+        final DateTime endDate = buildDateTime(2011, 1, 15);
 
-        BigDecimal expectedValue = FOURTEEN.divide(getDaysInTestPeriod(), NUMBER_OF_DECIMALS, ROUNDING_METHOD);
+        final BigDecimal expectedValue = FOURTEEN.divide(getDaysInTestPeriod(), NUMBER_OF_DECIMALS, ROUNDING_METHOD);
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 1, expectedValue);
     }
 
     @Test
     public void testCancelledBeforeOnePeriod_TargetDateAfterEndDateButInFirstBillingPeriod() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 1, 1);
-        DateTime targetDate = buildDateTime(2011, 1, 17);
-        DateTime endDate = buildDateTime(2011, 1, 15);
+        final DateTime startDate = buildDateTime(2011, 1, 1);
+        final DateTime targetDate = buildDateTime(2011, 1, 17);
+        final DateTime endDate = buildDateTime(2011, 1, 15);
 
-        BigDecimal expectedValue = FOURTEEN.divide(getDaysInTestPeriod(), NUMBER_OF_DECIMALS, ROUNDING_METHOD);
+        final BigDecimal expectedValue = FOURTEEN.divide(getDaysInTestPeriod(), NUMBER_OF_DECIMALS, ROUNDING_METHOD);
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 1, expectedValue);
     }
 
     @Test
     public void testCancelledBeforeOnePeriod_TargetDateAtEndOfFirstBillingPeriod() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 1, 1);
-        DateTime targetDate = buildDateTime(2011, 2, 1);
-        DateTime endDate = buildDateTime(2011, 1, 15);
+        final DateTime startDate = buildDateTime(2011, 1, 1);
+        final DateTime targetDate = buildDateTime(2011, 2, 1);
+        final DateTime endDate = buildDateTime(2011, 1, 15);
 
-        BigDecimal expectedValue = FOURTEEN.divide(getDaysInTestPeriod(), NUMBER_OF_DECIMALS, ROUNDING_METHOD);
+        final BigDecimal expectedValue = FOURTEEN.divide(getDaysInTestPeriod(), NUMBER_OF_DECIMALS, ROUNDING_METHOD);
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 1, expectedValue);
     }
 
     @Test
     public void testCancelledBeforeOnePeriod_TargetDateAfterFirstBillingPeriod() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 1, 1);
-        DateTime targetDate = buildDateTime(2011, 4, 5);
-        DateTime endDate = buildDateTime(2011, 1, 15);
+        final DateTime startDate = buildDateTime(2011, 1, 1);
+        final DateTime targetDate = buildDateTime(2011, 4, 5);
+        final DateTime endDate = buildDateTime(2011, 1, 15);
 
-        BigDecimal expectedValue = FOURTEEN.divide(getDaysInTestPeriod(), NUMBER_OF_DECIMALS, ROUNDING_METHOD);
+        final BigDecimal expectedValue = FOURTEEN.divide(getDaysInTestPeriod(), NUMBER_OF_DECIMALS, ROUNDING_METHOD);
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 1, expectedValue);
     }
 }
diff --git a/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/monthly/DoubleProRationTests.java b/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/monthly/DoubleProRationTests.java
index 8c9b61d..230d60c 100644
--- a/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/monthly/DoubleProRationTests.java
+++ b/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/monthly/DoubleProRationTests.java
@@ -34,39 +34,39 @@ public class DoubleProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testDoubleProRation_TargetDateOnStartDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 1, 1);
-        DateTime targetDate = buildDateTime(2011, 1, 1);
-        DateTime endDate = buildDateTime(2011, 2, 27);
+        final DateTime startDate = buildDateTime(2011, 1, 1);
+        final DateTime targetDate = buildDateTime(2011, 1, 1);
+        final DateTime endDate = buildDateTime(2011, 2, 27);
 
-        BigDecimal expectedValue = FOURTEEN.divide(THIRTY_ONE, NUMBER_OF_DECIMALS, ROUNDING_METHOD);
+        final BigDecimal expectedValue = FOURTEEN.divide(THIRTY_ONE, NUMBER_OF_DECIMALS, ROUNDING_METHOD);
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 15, expectedValue);
     }
 
     @Test
     public void testDoubleProRation_TargetDateInFirstProRationPeriod() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 1, 1);
-        DateTime targetDate = buildDateTime(2011, 1, 7);
-        DateTime endDate = buildDateTime(2011, 2, 27);
+        final DateTime startDate = buildDateTime(2011, 1, 1);
+        final DateTime targetDate = buildDateTime(2011, 1, 7);
+        final DateTime endDate = buildDateTime(2011, 2, 27);
 
-        BigDecimal expectedValue = FOURTEEN.divide(THIRTY_ONE, NUMBER_OF_DECIMALS, ROUNDING_METHOD);
+        final BigDecimal expectedValue = FOURTEEN.divide(THIRTY_ONE, NUMBER_OF_DECIMALS, ROUNDING_METHOD);
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 15, expectedValue);
     }
 
     @Test
     public void testDoubleProRation_TargetDateOnFirstBillingCycleDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 1, 1);
-        DateTime targetDate = buildDateTime(2011, 1, 15);
-        DateTime endDate = buildDateTime(2011, 2, 27);
+        final DateTime startDate = buildDateTime(2011, 1, 1);
+        final DateTime targetDate = buildDateTime(2011, 1, 15);
+        final DateTime endDate = buildDateTime(2011, 2, 27);
 
-        BigDecimal expectedValue = ONE.add(FOURTEEN.divide(THIRTY_ONE, NUMBER_OF_DECIMALS, ROUNDING_METHOD));
+        final BigDecimal expectedValue = ONE.add(FOURTEEN.divide(THIRTY_ONE, NUMBER_OF_DECIMALS, ROUNDING_METHOD));
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 15, expectedValue);
     }
 
     @Test
     public void testDoubleProRation_TargetDateInFullBillingPeriod() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 1, 1);
-        DateTime targetDate = buildDateTime(2011, 1, 22);
-        DateTime endDate = buildDateTime(2011, 2, 27);
+        final DateTime startDate = buildDateTime(2011, 1, 1);
+        final DateTime targetDate = buildDateTime(2011, 1, 22);
+        final DateTime endDate = buildDateTime(2011, 2, 27);
 
         BigDecimal expectedValue;
         expectedValue = FOURTEEN.divide(THIRTY_ONE, NUMBER_OF_DECIMALS, ROUNDING_METHOD);
@@ -77,9 +77,9 @@ public class DoubleProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testDoubleProRation_TargetDateOnSecondBillingCycleDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 1, 1);
-        DateTime targetDate = buildDateTime(2011, 2, 27);
-        DateTime endDate = buildDateTime(2011, 2, 27);
+        final DateTime startDate = buildDateTime(2011, 1, 1);
+        final DateTime targetDate = buildDateTime(2011, 2, 27);
+        final DateTime endDate = buildDateTime(2011, 2, 27);
 
         BigDecimal expectedValue;
         expectedValue = FOURTEEN.divide(THIRTY_ONE, NUMBER_OF_DECIMALS, ROUNDING_METHOD);
@@ -91,9 +91,9 @@ public class DoubleProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testDoubleProRation_TargetDateInSecondProRationPeriod() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 1, 1);
-        DateTime targetDate = buildDateTime(2011, 2, 26);
-        DateTime endDate = buildDateTime(2011, 2, 27);
+        final DateTime startDate = buildDateTime(2011, 1, 1);
+        final DateTime targetDate = buildDateTime(2011, 2, 26);
+        final DateTime endDate = buildDateTime(2011, 2, 27);
 
         BigDecimal expectedValue;
         expectedValue = FOURTEEN.divide(THIRTY_ONE, NUMBER_OF_DECIMALS, ROUNDING_METHOD);
@@ -105,9 +105,9 @@ public class DoubleProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testDoubleProRation_TargetDateOnEndDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 1, 1);
-        DateTime targetDate = buildDateTime(2011, 2, 27);
-        DateTime endDate = buildDateTime(2011, 2, 27);
+        final DateTime startDate = buildDateTime(2011, 1, 1);
+        final DateTime targetDate = buildDateTime(2011, 2, 27);
+        final DateTime endDate = buildDateTime(2011, 2, 27);
 
         BigDecimal expectedValue;
         expectedValue = FOURTEEN.divide(THIRTY_ONE, NUMBER_OF_DECIMALS, ROUNDING_METHOD);
@@ -119,9 +119,9 @@ public class DoubleProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testDoubleProRation_TargetDateAfterEndDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 1, 1);
-        DateTime targetDate = buildDateTime(2011, 3, 7);
-        DateTime endDate = buildDateTime(2011, 2, 27);
+        final DateTime startDate = buildDateTime(2011, 1, 1);
+        final DateTime targetDate = buildDateTime(2011, 3, 7);
+        final DateTime endDate = buildDateTime(2011, 2, 27);
 
         BigDecimal expectedValue;
         expectedValue = FOURTEEN.divide(THIRTY_ONE, NUMBER_OF_DECIMALS, ROUNDING_METHOD);
@@ -133,9 +133,9 @@ public class DoubleProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testDoubleProRationWithMultiplePeriods_TargetDateInSecondFullBillingPeriod() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 1, 1);
-        DateTime targetDate = buildDateTime(2011, 2, 26);
-        DateTime endDate = buildDateTime(2011, 4, 27);
+        final DateTime startDate = buildDateTime(2011, 1, 1);
+        final DateTime targetDate = buildDateTime(2011, 2, 26);
+        final DateTime endDate = buildDateTime(2011, 4, 27);
 
         BigDecimal expectedValue;
         expectedValue = FOURTEEN.divide(THIRTY_ONE, NUMBER_OF_DECIMALS, ROUNDING_METHOD);
diff --git a/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/monthly/LeadingProRationTests.java b/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/monthly/LeadingProRationTests.java
index f723738..11b6789 100644
--- a/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/monthly/LeadingProRationTests.java
+++ b/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/monthly/LeadingProRationTests.java
@@ -34,10 +34,10 @@ public class LeadingProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testLeadingProRation_Evergreen_TargetDateOnStartDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 1);
-        DateTime targetDate = buildDateTime(2011, 2, 1);
+        final DateTime startDate = buildDateTime(2011, 2, 1);
+        final DateTime targetDate = buildDateTime(2011, 2, 1);
 
-        BigDecimal expectedValue;
+        final BigDecimal expectedValue;
         expectedValue = TWELVE.divide(THIRTY_ONE, NUMBER_OF_DECIMALS, ROUNDING_METHOD);
 
         testCalculateNumberOfBillingCycles(startDate, targetDate, 13, expectedValue);
@@ -45,10 +45,10 @@ public class LeadingProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testLeadingProRation_Evergreen_TargetDateInProRationPeriod() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 1);
-        DateTime targetDate = buildDateTime(2011, 2, 4);
+        final DateTime startDate = buildDateTime(2011, 2, 1);
+        final DateTime targetDate = buildDateTime(2011, 2, 4);
 
-        BigDecimal expectedValue;
+        final BigDecimal expectedValue;
         expectedValue = TWELVE.divide(THIRTY_ONE, NUMBER_OF_DECIMALS, ROUNDING_METHOD);
 
         testCalculateNumberOfBillingCycles(startDate, targetDate, 13, expectedValue);
@@ -56,10 +56,10 @@ public class LeadingProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testLeadingProRation_Evergreen_TargetDateOnFirstBillingDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 1);
-        DateTime targetDate = buildDateTime(2011, 2, 13);
+        final DateTime startDate = buildDateTime(2011, 2, 1);
+        final DateTime targetDate = buildDateTime(2011, 2, 13);
 
-        BigDecimal expectedValue;
+        final BigDecimal expectedValue;
         expectedValue = TWELVE.divide(THIRTY_ONE, NUMBER_OF_DECIMALS, ROUNDING_METHOD).add(ONE);
 
         testCalculateNumberOfBillingCycles(startDate, targetDate, 13, expectedValue);
@@ -67,10 +67,10 @@ public class LeadingProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testLeadingProRation_Evergreen_TargetDateAfterFirstBillingPeriod() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 1);
-        DateTime targetDate = buildDateTime(2011, 4, 13);
+        final DateTime startDate = buildDateTime(2011, 2, 1);
+        final DateTime targetDate = buildDateTime(2011, 4, 13);
 
-        BigDecimal expectedValue;
+        final BigDecimal expectedValue;
         expectedValue = TWELVE.divide(THIRTY_ONE, NUMBER_OF_DECIMALS, ROUNDING_METHOD).add(THREE);
 
         testCalculateNumberOfBillingCycles(startDate, targetDate, 13, expectedValue);
@@ -78,11 +78,11 @@ public class LeadingProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testLeadingProRation_WithEndDate_TargetDateOnStartDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 1);
-        DateTime targetDate = buildDateTime(2011, 2, 1);
-        DateTime endDate = buildDateTime(2011, 4, 13);
+        final DateTime startDate = buildDateTime(2011, 2, 1);
+        final DateTime targetDate = buildDateTime(2011, 2, 1);
+        final DateTime endDate = buildDateTime(2011, 4, 13);
 
-        BigDecimal expectedValue;
+        final BigDecimal expectedValue;
         expectedValue = TWELVE.divide(THIRTY_ONE, NUMBER_OF_DECIMALS, ROUNDING_METHOD);
 
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 13, expectedValue);
@@ -90,11 +90,11 @@ public class LeadingProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testLeadingProRation_WithEndDate_TargetDateInProRationPeriod() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 1);
-        DateTime targetDate = buildDateTime(2011, 2, 4);
-        DateTime endDate = buildDateTime(2011, 4, 13);
+        final DateTime startDate = buildDateTime(2011, 2, 1);
+        final DateTime targetDate = buildDateTime(2011, 2, 4);
+        final DateTime endDate = buildDateTime(2011, 4, 13);
 
-        BigDecimal expectedValue;
+        final BigDecimal expectedValue;
         expectedValue = TWELVE.divide(THIRTY_ONE, NUMBER_OF_DECIMALS, ROUNDING_METHOD);
 
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 13, expectedValue);
@@ -102,11 +102,11 @@ public class LeadingProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testLeadingProRation_WithEndDate_TargetDateOnFirstBillingDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 1);
-        DateTime targetDate = buildDateTime(2011, 2, 13);
-        DateTime endDate = buildDateTime(2011, 4, 13);
+        final DateTime startDate = buildDateTime(2011, 2, 1);
+        final DateTime targetDate = buildDateTime(2011, 2, 13);
+        final DateTime endDate = buildDateTime(2011, 4, 13);
 
-        BigDecimal expectedValue;
+        final BigDecimal expectedValue;
         expectedValue = TWELVE.divide(THIRTY_ONE, NUMBER_OF_DECIMALS, ROUNDING_METHOD).add(ONE);
 
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 13, expectedValue);
@@ -114,11 +114,11 @@ public class LeadingProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testLeadingProRation_WithEndDate_TargetDateInFinalBillingPeriod() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 1);
-        DateTime targetDate = buildDateTime(2011, 4, 10);
-        DateTime endDate = buildDateTime(2011, 4, 13);
+        final DateTime startDate = buildDateTime(2011, 2, 1);
+        final DateTime targetDate = buildDateTime(2011, 4, 10);
+        final DateTime endDate = buildDateTime(2011, 4, 13);
 
-        BigDecimal expectedValue;
+        final BigDecimal expectedValue;
         expectedValue = TWELVE.divide(THIRTY_ONE, NUMBER_OF_DECIMALS, ROUNDING_METHOD).add(TWO);
 
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 13, expectedValue);
@@ -126,11 +126,11 @@ public class LeadingProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testLeadingProRation_WithEndDate_TargetDateOnEndDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 1);
-        DateTime targetDate = buildDateTime(2011, 4, 13);
-        DateTime endDate = buildDateTime(2011, 4, 13);
+        final DateTime startDate = buildDateTime(2011, 2, 1);
+        final DateTime targetDate = buildDateTime(2011, 4, 13);
+        final DateTime endDate = buildDateTime(2011, 4, 13);
 
-        BigDecimal expectedValue;
+        final BigDecimal expectedValue;
         expectedValue = TWELVE.divide(THIRTY_ONE, NUMBER_OF_DECIMALS, ROUNDING_METHOD).add(TWO);
 
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 13, expectedValue);
@@ -138,11 +138,11 @@ public class LeadingProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testLeadingProRation_WithEndDate_TargetDateAfterEndDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 1);
-        DateTime targetDate = buildDateTime(2011, 4, 10);
-        DateTime endDate = buildDateTime(2011, 4, 13);
+        final DateTime startDate = buildDateTime(2011, 2, 1);
+        final DateTime targetDate = buildDateTime(2011, 4, 10);
+        final DateTime endDate = buildDateTime(2011, 4, 13);
 
-        BigDecimal expectedValue;
+        final BigDecimal expectedValue;
         expectedValue = TWELVE.divide(THIRTY_ONE, NUMBER_OF_DECIMALS, ROUNDING_METHOD).add(TWO);
 
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 13, expectedValue);
diff --git a/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/monthly/ProRationTests.java b/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/monthly/ProRationTests.java
index 78f06b4..eb2d3e8 100644
--- a/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/monthly/ProRationTests.java
+++ b/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/monthly/ProRationTests.java
@@ -34,9 +34,9 @@ public class ProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testSinglePlan_WithPhaseChange() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 10);
-        DateTime phaseChangeDate = buildDateTime(2011, 2, 24);
-        DateTime targetDate = buildDateTime(2011, 3, 6);
+        final DateTime startDate = buildDateTime(2011, 2, 10);
+        final DateTime phaseChangeDate = buildDateTime(2011, 2, 24);
+        final DateTime targetDate = buildDateTime(2011, 3, 6);
 
         testCalculateNumberOfBillingCycles(startDate, phaseChangeDate, targetDate, 10, ONE_HALF);
         testCalculateNumberOfBillingCycles(phaseChangeDate, targetDate, 10, ONE_HALF);
@@ -44,9 +44,9 @@ public class ProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testSinglePlan_WithPhaseChange_BeforeBillCycleDay() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 3);
-        DateTime phaseChangeDate = buildDateTime(2011, 2, 17);
-        DateTime targetDate = buildDateTime(2011, 3, 1);
+        final DateTime startDate = buildDateTime(2011, 2, 3);
+        final DateTime phaseChangeDate = buildDateTime(2011, 2, 17);
+        final DateTime targetDate = buildDateTime(2011, 3, 1);
 
         testCalculateNumberOfBillingCycles(startDate, phaseChangeDate, targetDate, 3, ONE_HALF);
         testCalculateNumberOfBillingCycles(phaseChangeDate, targetDate, 3, ONE_HALF);
@@ -54,9 +54,9 @@ public class ProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testSinglePlan_WithPhaseChange_OnBillCycleDay() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 3);
-        DateTime phaseChangeDate = buildDateTime(2011, 2, 17);
-        DateTime targetDate = buildDateTime(2011, 3, 3);
+        final DateTime startDate = buildDateTime(2011, 2, 3);
+        final DateTime phaseChangeDate = buildDateTime(2011, 2, 17);
+        final DateTime targetDate = buildDateTime(2011, 3, 3);
 
         testCalculateNumberOfBillingCycles(startDate, phaseChangeDate, targetDate, 3, ONE_HALF);
         testCalculateNumberOfBillingCycles(phaseChangeDate, targetDate, 3, ONE_AND_A_HALF);
@@ -64,9 +64,9 @@ public class ProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testSinglePlan_WithPhaseChange_AfterBillCycleDay() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 3);
-        DateTime phaseChangeDate = buildDateTime(2011, 2, 17);
-        DateTime targetDate = buildDateTime(2011, 3, 4);
+        final DateTime startDate = buildDateTime(2011, 2, 3);
+        final DateTime phaseChangeDate = buildDateTime(2011, 2, 17);
+        final DateTime targetDate = buildDateTime(2011, 3, 4);
 
         testCalculateNumberOfBillingCycles(startDate, phaseChangeDate, targetDate, 3, ONE_HALF);
         testCalculateNumberOfBillingCycles(phaseChangeDate, targetDate, 3, ONE_AND_A_HALF);
@@ -74,9 +74,9 @@ public class ProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testPlanChange_WithChangeOfBillCycleDayToLaterDay() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 1);
-        DateTime planChangeDate = buildDateTime(2011, 2, 15);
-        DateTime targetDate = buildDateTime(2011, 3, 1);
+        final DateTime startDate = buildDateTime(2011, 2, 1);
+        final DateTime planChangeDate = buildDateTime(2011, 2, 15);
+        final DateTime targetDate = buildDateTime(2011, 3, 1);
 
         testCalculateNumberOfBillingCycles(startDate, planChangeDate, targetDate, 1, ONE_HALF);
         testCalculateNumberOfBillingCycles(planChangeDate, targetDate, 15, ONE);
@@ -84,9 +84,9 @@ public class ProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testPlanChange_WithChangeOfBillCycleDayToEarlierDay() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 20);
-        DateTime planChangeDate = buildDateTime(2011, 3, 6);
-        DateTime targetDate = buildDateTime(2011, 3, 9);
+        final DateTime startDate = buildDateTime(2011, 2, 20);
+        final DateTime planChangeDate = buildDateTime(2011, 3, 6);
+        final DateTime targetDate = buildDateTime(2011, 3, 9);
 
         testCalculateNumberOfBillingCycles(startDate, planChangeDate, targetDate, 20, ONE_HALF);
         testCalculateNumberOfBillingCycles(planChangeDate, targetDate, 6, ONE);
@@ -94,41 +94,41 @@ public class ProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testSinglePlan_CrossingYearBoundary() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2010, 12, 15);
-        DateTime targetDate = buildDateTime(2011, 1, 16);
+        final DateTime startDate = buildDateTime(2010, 12, 15);
+        final DateTime targetDate = buildDateTime(2011, 1, 16);
 
         testCalculateNumberOfBillingCycles(startDate, targetDate, 15, TWO);
     }
 
     @Test
     public void testSinglePlan_LeapYear_StartingMidFebruary() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2012, 2, 15);
-        DateTime targetDate = buildDateTime(2012, 3, 15);
+        final DateTime startDate = buildDateTime(2012, 2, 15);
+        final DateTime targetDate = buildDateTime(2012, 3, 15);
 
         testCalculateNumberOfBillingCycles(startDate, targetDate, 15, TWO);
     }
 
     @Test
     public void testSinglePlan_LeapYear_StartingBeforeFebruary() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2012, 1, 15);
-        DateTime targetDate = buildDateTime(2012, 2, 3);
+        final DateTime startDate = buildDateTime(2012, 1, 15);
+        final DateTime targetDate = buildDateTime(2012, 2, 3);
 
         testCalculateNumberOfBillingCycles(startDate, targetDate, 15, ONE);
     }
 
     @Test
     public void testSinglePlan_LeapYear_IncludingAllOfFebruary() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2012, 1, 30);
-        DateTime targetDate = buildDateTime(2012, 3, 1);
+        final DateTime startDate = buildDateTime(2012, 1, 30);
+        final DateTime targetDate = buildDateTime(2012, 3, 1);
 
         testCalculateNumberOfBillingCycles(startDate, targetDate, 30, TWO);
     }
 
     @Test
     public void testSinglePlan_ChangeBCDTo31() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 1);
-        DateTime planChangeDate = buildDateTime(2011, 2, 14);
-        DateTime targetDate = buildDateTime(2011, 3, 1);
+        final DateTime startDate = buildDateTime(2011, 2, 1);
+        final DateTime planChangeDate = buildDateTime(2011, 2, 14);
+        final DateTime targetDate = buildDateTime(2011, 3, 1);
 
         BigDecimal expectedValue;
 
@@ -141,9 +141,9 @@ public class ProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testSinglePlan_ChangeBCD() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 1);
-        DateTime planChangeDate = buildDateTime(2011, 2, 14);
-        DateTime targetDate = buildDateTime(2011, 3, 1);
+        final DateTime startDate = buildDateTime(2011, 2, 1);
+        final DateTime planChangeDate = buildDateTime(2011, 2, 14);
+        final DateTime targetDate = buildDateTime(2011, 3, 1);
 
         BigDecimal expectedValue;
 
@@ -156,11 +156,11 @@ public class ProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testSinglePlan_LeapYearFebruaryProRation() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2012, 2, 1);
-        DateTime endDate = buildDateTime(2012, 2, 15);
-        DateTime targetDate = buildDateTime(2012, 2, 19);
+        final DateTime startDate = buildDateTime(2012, 2, 1);
+        final DateTime endDate = buildDateTime(2012, 2, 15);
+        final DateTime targetDate = buildDateTime(2012, 2, 19);
 
-        BigDecimal expectedValue;
+        final BigDecimal expectedValue;
         expectedValue = FOURTEEN.divide(TWENTY_NINE, NUMBER_OF_DECIMALS, ROUNDING_METHOD);
 
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 1, expectedValue);
@@ -168,11 +168,11 @@ public class ProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testPlanChange_BeforeBillingDay() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 7);
-        DateTime changeDate = buildDateTime(2011, 2, 15);
-        DateTime targetDate = buildDateTime(2011, 4, 21);
-        
-        BigDecimal expectedValue;
+        final DateTime startDate = buildDateTime(2011, 2, 7);
+        final DateTime changeDate = buildDateTime(2011, 2, 15);
+        final DateTime targetDate = buildDateTime(2011, 4, 21);
+
+        final BigDecimal expectedValue;
 
         expectedValue = EIGHT.divide(TWENTY_EIGHT, NUMBER_OF_DECIMALS, ROUNDING_METHOD);
         testCalculateNumberOfBillingCycles(startDate, changeDate, targetDate, 7, expectedValue);
@@ -182,22 +182,22 @@ public class ProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testPlanChange_OnBillingDay() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 7);
-        DateTime changeDate = buildDateTime(2011, 3, 7);
-        DateTime targetDate = buildDateTime(2011, 4, 21);
+        final DateTime startDate = buildDateTime(2011, 2, 7);
+        final DateTime changeDate = buildDateTime(2011, 3, 7);
+        final DateTime targetDate = buildDateTime(2011, 4, 21);
 
         testCalculateNumberOfBillingCycles(startDate, changeDate, targetDate, 7, ONE);
 
-        BigDecimal expectedValue;
+        final BigDecimal expectedValue;
         expectedValue = EIGHT.divide(TWENTY_EIGHT, NUMBER_OF_DECIMALS, ROUNDING_METHOD).add(TWO);
         testCalculateNumberOfBillingCycles(changeDate, targetDate, 15, expectedValue);
     }
 
     @Test
     public void testPlanChange_AfterBillingDay() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 7);
-        DateTime changeDate = buildDateTime(2011, 3, 10);
-        DateTime targetDate = buildDateTime(2011, 4, 21);
+        final DateTime startDate = buildDateTime(2011, 2, 7);
+        final DateTime changeDate = buildDateTime(2011, 3, 10);
+        final DateTime targetDate = buildDateTime(2011, 4, 21);
 
         BigDecimal expectedValue;
 
@@ -210,9 +210,9 @@ public class ProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testPlanChange_DoubleProRation() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 1, 31);
-        DateTime planChangeDate = buildDateTime(2011, 3, 10);
-        DateTime targetDate = buildDateTime(2011, 4, 21);
+        final DateTime startDate = buildDateTime(2011, 1, 31);
+        final DateTime planChangeDate = buildDateTime(2011, 3, 10);
+        final DateTime targetDate = buildDateTime(2011, 4, 21);
 
         BigDecimal expectedValue;
         expectedValue = SEVEN.divide(THIRTY_ONE, 2 * NUMBER_OF_DECIMALS, ROUNDING_METHOD);
@@ -221,17 +221,17 @@ public class ProRationTests extends ProRationInAdvanceTestBase {
         expectedValue = expectedValue.setScale(NUMBER_OF_DECIMALS, ROUNDING_METHOD);
         testCalculateNumberOfBillingCycles(startDate, planChangeDate, targetDate, 7, expectedValue);
 
-        expectedValue = FIVE.divide(TWENTY_EIGHT, NUMBER_OF_DECIMALS, ROUNDING_METHOD).add(TWO);  
+        expectedValue = FIVE.divide(TWENTY_EIGHT, NUMBER_OF_DECIMALS, ROUNDING_METHOD).add(TWO);
         testCalculateNumberOfBillingCycles(planChangeDate, targetDate, 15, expectedValue);
     }
 
     @Test
     public void testStartTargetEnd() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2010, 12, 15);
-        DateTime targetDate = buildDateTime(2011, 3, 15);
-        DateTime endDate = buildDateTime(2011, 3, 17);
+        final DateTime startDate = buildDateTime(2010, 12, 15);
+        final DateTime targetDate = buildDateTime(2011, 3, 15);
+        final DateTime endDate = buildDateTime(2011, 3, 17);
 
-        BigDecimal expectedValue = THREE.add(TWO.divide(THIRTY_ONE, NUMBER_OF_DECIMALS, ROUNDING_METHOD));
+        final BigDecimal expectedValue = THREE.add(TWO.divide(THIRTY_ONE, NUMBER_OF_DECIMALS, ROUNDING_METHOD));
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 15, expectedValue);
     }
-}
\ No newline at end of file
+}
diff --git a/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/monthly/TrailingProRationTests.java b/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/monthly/TrailingProRationTests.java
index 581e8af..5e6366d 100644
--- a/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/monthly/TrailingProRationTests.java
+++ b/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/monthly/TrailingProRationTests.java
@@ -34,58 +34,58 @@ public class TrailingProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testTargetDateOnStartDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2010, 6, 17);
-        DateTime endDate = buildDateTime(2010, 7, 25);
-        DateTime targetDate = buildDateTime(2010, 6, 17);
+        final DateTime startDate = buildDateTime(2010, 6, 17);
+        final DateTime endDate = buildDateTime(2010, 7, 25);
+        final DateTime targetDate = buildDateTime(2010, 6, 17);
 
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 17, ONE);
     }
 
     @Test
     public void testTargetDateInFirstBillingPeriod() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2010, 6, 17);
-        DateTime endDate = buildDateTime(2010, 7, 25);
-        DateTime targetDate = buildDateTime(2010, 6, 20);
+        final DateTime startDate = buildDateTime(2010, 6, 17);
+        final DateTime endDate = buildDateTime(2010, 7, 25);
+        final DateTime targetDate = buildDateTime(2010, 6, 20);
 
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 17, ONE);
     }
 
     @Test
     public void testTargetDateAtEndOfFirstBillingCycle() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2010, 6, 17);
-        DateTime endDate = buildDateTime(2010, 7, 25);
-        DateTime targetDate = buildDateTime(2010, 7, 17);
+        final DateTime startDate = buildDateTime(2010, 6, 17);
+        final DateTime endDate = buildDateTime(2010, 7, 25);
+        final DateTime targetDate = buildDateTime(2010, 7, 17);
 
-        BigDecimal expectedValue = ONE.add(EIGHT.divide(THIRTY_ONE, NUMBER_OF_DECIMALS, ROUNDING_METHOD));
+        final BigDecimal expectedValue = ONE.add(EIGHT.divide(THIRTY_ONE, NUMBER_OF_DECIMALS, ROUNDING_METHOD));
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 17, expectedValue);
     }
 
     @Test
     public void testTargetDateInProRationPeriod() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2010, 6, 17);
-        DateTime endDate = buildDateTime(2010, 7, 25);
-        DateTime targetDate = buildDateTime(2010, 7, 18);
+        final DateTime startDate = buildDateTime(2010, 6, 17);
+        final DateTime endDate = buildDateTime(2010, 7, 25);
+        final DateTime targetDate = buildDateTime(2010, 7, 18);
 
-        BigDecimal expectedValue = ONE.add(EIGHT.divide(THIRTY_ONE, NUMBER_OF_DECIMALS, ROUNDING_METHOD));
+        final BigDecimal expectedValue = ONE.add(EIGHT.divide(THIRTY_ONE, NUMBER_OF_DECIMALS, ROUNDING_METHOD));
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 17, expectedValue);
     }
 
     @Test
     public void testTargetDateOnEndDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2010, 6, 17);
-        DateTime endDate = buildDateTime(2010, 7, 25);
+        final DateTime startDate = buildDateTime(2010, 6, 17);
+        final DateTime endDate = buildDateTime(2010, 7, 25);
 
-        BigDecimal expectedValue = ONE.add(EIGHT.divide(THIRTY_ONE, NUMBER_OF_DECIMALS, ROUNDING_METHOD));
+        final BigDecimal expectedValue = ONE.add(EIGHT.divide(THIRTY_ONE, NUMBER_OF_DECIMALS, ROUNDING_METHOD));
         testCalculateNumberOfBillingCycles(startDate, endDate, endDate, 17, expectedValue);
     }
 
     @Test
     public void testTargetDateAfterEndDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2010, 6, 17);
-        DateTime endDate = buildDateTime(2010, 7, 25);
-        DateTime targetDate = buildDateTime(2010, 7, 30);
+        final DateTime startDate = buildDateTime(2010, 6, 17);
+        final DateTime endDate = buildDateTime(2010, 7, 25);
+        final DateTime targetDate = buildDateTime(2010, 7, 30);
 
-        BigDecimal expectedValue = ONE.add(EIGHT.divide(THIRTY_ONE, NUMBER_OF_DECIMALS, ROUNDING_METHOD));
+        final BigDecimal expectedValue = ONE.add(EIGHT.divide(THIRTY_ONE, NUMBER_OF_DECIMALS, ROUNDING_METHOD));
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 17, expectedValue);
     }
-}
\ No newline at end of file
+}
diff --git a/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/quarterly/DoubleProRationTests.java b/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/quarterly/DoubleProRationTests.java
index e6c3cf3..6aa022b 100644
--- a/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/quarterly/DoubleProRationTests.java
+++ b/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/quarterly/DoubleProRationTests.java
@@ -34,9 +34,9 @@ public class DoubleProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testDoubleProRation_TargetDateOnStartDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 1, 1);
-        DateTime targetDate = buildDateTime(2011, 1, 1);
-        DateTime endDate = buildDateTime(2011, 4, 27);
+        final DateTime startDate = buildDateTime(2011, 1, 1);
+        final DateTime targetDate = buildDateTime(2011, 1, 1);
+        final DateTime endDate = buildDateTime(2011, 4, 27);
 
         BigDecimal expectedValue = FOURTEEN.divide(NINETY_TWO, 2 * NUMBER_OF_DECIMALS, ROUNDING_METHOD);
         expectedValue = expectedValue.setScale(NUMBER_OF_DECIMALS, ROUNDING_METHOD);
@@ -45,9 +45,9 @@ public class DoubleProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testDoubleProRation_TargetDateInFirstProRationPeriod() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 1, 1);
-        DateTime targetDate = buildDateTime(2011, 1, 7);
-        DateTime endDate = buildDateTime(2011, 4, 27);
+        final DateTime startDate = buildDateTime(2011, 1, 1);
+        final DateTime targetDate = buildDateTime(2011, 1, 7);
+        final DateTime endDate = buildDateTime(2011, 4, 27);
 
         BigDecimal expectedValue = FOURTEEN.divide(NINETY_TWO, 2 * NUMBER_OF_DECIMALS, ROUNDING_METHOD);
         expectedValue = expectedValue.setScale(NUMBER_OF_DECIMALS, ROUNDING_METHOD);
@@ -56,9 +56,9 @@ public class DoubleProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testDoubleProRation_TargetDateOnFirstBillingCycleDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 1, 1);
-        DateTime targetDate = buildDateTime(2011, 1, 15);
-        DateTime endDate = buildDateTime(2011, 4, 27);
+        final DateTime startDate = buildDateTime(2011, 1, 1);
+        final DateTime targetDate = buildDateTime(2011, 1, 15);
+        final DateTime endDate = buildDateTime(2011, 4, 27);
 
         BigDecimal expectedValue = ONE.add(FOURTEEN.divide(NINETY_TWO, 2 * NUMBER_OF_DECIMALS, ROUNDING_METHOD));
         expectedValue = expectedValue.setScale(NUMBER_OF_DECIMALS, ROUNDING_METHOD);
@@ -67,9 +67,9 @@ public class DoubleProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testDoubleProRation_TargetDateInFullBillingPeriod() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 1, 1);
-        DateTime targetDate = buildDateTime(2011, 1, 22);
-        DateTime endDate = buildDateTime(2011, 4, 27);
+        final DateTime startDate = buildDateTime(2011, 1, 1);
+        final DateTime targetDate = buildDateTime(2011, 1, 22);
+        final DateTime endDate = buildDateTime(2011, 4, 27);
 
         BigDecimal expectedValue;
         expectedValue = FOURTEEN.divide(NINETY_TWO, 2 * NUMBER_OF_DECIMALS, ROUNDING_METHOD);
@@ -81,9 +81,9 @@ public class DoubleProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testDoubleProRation_TargetDateOnSecondBillingCycleDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 1, 1);
-        DateTime targetDate = buildDateTime(2011, 4, 15);
-        DateTime endDate = buildDateTime(2011, 4, 27);
+        final DateTime startDate = buildDateTime(2011, 1, 1);
+        final DateTime targetDate = buildDateTime(2011, 4, 15);
+        final DateTime endDate = buildDateTime(2011, 4, 27);
 
         BigDecimal expectedValue;
         expectedValue = FOURTEEN.divide(NINETY_TWO, 2 * NUMBER_OF_DECIMALS, ROUNDING_METHOD);
@@ -96,9 +96,9 @@ public class DoubleProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testDoubleProRation_TargetDateInSecondProRationPeriod() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 1, 1);
-        DateTime targetDate = buildDateTime(2011, 4, 26);
-        DateTime endDate = buildDateTime(2011, 4, 27);
+        final DateTime startDate = buildDateTime(2011, 1, 1);
+        final DateTime targetDate = buildDateTime(2011, 4, 26);
+        final DateTime endDate = buildDateTime(2011, 4, 27);
 
         BigDecimal expectedValue;
         expectedValue = FOURTEEN.divide(NINETY_TWO, 2 * NUMBER_OF_DECIMALS, ROUNDING_METHOD);
@@ -111,9 +111,9 @@ public class DoubleProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testDoubleProRation_TargetDateOnEndDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 1, 1);
-        DateTime targetDate = buildDateTime(2011, 4, 27);
-        DateTime endDate = buildDateTime(2011, 4, 27);
+        final DateTime startDate = buildDateTime(2011, 1, 1);
+        final DateTime targetDate = buildDateTime(2011, 4, 27);
+        final DateTime endDate = buildDateTime(2011, 4, 27);
 
         BigDecimal expectedValue;
         expectedValue = FOURTEEN.divide(NINETY_TWO, 2 * NUMBER_OF_DECIMALS, ROUNDING_METHOD);
@@ -126,9 +126,9 @@ public class DoubleProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testDoubleProRation_TargetDateAfterEndDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 1, 1);
-        DateTime targetDate = buildDateTime(2011, 5, 7);
-        DateTime endDate = buildDateTime(2011, 4, 27);
+        final DateTime startDate = buildDateTime(2011, 1, 1);
+        final DateTime targetDate = buildDateTime(2011, 5, 7);
+        final DateTime endDate = buildDateTime(2011, 4, 27);
 
         BigDecimal expectedValue;
         expectedValue = FOURTEEN.divide(NINETY_TWO, 2 * NUMBER_OF_DECIMALS, ROUNDING_METHOD);
@@ -141,9 +141,9 @@ public class DoubleProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testDoubleProRationWithMultiplePeriods_TargetDateInSecondFullBillingPeriod() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 1, 1);
-        DateTime targetDate = buildDateTime(2011, 6, 26);
-        DateTime endDate = buildDateTime(2011, 8, 27);
+        final DateTime startDate = buildDateTime(2011, 1, 1);
+        final DateTime targetDate = buildDateTime(2011, 6, 26);
+        final DateTime endDate = buildDateTime(2011, 8, 27);
 
         BigDecimal expectedValue;
         expectedValue = FOURTEEN.divide(NINETY_TWO, 2 * NUMBER_OF_DECIMALS, ROUNDING_METHOD);
diff --git a/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/quarterly/LeadingProRationTests.java b/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/quarterly/LeadingProRationTests.java
index 18bb8af..681fac1 100644
--- a/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/quarterly/LeadingProRationTests.java
+++ b/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/quarterly/LeadingProRationTests.java
@@ -34,10 +34,10 @@ public class LeadingProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testLeadingProRation_Evergreen_TargetDateOnStartDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 1);
-        DateTime targetDate = buildDateTime(2011, 2, 1);
+        final DateTime startDate = buildDateTime(2011, 2, 1);
+        final DateTime targetDate = buildDateTime(2011, 2, 1);
 
-        BigDecimal expectedValue;
+        final BigDecimal expectedValue;
         expectedValue = TWELVE.divide(NINETY_TWO, NUMBER_OF_DECIMALS, ROUNDING_METHOD);
 
         testCalculateNumberOfBillingCycles(startDate, targetDate, 13, expectedValue);
@@ -45,10 +45,10 @@ public class LeadingProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testLeadingProRation_Evergreen_TargetDateInProRationPeriod() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 1);
-        DateTime targetDate = buildDateTime(2011, 2, 4);
+        final DateTime startDate = buildDateTime(2011, 2, 1);
+        final DateTime targetDate = buildDateTime(2011, 2, 4);
 
-        BigDecimal expectedValue;
+        final BigDecimal expectedValue;
         expectedValue = TWELVE.divide(NINETY_TWO, NUMBER_OF_DECIMALS, ROUNDING_METHOD);
 
         testCalculateNumberOfBillingCycles(startDate, targetDate, 13, expectedValue);
@@ -56,10 +56,10 @@ public class LeadingProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testLeadingProRation_Evergreen_TargetDateOnFirstBillingDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 1);
-        DateTime targetDate = buildDateTime(2011, 2, 13);
+        final DateTime startDate = buildDateTime(2011, 2, 1);
+        final DateTime targetDate = buildDateTime(2011, 2, 13);
 
-        BigDecimal expectedValue;
+        final BigDecimal expectedValue;
         expectedValue = TWELVE.divide(NINETY_TWO, NUMBER_OF_DECIMALS, ROUNDING_METHOD).add(ONE);
 
         testCalculateNumberOfBillingCycles(startDate, targetDate, 13, expectedValue);
@@ -67,10 +67,10 @@ public class LeadingProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testLeadingProRation_Evergreen_TargetDateAfterFirstBillingPeriod() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 1);
-        DateTime targetDate = buildDateTime(2011, 6, 13);
+        final DateTime startDate = buildDateTime(2011, 2, 1);
+        final DateTime targetDate = buildDateTime(2011, 6, 13);
 
-        BigDecimal expectedValue;
+        final BigDecimal expectedValue;
         expectedValue = TWELVE.divide(NINETY_TWO, NUMBER_OF_DECIMALS, ROUNDING_METHOD).add(TWO);
 
         testCalculateNumberOfBillingCycles(startDate, targetDate, 13, expectedValue);
@@ -78,11 +78,11 @@ public class LeadingProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testLeadingProRation_WithEndDate_TargetDateOnStartDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 1);
-        DateTime targetDate = buildDateTime(2011, 2, 1);
-        DateTime endDate = buildDateTime(2011, 8, 13);
+        final DateTime startDate = buildDateTime(2011, 2, 1);
+        final DateTime targetDate = buildDateTime(2011, 2, 1);
+        final DateTime endDate = buildDateTime(2011, 8, 13);
 
-        BigDecimal expectedValue;
+        final BigDecimal expectedValue;
         expectedValue = TWELVE.divide(NINETY_TWO, NUMBER_OF_DECIMALS, ROUNDING_METHOD);
 
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 13, expectedValue);
@@ -90,11 +90,11 @@ public class LeadingProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testLeadingProRation_WithEndDate_TargetDateInProRationPeriod() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 1);
-        DateTime targetDate = buildDateTime(2011, 2, 4);
-        DateTime endDate = buildDateTime(2011, 8, 13);
+        final DateTime startDate = buildDateTime(2011, 2, 1);
+        final DateTime targetDate = buildDateTime(2011, 2, 4);
+        final DateTime endDate = buildDateTime(2011, 8, 13);
 
-        BigDecimal expectedValue;
+        final BigDecimal expectedValue;
         expectedValue = TWELVE.divide(NINETY_TWO, NUMBER_OF_DECIMALS, ROUNDING_METHOD);
 
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 13, expectedValue);
@@ -102,11 +102,11 @@ public class LeadingProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testLeadingProRation_WithEndDate_TargetDateOnFirstBillingDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 1);
-        DateTime targetDate = buildDateTime(2011, 2, 13);
-        DateTime endDate = buildDateTime(2011, 8, 13);
+        final DateTime startDate = buildDateTime(2011, 2, 1);
+        final DateTime targetDate = buildDateTime(2011, 2, 13);
+        final DateTime endDate = buildDateTime(2011, 8, 13);
 
-        BigDecimal expectedValue;
+        final BigDecimal expectedValue;
         expectedValue = TWELVE.divide(NINETY_TWO, NUMBER_OF_DECIMALS, ROUNDING_METHOD).add(ONE);
 
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 13, expectedValue);
@@ -114,11 +114,11 @@ public class LeadingProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testLeadingProRation_WithEndDate_TargetDateInFinalBillingPeriod() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 1);
-        DateTime targetDate = buildDateTime(2011, 8, 10);
-        DateTime endDate = buildDateTime(2011, 8, 13);
+        final DateTime startDate = buildDateTime(2011, 2, 1);
+        final DateTime targetDate = buildDateTime(2011, 8, 10);
+        final DateTime endDate = buildDateTime(2011, 8, 13);
 
-        BigDecimal expectedValue;
+        final BigDecimal expectedValue;
         expectedValue = TWELVE.divide(NINETY_TWO, NUMBER_OF_DECIMALS, ROUNDING_METHOD).add(TWO);
 
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 13, expectedValue);
@@ -126,11 +126,11 @@ public class LeadingProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testLeadingProRation_WithEndDate_TargetDateOnEndDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 1);
-        DateTime targetDate = buildDateTime(2011, 8, 13);
-        DateTime endDate = buildDateTime(2011, 8, 13);
+        final DateTime startDate = buildDateTime(2011, 2, 1);
+        final DateTime targetDate = buildDateTime(2011, 8, 13);
+        final DateTime endDate = buildDateTime(2011, 8, 13);
 
-        BigDecimal expectedValue;
+        final BigDecimal expectedValue;
         expectedValue = TWELVE.divide(NINETY_TWO, NUMBER_OF_DECIMALS, ROUNDING_METHOD).add(TWO);
 
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 13, expectedValue);
@@ -138,11 +138,11 @@ public class LeadingProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testLeadingProRation_WithEndDate_TargetDateAfterEndDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 1);
-        DateTime targetDate = buildDateTime(2011, 9, 10);
-        DateTime endDate = buildDateTime(2011, 8, 13);
+        final DateTime startDate = buildDateTime(2011, 2, 1);
+        final DateTime targetDate = buildDateTime(2011, 9, 10);
+        final DateTime endDate = buildDateTime(2011, 8, 13);
 
-        BigDecimal expectedValue;
+        final BigDecimal expectedValue;
         expectedValue = TWELVE.divide(NINETY_TWO, NUMBER_OF_DECIMALS, ROUNDING_METHOD).add(TWO);
 
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 13, expectedValue);
diff --git a/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/quarterly/ProRationTests.java b/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/quarterly/ProRationTests.java
index 2988dfe..20611b1 100644
--- a/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/quarterly/ProRationTests.java
+++ b/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/quarterly/ProRationTests.java
@@ -34,9 +34,9 @@ public class ProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testSinglePlan_WithPhaseChange() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 10);
-        DateTime phaseChangeDate = buildDateTime(2011, 2, 24);
-        DateTime targetDate = buildDateTime(2011, 3, 6);
+        final DateTime startDate = buildDateTime(2011, 2, 10);
+        final DateTime phaseChangeDate = buildDateTime(2011, 2, 24);
+        final DateTime targetDate = buildDateTime(2011, 3, 6);
 
         BigDecimal expectedValue;
         expectedValue = FOURTEEN.divide(EIGHTY_NINE, NUMBER_OF_DECIMALS, ROUNDING_METHOD);
@@ -48,9 +48,9 @@ public class ProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testSinglePlan_WithPhaseChange_BeforeBillCycleDay() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 3);
-        DateTime phaseChangeDate = buildDateTime(2011, 2, 17);
-        DateTime targetDate = buildDateTime(2011, 3, 1);
+        final DateTime startDate = buildDateTime(2011, 2, 3);
+        final DateTime phaseChangeDate = buildDateTime(2011, 2, 17);
+        final DateTime targetDate = buildDateTime(2011, 3, 1);
 
         BigDecimal expectedValue;
         expectedValue = FOURTEEN.divide(EIGHTY_NINE, NUMBER_OF_DECIMALS, ROUNDING_METHOD);
@@ -62,9 +62,9 @@ public class ProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testSinglePlan_WithPhaseChange_OnBillCycleDay() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 3);
-        DateTime phaseChangeDate = buildDateTime(2011, 2, 17);
-        DateTime targetDate = buildDateTime(2011, 3, 3);
+        final DateTime startDate = buildDateTime(2011, 2, 3);
+        final DateTime phaseChangeDate = buildDateTime(2011, 2, 17);
+        final DateTime targetDate = buildDateTime(2011, 3, 3);
 
         BigDecimal expectedValue;
         expectedValue = FOURTEEN.divide(EIGHTY_NINE, NUMBER_OF_DECIMALS, ROUNDING_METHOD);
@@ -76,9 +76,9 @@ public class ProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testSinglePlan_WithPhaseChange_AfterBillCycleDay() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 3);
-        DateTime phaseChangeDate = buildDateTime(2011, 2, 17);
-        DateTime targetDate = buildDateTime(2011, 3, 4);
+        final DateTime startDate = buildDateTime(2011, 2, 3);
+        final DateTime phaseChangeDate = buildDateTime(2011, 2, 17);
+        final DateTime targetDate = buildDateTime(2011, 3, 4);
 
         BigDecimal expectedValue;
         expectedValue = FOURTEEN.divide(EIGHTY_NINE, NUMBER_OF_DECIMALS, ROUNDING_METHOD);
@@ -90,63 +90,63 @@ public class ProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testPlanChange_WithChangeOfBillCycleDayToLaterDay() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 1);
-        DateTime planChangeDate = buildDateTime(2011, 2, 15);
-        DateTime targetDate = buildDateTime(2011, 3, 1);
+        final DateTime startDate = buildDateTime(2011, 2, 1);
+        final DateTime planChangeDate = buildDateTime(2011, 2, 15);
+        final DateTime targetDate = buildDateTime(2011, 3, 1);
 
-        BigDecimal expectedValue = FOURTEEN.divide(EIGHTY_NINE, NUMBER_OF_DECIMALS, ROUNDING_METHOD);
+        final BigDecimal expectedValue = FOURTEEN.divide(EIGHTY_NINE, NUMBER_OF_DECIMALS, ROUNDING_METHOD);
         testCalculateNumberOfBillingCycles(startDate, planChangeDate, targetDate, 1, expectedValue);
         testCalculateNumberOfBillingCycles(planChangeDate, targetDate, 15, ONE);
     }
 
     @Test
     public void testPlanChange_WithChangeOfBillCycleDayToEarlierDay() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 20);
-        DateTime planChangeDate = buildDateTime(2011, 3, 6);
-        DateTime targetDate = buildDateTime(2011, 3, 9);
+        final DateTime startDate = buildDateTime(2011, 2, 20);
+        final DateTime planChangeDate = buildDateTime(2011, 3, 6);
+        final DateTime targetDate = buildDateTime(2011, 3, 9);
 
-        BigDecimal expectedValue = FOURTEEN.divide(EIGHTY_NINE, NUMBER_OF_DECIMALS, ROUNDING_METHOD);
+        final BigDecimal expectedValue = FOURTEEN.divide(EIGHTY_NINE, NUMBER_OF_DECIMALS, ROUNDING_METHOD);
         testCalculateNumberOfBillingCycles(startDate, planChangeDate, targetDate, 20, expectedValue);
         testCalculateNumberOfBillingCycles(planChangeDate, targetDate, 6, ONE);
     }
 
     @Test
     public void testSinglePlan_CrossingYearBoundary() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2010, 12, 15);
-        DateTime targetDate = buildDateTime(2011, 1, 16);
+        final DateTime startDate = buildDateTime(2010, 12, 15);
+        final DateTime targetDate = buildDateTime(2011, 1, 16);
 
         testCalculateNumberOfBillingCycles(startDate, targetDate, 15, ONE);
     }
 
     @Test
     public void testSinglePlan_LeapYear_StartingMidFebruary() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2012, 2, 15);
-        DateTime targetDate = buildDateTime(2012, 3, 15);
+        final DateTime startDate = buildDateTime(2012, 2, 15);
+        final DateTime targetDate = buildDateTime(2012, 3, 15);
 
         testCalculateNumberOfBillingCycles(startDate, targetDate, 15, ONE);
     }
 
     @Test
     public void testSinglePlan_LeapYear_StartingBeforeFebruary() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2012, 1, 15);
-        DateTime targetDate = buildDateTime(2012, 2, 3);
+        final DateTime startDate = buildDateTime(2012, 1, 15);
+        final DateTime targetDate = buildDateTime(2012, 2, 3);
 
         testCalculateNumberOfBillingCycles(startDate, targetDate, 15, ONE);
     }
 
     @Test
     public void testSinglePlan_LeapYear_IncludingAllOfFebruary() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2012, 1, 30);
-        DateTime targetDate = buildDateTime(2012, 3, 1);
+        final DateTime startDate = buildDateTime(2012, 1, 30);
+        final DateTime targetDate = buildDateTime(2012, 3, 1);
 
         testCalculateNumberOfBillingCycles(startDate, targetDate, 30, ONE);
     }
 
     @Test
     public void testSinglePlan_ChangeBCDTo31() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 1);
-        DateTime planChangeDate = buildDateTime(2011, 2, 14);
-        DateTime targetDate = buildDateTime(2011, 3, 1);
+        final DateTime startDate = buildDateTime(2011, 2, 1);
+        final DateTime planChangeDate = buildDateTime(2011, 2, 14);
+        final DateTime targetDate = buildDateTime(2011, 3, 1);
 
         BigDecimal expectedValue;
 
@@ -159,9 +159,9 @@ public class ProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testSinglePlan_ChangeBCD() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 1);
-        DateTime planChangeDate = buildDateTime(2011, 2, 14);
-        DateTime targetDate = buildDateTime(2011, 5, 1);
+        final DateTime startDate = buildDateTime(2011, 2, 1);
+        final DateTime planChangeDate = buildDateTime(2011, 2, 14);
+        final DateTime targetDate = buildDateTime(2011, 5, 1);
 
         BigDecimal expectedValue;
 
@@ -174,11 +174,11 @@ public class ProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testSinglePlan_LeapYearFebruaryProRation() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2012, 2, 1);
-        DateTime endDate = buildDateTime(2012, 2, 15);
-        DateTime targetDate = buildDateTime(2012, 2, 19);
+        final DateTime startDate = buildDateTime(2012, 2, 1);
+        final DateTime endDate = buildDateTime(2012, 2, 15);
+        final DateTime targetDate = buildDateTime(2012, 2, 19);
 
-        BigDecimal expectedValue;
+        final BigDecimal expectedValue;
         expectedValue = FOURTEEN.divide(NINETY, NUMBER_OF_DECIMALS, ROUNDING_METHOD);
 
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 1, expectedValue);
@@ -186,11 +186,11 @@ public class ProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testPlanChange_BeforeBillingDay() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 7);
-        DateTime changeDate = buildDateTime(2011, 2, 15);
-        DateTime targetDate = buildDateTime(2011, 9, 21);
-        
-        BigDecimal expectedValue;
+        final DateTime startDate = buildDateTime(2011, 2, 7);
+        final DateTime changeDate = buildDateTime(2011, 2, 15);
+        final DateTime targetDate = buildDateTime(2011, 9, 21);
+
+        final BigDecimal expectedValue;
 
         expectedValue = EIGHT.divide(EIGHTY_NINE, NUMBER_OF_DECIMALS, ROUNDING_METHOD);
         testCalculateNumberOfBillingCycles(startDate, changeDate, targetDate, 7, expectedValue);
@@ -200,22 +200,22 @@ public class ProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testPlanChange_OnBillingDay() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 7);
-        DateTime changeDate = buildDateTime(2011, 5, 7);
-        DateTime targetDate = buildDateTime(2011, 7, 21);
+        final DateTime startDate = buildDateTime(2011, 2, 7);
+        final DateTime changeDate = buildDateTime(2011, 5, 7);
+        final DateTime targetDate = buildDateTime(2011, 7, 21);
 
         testCalculateNumberOfBillingCycles(startDate, changeDate, targetDate, 7, ONE);
 
-        BigDecimal expectedValue;
+        final BigDecimal expectedValue;
         expectedValue = EIGHT.divide(EIGHTY_NINE, NUMBER_OF_DECIMALS, ROUNDING_METHOD).add(ONE);
         testCalculateNumberOfBillingCycles(changeDate, targetDate, 15, expectedValue);
     }
 
     @Test
     public void testPlanChange_AfterBillingDay() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 2, 7);
-        DateTime changeDate = buildDateTime(2011, 5, 10);
-        DateTime targetDate = buildDateTime(2011, 9, 21);
+        final DateTime startDate = buildDateTime(2011, 2, 7);
+        final DateTime changeDate = buildDateTime(2011, 5, 10);
+        final DateTime targetDate = buildDateTime(2011, 9, 21);
 
         BigDecimal expectedValue;
 
@@ -228,9 +228,9 @@ public class ProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testPlanChange_DoubleProRation() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 1, 31);
-        DateTime planChangeDate = buildDateTime(2011, 5, 10);
-        DateTime targetDate = buildDateTime(2011, 5, 21);
+        final DateTime startDate = buildDateTime(2011, 1, 31);
+        final DateTime planChangeDate = buildDateTime(2011, 5, 10);
+        final DateTime targetDate = buildDateTime(2011, 5, 21);
 
         BigDecimal expectedValue;
         expectedValue = SEVEN.divide(NINETY_TWO, NUMBER_OF_DECIMALS, ROUNDING_METHOD);
@@ -244,11 +244,11 @@ public class ProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testStartTargetEnd() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2010, 12, 15);
-        DateTime targetDate = buildDateTime(2011, 6, 15);
-        DateTime endDate = buildDateTime(2011, 6, 17);
+        final DateTime startDate = buildDateTime(2010, 12, 15);
+        final DateTime targetDate = buildDateTime(2011, 6, 15);
+        final DateTime endDate = buildDateTime(2011, 6, 17);
 
-        BigDecimal expectedValue = TWO.add(TWO.divide(NINETY_TWO, NUMBER_OF_DECIMALS, ROUNDING_METHOD));
+        final BigDecimal expectedValue = TWO.add(TWO.divide(NINETY_TWO, NUMBER_OF_DECIMALS, ROUNDING_METHOD));
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 15, expectedValue);
     }
-}
\ No newline at end of file
+}
diff --git a/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/quarterly/TrailingProRationTests.java b/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/quarterly/TrailingProRationTests.java
index 270518d..a0b1573 100644
--- a/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/quarterly/TrailingProRationTests.java
+++ b/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/quarterly/TrailingProRationTests.java
@@ -34,58 +34,58 @@ public class TrailingProRationTests extends ProRationInAdvanceTestBase {
 
     @Test
     public void testTargetDateOnStartDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2010, 6, 17);
-        DateTime endDate = buildDateTime(2010, 9, 25);
-        DateTime targetDate = buildDateTime(2010, 6, 17);
+        final DateTime startDate = buildDateTime(2010, 6, 17);
+        final DateTime endDate = buildDateTime(2010, 9, 25);
+        final DateTime targetDate = buildDateTime(2010, 6, 17);
 
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 17, ONE);
     }
 
     @Test
     public void testTargetDateInFirstBillingPeriod() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2010, 6, 17);
-        DateTime endDate = buildDateTime(2010, 9, 25);
-        DateTime targetDate = buildDateTime(2010, 6, 20);
+        final DateTime startDate = buildDateTime(2010, 6, 17);
+        final DateTime endDate = buildDateTime(2010, 9, 25);
+        final DateTime targetDate = buildDateTime(2010, 6, 20);
 
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 17, ONE);
     }
 
     @Test
     public void testTargetDateAtEndOfFirstBillingCycle() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2010, 6, 17);
-        DateTime endDate = buildDateTime(2010, 9, 25);
-        DateTime targetDate = buildDateTime(2010, 9, 17);
+        final DateTime startDate = buildDateTime(2010, 6, 17);
+        final DateTime endDate = buildDateTime(2010, 9, 25);
+        final DateTime targetDate = buildDateTime(2010, 9, 17);
 
-        BigDecimal expectedValue = ONE.add(EIGHT.divide(NINETY_ONE, NUMBER_OF_DECIMALS, ROUNDING_METHOD));
+        final BigDecimal expectedValue = ONE.add(EIGHT.divide(NINETY_ONE, NUMBER_OF_DECIMALS, ROUNDING_METHOD));
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 17, expectedValue);
     }
 
     @Test
     public void testTargetDateInProRationPeriod() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2010, 6, 17);
-        DateTime endDate = buildDateTime(2010, 9, 25);
-        DateTime targetDate = buildDateTime(2010, 9, 18);
+        final DateTime startDate = buildDateTime(2010, 6, 17);
+        final DateTime endDate = buildDateTime(2010, 9, 25);
+        final DateTime targetDate = buildDateTime(2010, 9, 18);
 
-        BigDecimal expectedValue = ONE.add(EIGHT.divide(NINETY_ONE, NUMBER_OF_DECIMALS, ROUNDING_METHOD));
+        final BigDecimal expectedValue = ONE.add(EIGHT.divide(NINETY_ONE, NUMBER_OF_DECIMALS, ROUNDING_METHOD));
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 17, expectedValue);
     }
 
     @Test
     public void testTargetDateOnEndDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2010, 6, 17);
-        DateTime endDate = buildDateTime(2010, 9, 25);
+        final DateTime startDate = buildDateTime(2010, 6, 17);
+        final DateTime endDate = buildDateTime(2010, 9, 25);
 
-        BigDecimal expectedValue = ONE.add(EIGHT.divide(NINETY_ONE, NUMBER_OF_DECIMALS, ROUNDING_METHOD));
+        final BigDecimal expectedValue = ONE.add(EIGHT.divide(NINETY_ONE, NUMBER_OF_DECIMALS, ROUNDING_METHOD));
         testCalculateNumberOfBillingCycles(startDate, endDate, endDate, 17, expectedValue);
     }
 
     @Test
     public void testTargetDateAfterEndDate() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2010, 6, 17);
-        DateTime endDate = buildDateTime(2010, 9, 25);
-        DateTime targetDate = buildDateTime(2010, 9, 30);
+        final DateTime startDate = buildDateTime(2010, 6, 17);
+        final DateTime endDate = buildDateTime(2010, 9, 25);
+        final DateTime targetDate = buildDateTime(2010, 9, 30);
 
-        BigDecimal expectedValue = ONE.add(EIGHT.divide(NINETY_ONE, NUMBER_OF_DECIMALS, ROUNDING_METHOD));
+        final BigDecimal expectedValue = ONE.add(EIGHT.divide(NINETY_ONE, NUMBER_OF_DECIMALS, ROUNDING_METHOD));
         testCalculateNumberOfBillingCycles(startDate, endDate, targetDate, 17, expectedValue);
     }
-}
\ No newline at end of file
+}
diff --git a/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/ValidationProRationTests.java b/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/ValidationProRationTests.java
index 21dd092..30f0d4a 100644
--- a/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/ValidationProRationTests.java
+++ b/invoice/src/test/java/com/ning/billing/invoice/tests/inAdvance/ValidationProRationTests.java
@@ -16,8 +16,6 @@
 
 package com.ning.billing.invoice.tests.inAdvance;
 
-import static org.testng.Assert.assertEquals;
-
 import java.math.BigDecimal;
 
 import org.joda.time.DateTime;
@@ -29,6 +27,8 @@ import com.ning.billing.invoice.model.InAdvanceBillingMode;
 import com.ning.billing.invoice.model.InvalidDateSequenceException;
 import com.ning.billing.invoice.tests.ProRationTestBase;
 
+import static org.testng.Assert.assertEquals;
+
 @Test(groups = {"fast", "invoicing", "proRation"})
 public class ValidationProRationTests extends ProRationTestBase {
     protected BillingPeriod getBillingPeriod() {
@@ -42,52 +42,52 @@ public class ValidationProRationTests extends ProRationTestBase {
 
     @Test(expectedExceptions = InvalidDateSequenceException.class)
     public void testTargetStartEnd() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 1, 30);
-        DateTime endDate = buildDateTime(2011, 3, 15);
-        DateTime targetDate = buildDateTime(2011, 1, 15);
+        final DateTime startDate = buildDateTime(2011, 1, 30);
+        final DateTime endDate = buildDateTime(2011, 3, 15);
+        final DateTime targetDate = buildDateTime(2011, 1, 15);
 
         calculateNumberOfBillingCycles(startDate, endDate, targetDate, 15);
     }
 
     @Test(expectedExceptions = InvalidDateSequenceException.class)
     public void testTargetEndStart() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 4, 30);
-        DateTime endDate = buildDateTime(2011, 3, 15);
-        DateTime targetDate = buildDateTime(2011, 2, 15);
+        final DateTime startDate = buildDateTime(2011, 4, 30);
+        final DateTime endDate = buildDateTime(2011, 3, 15);
+        final DateTime targetDate = buildDateTime(2011, 2, 15);
 
         calculateNumberOfBillingCycles(startDate, endDate, targetDate, 15);
     }
 
     @Test(expectedExceptions = InvalidDateSequenceException.class)
     public void testEndTargetStart() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 3, 30);
-        DateTime endDate = buildDateTime(2011, 1, 15);
-        DateTime targetDate = buildDateTime(2011, 2, 15);
+        final DateTime startDate = buildDateTime(2011, 3, 30);
+        final DateTime endDate = buildDateTime(2011, 1, 15);
+        final DateTime targetDate = buildDateTime(2011, 2, 15);
 
         calculateNumberOfBillingCycles(startDate, endDate, targetDate, 15);
     }
 
     @Test(expectedExceptions = InvalidDateSequenceException.class)
     public void testEndStartTarget() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 1, 30);
-        DateTime endDate = buildDateTime(2011, 1, 15);
-        DateTime targetDate = buildDateTime(2011, 2, 15);
+        final DateTime startDate = buildDateTime(2011, 1, 30);
+        final DateTime endDate = buildDateTime(2011, 1, 15);
+        final DateTime targetDate = buildDateTime(2011, 2, 15);
 
         calculateNumberOfBillingCycles(startDate, endDate, targetDate, 15);
     }
 
     @Test(expectedExceptions = InvalidDateSequenceException.class)
     public void testTargetStart() throws InvalidDateSequenceException {
-        DateTime startDate = buildDateTime(2011, 4, 30);
-        DateTime targetDate = buildDateTime(2011, 2, 15);
+        final DateTime startDate = buildDateTime(2011, 4, 30);
+        final DateTime targetDate = buildDateTime(2011, 2, 15);
 
         calculateNumberOfBillingCycles(startDate, targetDate, 15);
     }
 
     @Test
     public void testBigDecimalTruncation() {
-        BigDecimal value = new BigDecimal("1.3349573498567");
-        BigDecimal truncated = value.setScale(0, BigDecimal.ROUND_DOWN).setScale(NUMBER_OF_DECIMALS);
+        final BigDecimal value = new BigDecimal("1.3349573498567");
+        final BigDecimal truncated = value.setScale(0, BigDecimal.ROUND_DOWN).setScale(NUMBER_OF_DECIMALS);
 
         assertEquals(truncated, ONE);
     }
diff --git a/invoice/src/test/java/com/ning/billing/invoice/tests/InternationalPriceMock.java b/invoice/src/test/java/com/ning/billing/invoice/tests/InternationalPriceMock.java
index ab11024..4e7467f 100644
--- a/invoice/src/test/java/com/ning/billing/invoice/tests/InternationalPriceMock.java
+++ b/invoice/src/test/java/com/ning/billing/invoice/tests/InternationalPriceMock.java
@@ -16,18 +16,18 @@
 
 package com.ning.billing.invoice.tests;
 
-import static org.testng.Assert.fail;
-
 import java.math.BigDecimal;
 
 import com.ning.billing.catalog.api.Currency;
 import com.ning.billing.catalog.api.InternationalPrice;
 import com.ning.billing.catalog.api.Price;
 
+import static org.testng.Assert.fail;
+
 public class InternationalPriceMock implements InternationalPrice {
     private final BigDecimal rate;
 
-    public InternationalPriceMock(BigDecimal rate) {
+    public InternationalPriceMock(final BigDecimal rate) {
         this.rate = rate;
     }
 
@@ -39,13 +39,13 @@ public class InternationalPriceMock implements InternationalPrice {
     }
 
     @Override
-    public BigDecimal getPrice(Currency currency) {
+    public BigDecimal getPrice(final Currency currency) {
         return rate;
     }
 
-	@Override
-	public boolean isZero() {
-		return rate.compareTo(BigDecimal.ZERO) == 0;
-	}
+    @Override
+    public boolean isZero() {
+        return rate.compareTo(BigDecimal.ZERO) == 0;
+    }
 
 }
diff --git a/invoice/src/test/java/com/ning/billing/invoice/tests/InvoicingTestBase.java b/invoice/src/test/java/com/ning/billing/invoice/tests/InvoicingTestBase.java
index e3147d5..1b4efdd 100644
--- a/invoice/src/test/java/com/ning/billing/invoice/tests/InvoicingTestBase.java
+++ b/invoice/src/test/java/com/ning/billing/invoice/tests/InvoicingTestBase.java
@@ -16,8 +16,12 @@
 
 package com.ning.billing.invoice.tests;
 
+import javax.annotation.Nullable;
 import java.math.BigDecimal;
 
+import org.joda.time.DateTime;
+import org.joda.time.DateTimeZone;
+
 import com.ning.billing.account.api.Account;
 import com.ning.billing.catalog.api.BillingPeriod;
 import com.ning.billing.catalog.api.Currency;
@@ -27,13 +31,8 @@ import com.ning.billing.entitlement.api.SubscriptionTransitionType;
 import com.ning.billing.entitlement.api.billing.BillingEvent;
 import com.ning.billing.entitlement.api.billing.BillingModeType;
 import com.ning.billing.entitlement.api.user.Subscription;
-import org.joda.time.DateTime;
-import org.joda.time.DateTimeZone;
-
 import com.ning.billing.invoice.model.InvoicingConfiguration;
 
-import javax.annotation.Nullable;
-
 public abstract class InvoicingTestBase {
     protected static final int NUMBER_OF_DECIMALS = InvoicingConfiguration.getNumberOfDecimals();
     protected static final int ROUNDING_METHOD = InvoicingConfiguration.getRoundingMode();
@@ -81,7 +80,7 @@ public abstract class InvoicingTestBase {
     protected static final BigDecimal THREE_HUNDRED_AND_SIXTY_FIVE = new BigDecimal("365.0").setScale(NUMBER_OF_DECIMALS);
     protected static final BigDecimal THREE_HUNDRED_AND_SIXTY_SIX = new BigDecimal("366.0").setScale(NUMBER_OF_DECIMALS);
 
-    protected DateTime buildDateTime(int year, int month, int day) {
+    protected DateTime buildDateTime(final int year, final int month, final int day) {
         return new DateTime(year, month, day, 0, 0, 0, 0);
     }
 
@@ -98,68 +97,83 @@ public abstract class InvoicingTestBase {
             public Account getAccount() {
                 return account;
             }
+
             @Override
             public int getBillCycleDay() {
                 return billCycleDay;
             }
+
             @Override
             public Subscription getSubscription() {
                 return subscription;
             }
+
             @Override
             public DateTime getEffectiveDate() {
                 return effectiveDate;
             }
+
             @Override
             public PlanPhase getPlanPhase() {
                 return planPhase;
             }
+
             @Override
             public Plan getPlan() {
                 return plan;
             }
+
             @Override
             public BillingPeriod getBillingPeriod() {
                 return billingPeriod;
             }
+
             @Override
             public BillingModeType getBillingMode() {
                 return billingModeType;
             }
+
             @Override
             public String getDescription() {
                 return description;
             }
+
             @Override
             public BigDecimal getFixedPrice() {
                 return fixedPrice;
             }
+
             @Override
             public BigDecimal getRecurringPrice() {
                 return recurringPrice;
             }
+
             @Override
             public Currency getCurrency() {
                 return currency;
             }
+
             @Override
             public SubscriptionTransitionType getTransitionType() {
                 return type;
             }
+
             @Override
             public Long getTotalOrdering() {
                 return totalOrdering;
             }
+
             @Override
             public DateTimeZone getTimeZone() {
                 return DateTimeZone.UTC;
             }
+
             @Override
-            public int compareTo(BillingEvent e1) {
+            public int compareTo(final BillingEvent e1) {
                 if (!getSubscription().getId().equals(e1.getSubscription().getId())) { // First order by subscription
                     return getSubscription().getId().compareTo(e1.getSubscription().getId());
                 } else { // subscriptions are the same
-                    if (! getEffectiveDate().equals(e1.getEffectiveDate())) { // Secondly order by date
+                    if (!getEffectiveDate().equals(e1.getEffectiveDate())) { // Secondly order by date
                         return getEffectiveDate().compareTo(e1.getEffectiveDate());
                     } else { // dates and subscriptions are the same
                         return getTotalOrdering().compareTo(e1.getTotalOrdering());
diff --git a/invoice/src/test/java/com/ning/billing/invoice/tests/ProRationTestBase.java b/invoice/src/test/java/com/ning/billing/invoice/tests/ProRationTestBase.java
index 1cd4e2f..578b199 100644
--- a/invoice/src/test/java/com/ning/billing/invoice/tests/ProRationTestBase.java
+++ b/invoice/src/test/java/com/ning/billing/invoice/tests/ProRationTestBase.java
@@ -16,9 +16,6 @@
 
 package com.ning.billing.invoice.tests;
 
-import static org.testng.Assert.assertEquals;
-import static org.testng.Assert.fail;
-
 import java.math.BigDecimal;
 import java.util.List;
 
@@ -29,13 +26,17 @@ import com.ning.billing.invoice.model.BillingMode;
 import com.ning.billing.invoice.model.InvalidDateSequenceException;
 import com.ning.billing.invoice.model.RecurringInvoiceItemData;
 
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.fail;
+
 public abstract class ProRationTestBase extends InvoicingTestBase {
     protected abstract BillingMode getBillingMode();
+
     protected abstract BillingPeriod getBillingPeriod();
 
-    protected void testCalculateNumberOfBillingCycles(DateTime startDate, DateTime targetDate, int billingCycleDay, BigDecimal expectedValue) throws InvalidDateSequenceException {
+    protected void testCalculateNumberOfBillingCycles(final DateTime startDate, final DateTime targetDate, final int billingCycleDay, final BigDecimal expectedValue) throws InvalidDateSequenceException {
         try {
-            BigDecimal numberOfBillingCycles;
+            final BigDecimal numberOfBillingCycles;
             numberOfBillingCycles = calculateNumberOfBillingCycles(startDate, targetDate, billingCycleDay);
 
             assertEquals(numberOfBillingCycles.compareTo(expectedValue), 0, "Actual: " + numberOfBillingCycles.toString() + "; expected: " + expectedValue.toString());
@@ -46,9 +47,9 @@ public abstract class ProRationTestBase extends InvoicingTestBase {
         }
     }
 
-    protected void testCalculateNumberOfBillingCycles(DateTime startDate, DateTime endDate, DateTime targetDate, int billingCycleDay, BigDecimal expectedValue) throws InvalidDateSequenceException {
+    protected void testCalculateNumberOfBillingCycles(final DateTime startDate, final DateTime endDate, final DateTime targetDate, final int billingCycleDay, final BigDecimal expectedValue) throws InvalidDateSequenceException {
         try {
-            BigDecimal numberOfBillingCycles;
+            final BigDecimal numberOfBillingCycles;
             numberOfBillingCycles = calculateNumberOfBillingCycles(startDate, endDate, targetDate, billingCycleDay);
 
             assertEquals(numberOfBillingCycles.compareTo(expectedValue), 0);
@@ -59,25 +60,25 @@ public abstract class ProRationTestBase extends InvoicingTestBase {
         }
     }
 
-    protected BigDecimal calculateNumberOfBillingCycles(DateTime startDate, DateTime endDate, DateTime targetDate, int billingCycleDay) throws InvalidDateSequenceException {
-        List<RecurringInvoiceItemData> items = getBillingMode().calculateInvoiceItemData(startDate, endDate, targetDate, billingCycleDay, getBillingPeriod());
+    protected BigDecimal calculateNumberOfBillingCycles(final DateTime startDate, final DateTime endDate, final DateTime targetDate, final int billingCycleDay) throws InvalidDateSequenceException {
+        final List<RecurringInvoiceItemData> items = getBillingMode().calculateInvoiceItemData(startDate, endDate, targetDate, billingCycleDay, getBillingPeriod());
 
         BigDecimal numberOfBillingCycles = ZERO;
-        for (RecurringInvoiceItemData item : items) {
+        for (final RecurringInvoiceItemData item : items) {
             numberOfBillingCycles = numberOfBillingCycles.add(item.getNumberOfCycles());
         }
 
         return numberOfBillingCycles.setScale(NUMBER_OF_DECIMALS, ROUNDING_METHOD);
     }
 
-    protected BigDecimal calculateNumberOfBillingCycles(DateTime startDate, DateTime targetDate, int billingCycleDay) throws InvalidDateSequenceException {
-        List<RecurringInvoiceItemData> items = getBillingMode().calculateInvoiceItemData(startDate, targetDate, billingCycleDay, getBillingPeriod());
+    protected BigDecimal calculateNumberOfBillingCycles(final DateTime startDate, final DateTime targetDate, final int billingCycleDay) throws InvalidDateSequenceException {
+        final List<RecurringInvoiceItemData> items = getBillingMode().calculateInvoiceItemData(startDate, targetDate, billingCycleDay, getBillingPeriod());
 
         BigDecimal numberOfBillingCycles = ZERO;
-        for (RecurringInvoiceItemData item : items) {
+        for (final RecurringInvoiceItemData item : items) {
             numberOfBillingCycles = numberOfBillingCycles.add(item.getNumberOfCycles());
         }
 
         return numberOfBillingCycles.setScale(NUMBER_OF_DECIMALS, ROUNDING_METHOD);
     }
-}
\ No newline at end of file
+}