Standardize the name of the exception variables

javiereguiluz · fabpot · commit 36cde602d02d · 2015-06-15T18:26:34.000+02:00
diff --git a/Acl/Dbal/AclProvider.php b/Acl/Dbal/AclProvider.php
@@ -177,13 +177,13 @@ public function findAcls(array $oids, array $sids = array())
             if ($currentBatchesCount > 0 && (self::MAX_BATCH_SIZE === $currentBatchesCount || ($i + 1) === $c)) {
                 try {
                     $loadedBatch = $this->lookupObjectIdentities($currentBatch, $sids, $oidLookup);
-                } catch (AclNotFoundException $aclNotFoundexception) {
+                } catch (AclNotFoundException $e) {
                     if ($result->count()) {
                         $partialResultException = new NotAllAclsFoundException('The provider could not find ACLs for all object identities.');
                         $partialResultException->setPartialResult($result);
                         throw $partialResultException;
                     } else {
-                        throw $aclNotFoundexception;
+                        throw $e;
                     }
                 }
                 foreach ($loadedBatch as $loadedOid) {
diff --git a/Acl/Dbal/MutableAclProvider.php b/Acl/Dbal/MutableAclProvider.php
@@ -62,10 +62,10 @@ public function createAcl(ObjectIdentityInterface $oid)
             $this->connection->executeQuery($this->getInsertObjectIdentityRelationSql($pk, $pk));
 
             $this->connection->commit();
-        } catch (\Exception $failed) {
+        } catch (\Exception $e) {
             $this->connection->rollBack();
 
-            throw $failed;
+            throw $e;
         }
 
         // re-read the ACL from the database to ensure proper caching, etc.
@@ -90,10 +90,10 @@ public function deleteAcl(ObjectIdentityInterface $oid)
             $this->deleteObjectIdentity($oidPK);
 
             $this->connection->commit();
-        } catch (\Exception $failed) {
+        } catch (\Exception $e) {
             $this->connection->rollBack();
 
-            throw $failed;
+            throw $e;
         }
 
         // evict the ACL from the in-memory identity map
@@ -324,10 +324,10 @@ public function updateAcl(MutableAclInterface $acl)
             }
 
             $this->connection->commit();
-        } catch (\Exception $failed) {
+        } catch (\Exception $e) {
             $this->connection->rollBack();
 
-            throw $failed;
+            throw $e;
         }
 
         $this->propertyChanges->offsetSet($acl, array());
diff --git a/Acl/Domain/ObjectIdentity.php b/Acl/Domain/ObjectIdentity.php
@@ -68,8 +68,8 @@ public static function fromDomainObject($domainObject)
             } elseif (method_exists($domainObject, 'getId')) {
                 return new self((string) $domainObject->getId(), ClassUtils::getRealClass($domainObject));
             }
-        } catch (\InvalidArgumentException $invalid) {
-            throw new InvalidDomainObjectException($invalid->getMessage(), 0, $invalid);
+        } catch (\InvalidArgumentException $e) {
+            throw new InvalidDomainObjectException($e->getMessage(), 0, $e);
         }
 
         throw new InvalidDomainObjectException('$domainObject must either implement the DomainObjectInterface, or have a method named "getId".');
diff --git a/Acl/Domain/ObjectIdentityRetrievalStrategy.php b/Acl/Domain/ObjectIdentityRetrievalStrategy.php
@@ -28,7 +28,7 @@ public function getObjectIdentity($domainObject)
     {
         try {
             return ObjectIdentity::fromDomainObject($domainObject);
-        } catch (InvalidDomainObjectException $failed) {
+        } catch (InvalidDomainObjectException $e) {
             return;
         }
     }
diff --git a/Acl/Domain/PermissionGrantingStrategy.php b/Acl/Domain/PermissionGrantingStrategy.php
@@ -55,21 +55,21 @@ public function isGranted(AclInterface $acl, array $masks, array $sids, $adminis
                 }
 
                 return $this->hasSufficientPermissions($acl, $aces, $masks, $sids, $administrativeMode);
-            } catch (NoAceFoundException $noObjectAce) {
+            } catch (NoAceFoundException $e) {
                 $aces = $acl->getClassAces();
 
                 if (!$aces) {
-                    throw $noObjectAce;
+                    throw $e;
                 }
 
                 return $this->hasSufficientPermissions($acl, $aces, $masks, $sids, $administrativeMode);
             }
