docs: @Override
      public void handle() throws FacesException
      {
          if (unhandled != null && !unhandled.isEmpty())
          {
              if (handled == null)
              {
                  handled = new LinkedList<ExceptionQueuedEvent>();
              }
              
              List<Throwable> throwableList = new ArrayList<Throwable>();
              FacesContext facesContext = null;
              
              do
              {
                  // For each ExceptionEvent in the list
                  
                  // get the event to handle
                  ExceptionQueuedEvent event = unhandled.peek();
                  try
                  {
                      // call its getContext() method
                      ExceptionQueuedEventContext context = event.getContext();
  
                      if (facesContext == null)
                      {
                          facesContext = event.getContext().getContext();
                      }
                      
                      // and call getException() on the returned result
                      Throwable exception = context.getException();
                      
                      // Upon encountering the first such Exception that is not an instance of
                      // javax.faces.event.AbortProcessingException
                      if (!shouldSkip(exception))
                      {
                          // set handledAndThrown so that getHandledExceptionQueuedEvent() returns this event
                          handledAndThrown = event;
                          
                          Throwable rootCause = getRootCause(exception);
                          
                          throwableList.add(rootCause == null ? exception : rootCause);
                          
                          //break;
                      }
                      else
                      {
                          // Testing mojarra it logs a message and the exception
                          // however, this behaviour is not mentioned in the spec
                          log.log(Level.SEVERE, exception.getClass().getName() + " occured while processing " +
                                  (context.inBeforePhase() ? "beforePhase() of " : 
                                          (context.inAfterPhase() ? "afterPhase() of " : "")) + 
                                  "phase " + context.getPhaseId() + ": " +
                                  "UIComponent-ClientId=" + 
                                  (context.getComponent() != null ? 
                                          context.getComponent().getClientId(context.getContext()) : "") + ", " +
                                  "Message=" + exception.getMessage());
                          
                          log.log(Level.SEVERE, exception.getMessage(), exception);
                      }
                  }
                  finally
                  {
                      // if we will throw the Exception or if we just logged it,
                      // we handled it in either way --> add to handled
                      handled.add(event);
                      unhandled.remove(event);
                  }
              } while (!unhandled.isEmpty());
  
              if (!throwableList.isEmpty())
              {
                  PartialResponseWriter partialWriter = null;
                  boolean responseComplete = false;
  
                  //Retrieve the partial writer used to render the exception
                  if (facesContext == null)
                  {
                      facesContext = FacesContext.getCurrentInstance();
                  }
                  
                  facesContext = (facesContext == null) ? FacesContext.getCurrentInstance() : facesContext;
                  ExternalContext externalContext = facesContext.getExternalContext();
                  
                  //Clean up the response if by some reason something has been written before.
                  if (!facesContext.getExternalContext().isResponseCommitted())
                  {
                      facesContext.getExternalContext().responseReset();
                  }
                  
                  PartialViewContext partialViewContext = facesContext.getPartialViewContext();
                  partialWriter = partialViewContext.getPartialResponseWriter();
  
                  // ajax request --> xml error page 
                  externalContext.setResponseContentType("text/xml");
                  externalContext.setResponseCharacterEncoding("UTF-8");
                  externalContext.addResponseHeader("Cache-control", "no-cache");
                  
                  try
                  {
                      partialWriter.startDocument();
      
                      for (Throwable t : throwableList)
                      {
                          renderAjaxError(partialWriter, t);
                      }
                      
                      responseComplete = true;
                  }
                  catch (IOException e)
                  {
                      if (log.isLoggable(Level.SEVERE))
                      {
                          log.log(Level.SEVERE, "Cannot render exception on ajax request", e);
                      }
                  }
                  finally
                  {
                      if (responseComplete)
                      {
                          try
                          {
                              partialWriter.endDocument();
                              facesContext.responseComplete();
                          }
                          catch (IOException e1)
                          {
                              if (log.isLoggable(Level.SEVERE))
                              {
                                  log.log(Level.SEVERE, "Cannot render exception on ajax request", e1);
                              }
                          }
                      }
                  }
              }
          }
      }