View difference between Paste ID: fBNJC7uV and wi1Q1Ri6

 package com.deious.service.account;
 
 import com.deious.domain.account.Account;
 import com.deious.repository.account.AccountRepository;
 import com.prociss.paragon.testing.specification.AfterInvocation;
 import com.prociss.paragon.testing.specification.BeforeInvocation;
 import com.prociss.paragon.testing.specification.InvalidInvocation;
 import com.prociss.paragon.testing.specification.SpecificationCallback;
 import com.prociss.paragon.testing.specification.ValidInvocation;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.ArgumentCaptor;
 import org.mockito.Mock;
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.runners.MockitoJUnitRunner;
 import org.mockito.stubbing.Answer;
 
 import static com.prociss.paragon.testing.specification.Specifications.emailSpec;
 import static com.prociss.paragon.testing.specification.ValidationVerifier.specification;
 import static org.fest.assertions.Assertions.assertThat;
 import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.reset;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyZeroInteractions;
 import static org.mockito.Mockito.when;
 
 @RunWith(MockitoJUnitRunner.class)
 public class AccountServiceTest {
 
     @Mock
     private AccountRepository accountRepository;
 
     private AccountService accountService;
 
     @Before
     public void setupService() {
         this.accountService = new AccountService(accountRepository);
     }
 
     @Test
     public void verifyCreateAccountParameterValidation() throws Throwable {
 
         specification(
                 accountService,
                 "createAccount",
                 Account.class,
                 new CreateAccountCallback(),
                 emailSpec().notNull());
 
     }
 
     public class CreateAccountCallback implements SpecificationCallback {
 
         @BeforeInvocation
         public void setupMock() {
 
-            when(accountRepository.save(any(Account.class))).thenAnswer(new Answer<Object>() {
+            when(accountRepository.save(any(Account.class))).thenAnswer(new Answer<Account>() {
                 @Override
-                public Object answer(InvocationOnMock invocation) throws Throwable {
+                public Account answer(InvocationOnMock invocation) throws Throwable {
                     Account account = (Account) invocation.getArguments()[0];
                     return new Account(account.getEmail());
                 }
             });
         }
 
         @ValidInvocation
         public void validEmail(final String validEmail, final Account returnedAccount) {
 
             ArgumentCaptor<Account> accountCaptor = ArgumentCaptor.forClass(Account.class);
             verify(accountRepository).save(accountCaptor.capture());
 
             Account savedAccount = accountCaptor.getValue();
 
             assertThat(savedAccount.getEmail()).isEqualTo(validEmail);
             assertThat(returnedAccount.getEmail()).isEqualTo(validEmail);
         }
 
         @InvalidInvocation
         public void invalidEmail(final String invalidEmail) {
 
             verifyZeroInteractions(accountRepository);
 
         }
 
         @AfterInvocation
         public void resetMock() {
 
             reset(accountRepository);
         }
 
 
     }
 
 }