-        } catch (NoAceFoundException $noClassAce) {
+        } catch (NoAceFoundException $e) {
             if ($acl->isEntriesInheriting() && null !== $parentAcl = $acl->getParentAcl()) {
                 return $parentAcl->isGranted($masks, $sids, $administrativeMode);
             }
 
-            throw $noClassAce;
+            throw $e;
         }
     }
 
@@ -86,20 +86,20 @@ public function isFieldGranted(AclInterface $acl, $field, array $masks, array $s
                 }
 
                 return $this->hasSufficientPermissions($acl, $aces, $masks, $sids, $administrativeMode);
-            } catch (NoAceFoundException $noObjectAces) {
+            } catch (NoAceFoundException $e) {
                 $aces = $acl->getClassFieldAces($field);
                 if (!$aces) {
-                    throw $noObjectAces;
+                    throw $e;
                 }
 
                 return $this->hasSufficientPermissions($acl, $aces, $masks, $sids, $administrativeMode);
             }
-        } catch (NoAceFoundException $noClassAces) {
+        } catch (NoAceFoundException $e) {
             if ($acl->isEntriesInheriting() && null !== $parentAcl = $acl->getParentAcl()) {
                 return $parentAcl->isFieldGranted($field, $masks, $sids, $administrativeMode);
             }
 
-            throw $noClassAces;
+            throw $e;
         }
     }
 
diff --git a/Acl/Domain/SecurityIdentityRetrievalStrategy.php b/Acl/Domain/SecurityIdentityRetrievalStrategy.php
@@ -51,7 +51,7 @@ public function getSecurityIdentities(TokenInterface $token)
         if (!$token instanceof AnonymousToken) {
             try {
                 $sids[] = UserSecurityIdentity::fromToken($token);
-            } catch (\InvalidArgumentException $invalid) {
+            } catch (\InvalidArgumentException $e) {
                 // ignore, user has no user security identity
             }
         }
diff --git a/Acl/Permission/MaskBuilder.php b/Acl/Permission/MaskBuilder.php
@@ -132,7 +132,7 @@ public function getPattern()
             if ('1' === $bitmask[$i]) {
                 try {
                     $pattern[$i] = self::getCode(1 << ($length - $i - 1));
-                } catch (\Exception $notPredefined) {
+                } catch (\Exception $e) {
                     $pattern[$i] = self::ON;
                 }
             }
diff --git a/Acl/Voter/AclVoter.php b/Acl/Voter/AclVoter.php
@@ -113,13 +113,13 @@ public function vote(TokenInterface $token, $object, array $attributes)
                 }
 
                 return self::ACCESS_DENIED;
-            } catch (AclNotFoundException $noAcl) {
+            } catch (AclNotFoundException $e) {
                 if (null !== $this->logger) {
                     $this->logger->debug('No ACL found for the object identity. Voting to deny access.');
                 }
 
                 return self::ACCESS_DENIED;
-            } catch (NoAceFoundException $noAce) {
+            } catch (NoAceFoundException $e) {
                 if (null !== $this->logger) {
                     $this->logger->debug('ACL found, no ACE applicable. Voting to deny access.');
                 }
diff --git a/Core/Authentication/Provider/DaoAuthenticationProvider.php b/Core/Authentication/Provider/DaoAuthenticationProvider.php
@@ -87,13 +87,13 @@ protected function retrieveUser($username, UsernamePasswordToken $token)
             }
 
             return $user;
-        } catch (UsernameNotFoundException $notFound) {
-            $notFound->setUsername($username);
-            throw $notFound;
-        } catch (\Exception $repositoryProblem) {
-            $ex = new AuthenticationServiceException($repositoryProblem->getMessage(), 0, $repositoryProblem);
-            $ex->setToken($token);
-            throw $ex;
+        } catch (UsernameNotFoundException $e) {
+            $e->setUsername($username);
+            throw $e;
+        } catch (\Exception $e) {
+            $e = new AuthenticationServiceException($e->getMessage(), 0, $e);
+            $e->setToken($token);
+            throw $e;
         }
     }
 }
