anchor.diff:  
   == Test the changes
   
  -- Access allowed
  +Access allowed::
   
   Open your browser again to http://localhost:8080/greeting and introduce `scott` and `jb0ss` in the dialog displayed.
  -
  ++
   The word `hello` should be displayed.
   
  -- Access forbidden
  +Access forbidden::
   
   Open your browser again to http://localhost:8080/greeting and let empty the dialog displayed.
  -
  ++
   The result should be:
  ++
  +[source]
   ----
   Access to localhost was denied
   You don't have authorization to view this page.
  
positive.code:     public final String ADMIN = "admin";
      public final String USER = "user";
  }
  
  ----
  
  * hasAnyRole
  
  In the same fashion as `hasRole`, users can use `hasAnyRole`  to check if the logged in user has any of the specified roles. Some examples are:
  `@PreAuthorize("hasAnyRole('admin')")`, `@PreAuthorize("hasAnyRole(@roles.USER, 'view')")`
  
  permitAll:: Adding `@PreAuthorize("permitAll()")` to a method will ensure that that method is accessible by any user (including anonymous users). Adding it to a class will ensure that all public methods
  +of the class that are not annotated with any other Spring Security annotation will be accessible.
  
  denyAll:: Adding `@PreAuthorize("denyAll()")` to a method will ensure that that method is not accessible by any user. Adding it to a class will ensure that all public methods
  +of the class that are not annotated with any other Spring Security annotation will not be accessible to any user.
  
  isAnonymous:: When annotating a bean method with `@PreAuthorize("isAnonymous()")` the method will only be accessible if the current user is anonymous - i.e. a non logged in user.
  
  isAuthenticated:: When annotating a bean method with `@PreAuthorize("isAuthenticated()")` the method will only be accessible if the current user is a logged in user. Essentially the
  +method is only unavailable for anonymous users.
  
  #paramName == authentication.principal.username:: This syntax allows users to check if a parameter (or a field of the parameter) of the secured method is equal to the logged in username.
  +Examples of this use case are:
  
  [source,java]
  ----
  public class Person {
  
negative.code:     }
  }
  ----
  <1> `doSomething` can be executed if the current logged in user is the same as the `username` method parameter
  <2> `doSomethingElse` can be executed if the current logged in user is the same as the `name` field of `person` method parameter
  +
  TIP: the use of `authentication.` is optional, so using `principal.username` has the same result.
  
  #paramName != authentication.principal.username:: This is similar to the previous expression with the difference being that the method parameter must be different than the logged in username.
  
  @beanName.method():: This syntax allows developers to specify that the execution of method of a specific bean will determine if the current user can access the secured method.
  +
  The syntax is best explained with an example.
  Let's assume that a `MyComponent` bean has been created like so:
  +
  [source,java]
  ----
  @Component
  