diff --git a/Core/Authentication/Provider/UserAuthenticationProvider.php b/Core/Authentication/Provider/UserAuthenticationProvider.php
@@ -68,13 +68,13 @@ public function authenticate(TokenInterface $token)
 
         try {
             $user = $this->retrieveUser($username, $token);
-        } catch (UsernameNotFoundException $notFound) {
+        } catch (UsernameNotFoundException $e) {
             if ($this->hideUserNotFoundExceptions) {
-                throw new BadCredentialsException('Bad credentials', 0, $notFound);
+                throw new BadCredentialsException('Bad credentials', 0, $e);
             }
-            $notFound->setUsername($username);
+            $e->setUsername($username);
 
-            throw $notFound;
+            throw $e;
         }
 
         if (!$user instanceof UserInterface) {
diff --git a/Core/User/ChainUserProvider.php b/Core/User/ChainUserProvider.php
@@ -47,7 +47,7 @@ public function loadUserByUsername($username)
         foreach ($this->providers as $provider) {
             try {
                 return $provider->loadUserByUsername($username);
-            } catch (UsernameNotFoundException $notFound) {
+            } catch (UsernameNotFoundException $e) {
                 // try next one
             }
         }
@@ -67,18 +67,18 @@ public function refreshUser(UserInterface $user)
         foreach ($this->providers as $provider) {
             try {
                 return $provider->refreshUser($user);
-            } catch (UnsupportedUserException $unsupported) {
+            } catch (UnsupportedUserException $e) {
                 // try next one
-            } catch (UsernameNotFoundException $notFound) {
+            } catch (UsernameNotFoundException $e) {
                 $supportedUserFound = true;
                 // try next one
             }
         }
 
         if ($supportedUserFound) {
-            $ex = new UsernameNotFoundException(sprintf('There is no user with name "%s".', $user->getUsername()));
-            $ex->setUsername($user->getUsername());
-            throw $ex;
+            $e = new UsernameNotFoundException(sprintf('There is no user with name "%s".', $user->getUsername()));
+            $e->setUsername($user->getUsername());
+            throw $e;
         } else {
             throw new UnsupportedUserException(sprintf('The account "%s" is not supported.', get_class($user)));
         }
diff --git a/Http/Firewall/AbstractPreAuthenticatedListener.php b/Http/Firewall/AbstractPreAuthenticatedListener.php
@@ -62,8 +62,8 @@ final public function handle(GetResponseEvent $event)
 
         try {
             list($user, $credentials) = $this->getPreAuthenticatedData($request);
-        } catch (BadCredentialsException $exception) {
-            $this->clearToken($exception);
+        } catch (BadCredentialsException $e) {
+            $this->clearToken($e);
 
             return;
         }
@@ -90,8 +90,8 @@ final public function handle(GetResponseEvent $event)
                 $loginEvent = new InteractiveLoginEvent($request, $token);
                 $this->dispatcher->dispatch(SecurityEvents::INTERACTIVE_LOGIN, $loginEvent);
             }
-        } catch (AuthenticationException $failed) {
-            $this->clearToken($failed);
+        } catch (AuthenticationException $e) {
+            $this->clearToken($e);
         }
     }
 
diff --git a/Http/Firewall/BasicAuthenticationListener.php b/Http/Firewall/BasicAuthenticationListener.php
@@ -73,21 +73,21 @@ public function handle(GetResponseEvent $event)
         try {
             $token = $this->authenticationManager->authenticate(new UsernamePasswordToken($username, $request->headers->get('PHP_AUTH_PW'), $this->providerKey));
             $this->securityContext->setToken($token);
-        } catch (AuthenticationException $failed) {
+        } catch (AuthenticationException $e) {
             $token = $this->securityContext->getToken();
             if ($token instanceof UsernamePasswordToken && $this->providerKey === $token->getProviderKey()) {
                 $this->securityContext->setToken(null);
             }
 
             if (null !== $this->logger) {
-                $this->logger->info(sprintf('Authentication request failed for user "%s": %s', $username, $failed->getMessage()));
+                $this->logger->info(sprintf('Authentication request failed for user "%s": %s', $username, $e->getMessage()));
             }
 
             if ($this->ignoreFailure) {
                 return;
             }
 
-            $event->setResponse($this->authenticationEntryPoint->start($request, $failed));
+            $event->setResponse($this->authenticationEntryPoint->start($request, $e));
         }
     }
 }
diff --git a/Http/Firewall/ContextListener.php b/Http/Firewall/ContextListener.php
@@ -167,11 +167,11 @@ private function refreshUser(TokenInterface $token)
                 }
 
                 return $token;
-            } catch (UnsupportedUserException $unsupported) {
+            } catch (UnsupportedUserException $e) {
                 // let's try the next user provider
-            } catch (UsernameNotFoundException $notFound) {
+            } catch (UsernameNotFoundException $e) {
                 if (null !== $this->logger) {
-                    $this->logger->warning(sprintf('Username "%s" could not be found.', $notFound->getUsername()));
+                    $this->logger->warning(sprintf('Username "%s" could not be found.', $e->getUsername()));
                 }
 
                 return;
diff --git a/Http/Firewall/DigestAuthenticationListener.php b/Http/Firewall/DigestAuthenticationListener.php
@@ -93,7 +93,7 @@ public function handle(GetResponseEvent $event)
             }
 
             $serverDigestMd5 = $digestAuth->calculateServerDigest($user->getPassword(), $request->getMethod());
-        } catch (UsernameNotFoundException $notFound) {
+        } catch (UsernameNotFoundException $e) {
             $this->fail($event, $request, new BadCredentialsException(sprintf('Username %s not found.', $digestAuth->getUsername())));
 
             return;
diff --git a/Http/Firewall/RememberMeListener.php b/Http/Firewall/RememberMeListener.php
@@ -80,12 +80,12 @@ public function handle(GetResponseEvent $event)
             if (null !== $this->logger) {
                 $this->logger->debug('SecurityContext populated with remember-me token.');
             }
-        } catch (AuthenticationException $failed) {
+        } catch (AuthenticationException $e) {
             if (null !== $this->logger) {
                 $this->logger->warning(
                     'SecurityContext not populated with remember-me token as the'
                    .' AuthenticationManager rejected the AuthenticationToken returned'
-                   .' by the RememberMeServices: '.$failed->getMessage()
+                   .' by the RememberMeServices: '.$e->getMessage()
                 );
             }
 
diff --git a/Http/RememberMe/AbstractRememberMeServices.php b/Http/RememberMe/AbstractRememberMeServices.php
@@ -123,21 +123,21 @@ final public function autoLogin(Request $request)
             }
 
             return new RememberMeToken($user, $this->providerKey, $this->key);
-        } catch (CookieTheftException $theft) {
+        } catch (CookieTheftException $e) {
             $this->cancelCookie($request);
 
-            throw $theft;
-        } catch (UsernameNotFoundException $notFound) {
+            throw $e;
+        } catch (UsernameNotFoundException $e) {
             if (null !== $this->logger) {
                 $this->logger->info('User for remember-me cookie not found.');
             }
-        } catch (UnsupportedUserException $unSupported) {
+        } catch (UnsupportedUserException $e) {
             if (null !== $this->logger) {
                 $this->logger->warning('User class for remember-me cookie not supported.');
             }
-        } catch (AuthenticationException $invalid) {
+        } catch (AuthenticationException $e) {
             if (null !== $this->logger) {
-                $this->logger->debug('Remember-Me authentication failed: '.$invalid->getMessage());
+                $this->logger->debug('Remember-Me authentication failed: '.$e->getMessage());
             }
         }
 
diff --git a/Http/RememberMe/TokenBasedRememberMeServices.php b/Http/RememberMe/TokenBasedRememberMeServices.php
@@ -41,12 +41,12 @@ protected function processAutoLoginCookie(array $cookieParts, Request $request)
         }
         try {
             $user = $this->getUserProvider($class)->loadUserByUsername($username);
-        } catch (\Exception $ex) {
-            if (!$ex instanceof AuthenticationException) {
-                $ex = new AuthenticationException($ex->getMessage(), $ex->getCode(), $ex);
+        } catch (\Exception $e) {
+            if (!$e instanceof AuthenticationException) {
+                $e = new AuthenticationException($e->getMessage(), $e->getCode(), $e);
             }
 
-            throw $ex;
+            throw $e;
         }
 
         if (!$user instanceof UserInterface) {
diff --git a/Tests/Acl/Dbal/AclProviderTest.php b/Tests/Acl/Dbal/AclProviderTest.php
@@ -45,11 +45,11 @@ public function testFindAclsThrowsExceptionUnlessAnACLIsFoundForEveryOID()
             $this->getProvider()->findAcls($oids);
 
             $this->fail('Provider did not throw an expected exception.');
-        } catch (\Exception $ex) {
-            $this->assertInstanceOf('Symfony\Component\Security\Acl\Exception\AclNotFoundException', $ex);
-            $this->assertInstanceOf('Symfony\Component\Security\Acl\Exception\NotAllAclsFoundException', $ex);
+        } catch (\Exception $e) {
+            $this->assertInstanceOf('Symfony\Component\Security\Acl\Exception\AclNotFoundException', $e);
+            $this->assertInstanceOf('Symfony\Component\Security\Acl\Exception\NotAllAclsFoundException', $e);
 
-            $partialResult = $ex->getPartialResult();
+            $partialResult = $e->getPartialResult();
             $this->assertTrue($partialResult->contains($oids[0]));
             $this->assertFalse($partialResult->contains($oids[1]));
         }
diff --git a/Tests/Acl/Dbal/MutableAclProviderTest.php b/Tests/Acl/Dbal/MutableAclProviderTest.php
diff --git a/Tests/Acl/Domain/PermissionGrantingStrategyTest.php b/Tests/Acl/Domain/PermissionGrantingStrategyTest.php
diff --git a/Tests/Http/RememberMe/PersistentTokenBasedRememberMeServicesTest.php b/Tests/Http/RememberMe/PersistentTokenBasedRememberMeServicesTest.php

Original file line number	Diff line number	Diff line change
`@@ -68,8 +68,8 @@ public static function fromDomainObject($domainObject)`
`68`	`68`	`} elseif (method_exists($domainObject, 'getId')) {`
`69`	`69`	`return new self((string) $domainObject->getId(), ClassUtils::getRealClass($domainObject));`
`70`	`70`	`}`
`71`		`- } catch (\InvalidArgumentException $invalid) {`
`72`		`- throw new InvalidDomainObjectException($invalid->getMessage(), 0, $invalid);`
	`71`	`+ } catch (\InvalidArgumentException $e) {`
	`72`	`+ throw new InvalidDomainObjectException($e->getMessage(), 0, $e);`
`73`	`73`	`}`
`74`	`74`
`75`	`75`	`throw new InvalidDomainObjectException('$domainObject must either implement the DomainObjectInterface, or have a method named "getId".');`
Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ public function getObjectIdentity($domainObject)`
`28`	`28`	`{`
`29`	`29`	`try {`
`30`	`30`	`return ObjectIdentity::fromDomainObject($domainObject);`
`31`		`- } catch (InvalidDomainObjectException $failed) {`
	`31`	`+ } catch (InvalidDomainObjectException $e) {`
`32`	`32`	`return;`
`33`	`33`	`}`
`34`	`34`	`}`
Original file line number	Diff line number	Diff line change
`@@ -55,21 +55,21 @@ public function isGranted(AclInterface $acl, array $masks, array $sids, $adminis`
`55`	`55`	`}`
`56`	`56`
`57`	`57`	`return $this->hasSufficientPermissions($acl, $aces, $masks, $sids, $administrativeMode);`
`58`		`- } catch (NoAceFoundException $noObjectAce) {`
	`58`	`+ } catch (NoAceFoundException $e) {`
`59`	`59`	`$aces = $acl->getClassAces();`
`60`	`60`
`61`	`61`	`if (!$aces) {`
`62`		`- throw $noObjectAce;`
	`62`	`+ throw $e;`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`return $this->hasSufficientPermissions($acl, $aces, $masks, $sids, $administrativeMode);`
`66`	`66`	`}`
`67`		`- } catch (NoAceFoundException $noClassAce) {`
	`67`	`+ } catch (NoAceFoundException $e) {`
`68`	`68`	`if ($acl->isEntriesInheriting() && null !== $parentAcl = $acl->getParentAcl()) {`
`69`	`69`	`return $parentAcl->isGranted($masks, $sids, $administrativeMode);`
`70`	`70`	`}`
`71`	`71`
`72`		`- throw $noClassAce;`
	`72`	`+ throw $e;`
`73`	`73`	`}`
`74`	`74`	`}`
`75`	`75`
`@@ -86,20 +86,20 @@ public function isFieldGranted(AclInterface $acl, $field, array $masks, array $s`
`86`	`86`	`}`
`87`	`87`
`88`	`88`	`return $this->hasSufficientPermissions($acl, $aces, $masks, $sids, $administrativeMode);`
`89`		`- } catch (NoAceFoundException $noObjectAces) {`
	`89`	`+ } catch (NoAceFoundException $e) {`
`90`	`90`	`$aces = $acl->getClassFieldAces($field);`
`91`	`91`	`if (!$aces) {`
`92`		`- throw $noObjectAces;`
	`92`	`+ throw $e;`
`93`	`93`	`}`
`94`	`94`
`95`	`95`	`return $this->hasSufficientPermissions($acl, $aces, $masks, $sids, $administrativeMode);`
`96`	`96`	`}`
`97`		`- } catch (NoAceFoundException $noClassAces) {`
	`97`	`+ } catch (NoAceFoundException $e) {`
`98`	`98`	`if ($acl->isEntriesInheriting() && null !== $parentAcl = $acl->getParentAcl()) {`
`99`	`99`	`return $parentAcl->isFieldGranted($field, $masks, $sids, $administrativeMode);`
`100`	`100`	`}`
`101`	`101`
`102`		`- throw $noClassAces;`
	`102`	`+ throw $e;`
`103`	`103`	`}`
`104`	`104`	`}`
`105`	`105`
Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ public function getSecurityIdentities(TokenInterface $token)`
`51`	`51`	`if (!$token instanceof AnonymousToken) {`
`52`	`52`	`try {`
`53`	`53`	`$sids[] = UserSecurityIdentity::fromToken($token);`
`54`		`- } catch (\InvalidArgumentException $invalid) {`
	`54`	`+ } catch (\InvalidArgumentException $e) {`
`55`	`55`	`// ignore, user has no user security identity`
`56`	`56`	`}`
`57`	`57`	`}`
Original file line number	Diff line number	Diff line change
`@@ -132,7 +132,7 @@ public function getPattern()`
`132`	`132`	`if ('1' === $bitmask[$i]) {`
`133`	`133`	`try {`
`134`	`134`	`$pattern[$i] = self::getCode(1 << ($length - $i - 1));`
`135`		`- } catch (\Exception $notPredefined) {`
	`135`	`+ } catch (\Exception $e) {`
`136`	`136`	`$pattern[$i] = self::ON;`
`137`	`137`	`}`
`138`	`138`	`}`
Original file line number	Diff line number	Diff line change
`@@ -113,13 +113,13 @@ public function vote(TokenInterface $token, $object, array $attributes)`
`113`	`113`	`}`
`114`	`114`
`115`	`115`	`return self::ACCESS_DENIED;`
`116`		`- } catch (AclNotFoundException $noAcl) {`
	`116`	`+ } catch (AclNotFoundException $e) {`
`117`	`117`	`if (null !== $this->logger) {`
`118`	`118`	`$this->logger->debug('No ACL found for the object identity. Voting to deny access.');`
`119`	`119`	`}`
`120`	`120`
`121`	`121`	`return self::ACCESS_DENIED;`
`122`		`- } catch (NoAceFoundException $noAce) {`
	`122`	`+ } catch (NoAceFoundException $e) {`
`123`	`123`	`if (null !== $this->logger) {`
`124`	`124`	`$this->logger->debug('ACL found, no ACE applicable. Voting to deny access.');`
`125`	`125`	`}`
Original file line number	Diff line number	Diff line change
`@@ -87,13 +87,13 @@ protected function retrieveUser($username, UsernamePasswordToken $token)`
`87`	`87`	`}`
`88`	`88`
`89`	`89`	`return $user;`
`90`		`- } catch (UsernameNotFoundException $notFound) {`
`91`		`- $notFound->setUsername($username);`
`92`		`- throw $notFound;`
`93`		`- } catch (\Exception $repositoryProblem) {`
`94`		`- $ex = new AuthenticationServiceException($repositoryProblem->getMessage(), 0, $repositoryProblem);`
`95`		`- $ex->setToken($token);`
`96`		`- throw $ex;`
	`90`	`+ } catch (UsernameNotFoundException $e) {`
	`91`	`+ $e->setUsername($username);`
	`92`	`+ throw $e;`
	`93`	`+ } catch (\Exception $e) {`
	`94`	`+ $e = new AuthenticationServiceException($e->getMessage(), 0, $e);`
	`95`	`+ $e->setToken($token);`
	`96`	`+ throw $e;`
`97`	`97`	`}`
`98`	`98`	`}`
`99`	`99`	`}`