src/plugins/preflighting.core/src/com/motorolamobility/preflighting/core/verbose/WarningLevelFilter.java - platform/tools/motodev - Gitiles

 /*
  * Copyright (C) 2012 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package com.motorolamobility.preflighting.core.verbose;

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;

 import com.motorolamobility.preflighting.core.i18n.PreflightingCoreNLS;
 import com.motorolamobility.preflighting.core.utils.LimitedList;
 import com.motorolamobility.preflighting.core.validation.ValidationResult;
 import com.motorolamobility.preflighting.core.validation.ValidationResultData;
 import com.motorolamobility.preflighting.core.validation.ValidationResultData.SEVERITY;
 import com.motorolamobility.preflighting.core.verbose.DebugVerboseOutputter.VerboseLevel;

 /**
  * Abstract class responsible for defining warning levels, setting the current warning level,
  * and filtering results and returning appropriate messages based on current warning
  * level set.
  * The warning level will be passed as a parameter to the application, if not,
  * {@link WarningLevelFilter#DEFAULT_WARNING_LEVEL} will be assumed (default warning level).
  */
 public abstract class WarningLevelFilter
 {
     /**
      * The terminator string for the total message.
      */
     private static final String TOTAL_MESSAGE_TERMINATOR = "."; //$NON-NLS-1$

     /**
      * The level separator string for the total message.
      */
     private static final String TOTAL_MESSAGE_LEVEL_SEPARATOR = ", "; //$NON-NLS-1$

     /**
      * Enumeration representing the various warning levels available to the application.
      */
     public enum WarningLevel
     {
         /**
          * Suppress all messages, just return success or failure.
          */
         w0,
         /**
          * Only indicate extremely severe conditions that could cause immediate failure of
          * the application on launch (fatal errors).
          */
         w1,
         /**
          * Indicate improper conditions that will lead to failure or possible problems on
          * different handsets (fatal errors + errors). This is the default warning level.
          */
         w2,
         /**
          * Indicate all improper conditions (fatal errors + errors + warnings).
          */
         w3,
         /**
          * Indicate all improper conditions (fatal errors + errors + warnings) and their
          * potential fixes, if known.
          */
         w4;
     }

     /**
      * The default warning level ({@link WarningLevel#w2}).
      */
     public static WarningLevel DEFAULT_WARNING_LEVEL = WarningLevel.w2;

     /**
      * The current warning level being used.
      */
     private static WarningLevel currentWarningLevel = DEFAULT_WARNING_LEVEL;

     /**
      * Retrieve the current warning level for the application.
      *
      * @return Current warning level.
      */
     public static WarningLevel getCurrentWarningLevel()
     {
         return currentWarningLevel;
     }

     /**
      * Set the current warning level to the given one. If <code>null</code> is
      * passed, the default warning level is used ({@link WarningLevelFilter#DEFAULT_WARNING_LEVEL}).
      *
      * @param warningLevel Warning level to be set.
      */
     public static void setCurrentWarningLevel(WarningLevel warningLevel)
     {
         if (warningLevel != null)
         {
             currentWarningLevel = warningLevel;
         }
         else
         {
             currentWarningLevel = DEFAULT_WARNING_LEVEL;
         }
     }

     /**
      * Return whether quick fix suggestions should be printed
      * (warning level equals {@link WarningLevel#w4}) or not.
      *
      * @return <code>true</code> if quick fix suggestions should be printed,
      * <code>false</code> otherwise.
      */
     public static boolean printQuickFixSuggestions()
     {
         return currentWarningLevel.equals(WarningLevel.w4);
     }

     /**
      * Return whether the severities should be printed or not
      * (severities are not printed if warning level equals {@link WarningLevel#w0}).
      *
      * @return <code>true</code> if severities should be printed,
      * <code>false</code> otherwise.
      */
     public static boolean printSeverity()
     {
         return !currentWarningLevel.equals(WarningLevel.w0);
     }

     /**
      * Filters the given list of validation results so that the returning list
      * of validation results contain only the appropriate issues, according to
      * warning level set.
      *
      * @param validationResultList The list of validation results found by the application
      *
      * @return The filtered validation results list, according to warning level set
      */
     public static List<ValidationResult> filterValidationResultsForCurrentWarningLevel(
             List<ValidationResult> validationResultList)
     {
         if (validationResultList == null)
         {
             throw new IllegalArgumentException("List<ValidationResult> cannot be null"); //$NON-NLS-1$
         }

         List<ValidationResult> filteredValidationResult = new ArrayList<ValidationResult>();

         if (validationResultList.size() > 0)
         {

             DebugVerboseOutputter.printVerboseMessage(
                     PreflightingCoreNLS.WarningLevelFilter_VerboseMessage_FilterningResult,
                     VerboseLevel.v2);

             if (currentWarningLevel.equals(WarningLevel.w0))
             {
                 boolean fatalErrorsDetected = false, potentialErrorsDetected = false;

                 for (ValidationResult result : validationResultList)
                 {
                     for (ValidationResultData resultData : result.getValidationResult())
                     {
                         if (resultData.getSeverity().equals(SEVERITY.FATAL))
                         {
                             fatalErrorsDetected = true;
                             break;
                         }
                         else if (resultData.getSeverity().equals(SEVERITY.ERROR))
                         {
                             potentialErrorsDetected = true;
                         }
                     }
                 }

                 ValidationResult result = null;
                 if (fatalErrorsDetected)
                 {
                     result =
                             createValidationResultObject(
                                     PreflightingCoreNLS.WarningLevelFilter_FatalErrorsMessage,
                                     SEVERITY.FATAL);
                 }
                 else if (potentialErrorsDetected)
                 {
                     result =
                             createValidationResultObject(
                                     PreflightingCoreNLS.WarningLevelFilter_ErrorsMessage,
                                     SEVERITY.ERROR);
                 }
                 else
                 {
                     result =
                             createValidationResultObject(
                                     PreflightingCoreNLS.WarningLevelFilter_NoProblemsMessage,
                                     SEVERITY.OK);
                 }
                 filteredValidationResult.add(result);
             }
             else if (currentWarningLevel.equals(WarningLevel.w1)) // fatal errors only
             {
                 boolean fatalErrorsDetected =
                         filterValidationResultForSeverity(validationResultList,
                                 filteredValidationResult, SEVERITY.FATAL);
                 if (!fatalErrorsDetected)
                 {
                     ValidationResult result =
                             createValidationResultObject(
                                     PreflightingCoreNLS.WarningLevelFilter_NoFatalErrorsMessage,
                                     SEVERITY.OK);
                     filteredValidationResult.add(result);
                 }
             }
             else if (currentWarningLevel.equals(WarningLevel.w2)) // fatal errors and errors only
             {
                 boolean errorsOrFatalErrorsDetected =
                         filterValidationResultForSeverity(validationResultList,
                                 filteredValidationResult, SEVERITY.ERROR);
                 if (!errorsOrFatalErrorsDetected)
                 {
                     ValidationResult result =
                             createValidationResultObject(
                                     PreflightingCoreNLS.WarningLevelFilter_NoFatalNorErrorsMessage,
                                     SEVERITY.OK);
                     filteredValidationResult.add(result);
                 }
             }
             else if (currentWarningLevel.compareTo(WarningLevel.w3) >= 0) // all levels
             {
                 boolean warningsErrorsOrFatalErrorsDetected =
                         filterValidationResultForSeverity(validationResultList,
                                 filteredValidationResult, SEVERITY.WARNING);
                 if (!warningsErrorsOrFatalErrorsDetected)
                 {
                     ValidationResult result =
                             createValidationResultObject(
                                     PreflightingCoreNLS.WarningLevelFilter_NoFatalErrorsNorWarningsMessage,
                                     SEVERITY.OK);
                     filteredValidationResult.add(result);
                 }
             }

             DebugVerboseOutputter.printVerboseMessage(
                     PreflightingCoreNLS.WarningLevelFilter_VerboseMessage_ResultFiltered,
                     VerboseLevel.v2);
         }

         return filteredValidationResult;
     }

     private static ValidationResult createValidationResultObject(String message, SEVERITY severity)
     {
         ValidationResult result = new ValidationResult(null, LimitedList.UNLIMITED);
         ValidationResultData resultData = new ValidationResultData();
         result.addValidationResult(resultData);
         resultData.setSeverity(severity);
         resultData.setIssueDescription(message);
         return result;
     }

     /**
      * Filter the validation results of a particular checker, given the limit severity
      * (which is defined according to warning level set). The result is added to the filtered
      * list also passed.
      * Returns a flag indicating if any issues were found of at least the given severity.
      *
      * @param validationResultList The original list of validation results
      * @param filteredValidationResult The filtered list; entries are added to it by this method
      * @param limitSeverity The limit severity for issues entering the filtered list or not
      *
      * @return <code>true</code> if any issues were found with at least the severity passed
      * (or more severe), <code>false</code> otherwise
      */
     private static boolean filterValidationResultForSeverity(
             List<ValidationResult> validationResultList,
             List<ValidationResult> filteredValidationResult, SEVERITY limitSeverity)
     {
         boolean expectedLevelDetected = false;

         for (ValidationResult result : validationResultList)
         {
             ValidationResult filteredResult = null;
             for (ValidationResultData resultData : result.getValidationResult())
             {
                 if (resultData.getSeverity().compareTo(limitSeverity) <= 0)
                 {
                     if (filteredResult == null)
                     {
                         filteredResult =
                                 new ValidationResult(result.getCheckerId(), LimitedList.UNLIMITED);
                     }
                     filteredResult.addValidationResult(resultData);
                     expectedLevelDetected = true;
                 }
             }
             if (filteredResult != null)
             {
                 filteredValidationResult.add(filteredResult);
             }
         }

         return expectedLevelDetected;
     }

     /**
      * Retrieves the total message summing up fatal errors, errors and warnings, depending
      * on current warning level.
      *
      * @param validationResultList The list of validation results already filtered (as it
      * was outputted to used)
      *
      * @return The total message string, or <code>null</code> if no message applies
      */
     public static String getValidationResultTotalMessage(List<ValidationResult> validationResultList)
     {
         String totalMessage = null;
         if (validationResultList != null)
         {
             if (currentWarningLevel.compareTo(WarningLevel.w0) > 0)
             {
                 int fatalErrorsCount = 0, errorsCount = 0, warningsCount = 0;

                 for (ValidationResult result : validationResultList)
                 {
                     for (ValidationResultData resultData : result.getValidationResult())
                     {
                         if (resultData.getSeverity().equals(SEVERITY.FATAL))
                         {
                             fatalErrorsCount++;
                         }
                         else if (resultData.getSeverity().equals(SEVERITY.ERROR))
                         {
                             errorsCount++;
                         }
                         else if (resultData.getSeverity().equals(SEVERITY.WARNING))
                         {
                             warningsCount++;
                         }
                     }
                 }

                 StringBuilder stringBuilder = new StringBuilder();

                 // (some code repetition was used to avoid unnecessary repeated testing that would
                 // slow performance)
                 if (currentWarningLevel.compareTo(WarningLevel.w3) >= 0)
                 {
                     if ((fatalErrorsCount > 0) || (errorsCount > 0) || (warningsCount > 0))
                     {
                         stringBuilder.append(PreflightingCoreNLS.WarningLevelFilter_TotalMessage);
                         stringBuilder.append(PreflightingCoreNLS.bind(
                                 PreflightingCoreNLS.WarningLevelFilter_FatalErrorsCountMessage,
                                 fatalErrorsCount)
                                 + TOTAL_MESSAGE_LEVEL_SEPARATOR);
                         stringBuilder.append(PreflightingCoreNLS.bind(
                                 PreflightingCoreNLS.WarningLevelFilter_ErrorsCountMessage,
                                 errorsCount)
                                 + TOTAL_MESSAGE_LEVEL_SEPARATOR);
                         stringBuilder.append(PreflightingCoreNLS.bind(
                                 PreflightingCoreNLS.WarningLevelFilter_WarningsCountMessage,
                                 warningsCount)
                                 + TOTAL_MESSAGE_TERMINATOR);
                     }
                 }
                 else if (currentWarningLevel.equals(WarningLevel.w2))
                 {
                     if ((fatalErrorsCount > 0) || (errorsCount > 0))
                     {
                         stringBuilder.append(PreflightingCoreNLS.WarningLevelFilter_TotalMessage);
                         stringBuilder.append(PreflightingCoreNLS.bind(
                                 PreflightingCoreNLS.WarningLevelFilter_FatalErrorsCountMessage,
                                 fatalErrorsCount)
                                 + TOTAL_MESSAGE_LEVEL_SEPARATOR);
                         stringBuilder.append(PreflightingCoreNLS.bind(
                                 PreflightingCoreNLS.WarningLevelFilter_ErrorsCountMessage,
                                 errorsCount)
                                 + TOTAL_MESSAGE_TERMINATOR);
                     }
                 }
                 else if (currentWarningLevel.equals(WarningLevel.w1))
                 {
                     if (fatalErrorsCount > 0)
                     {
                         stringBuilder.append(PreflightingCoreNLS.WarningLevelFilter_TotalMessage);
                         stringBuilder.append(PreflightingCoreNLS.bind(
                                 PreflightingCoreNLS.WarningLevelFilter_FatalErrorsCountMessage,
                                 fatalErrorsCount)
                                 + TOTAL_MESSAGE_TERMINATOR);
                     }
                 }

                 if (stringBuilder.length() > 0)
                 {
                     totalMessage = stringBuilder.toString();
                 }
             }
         }
         return totalMessage;
     }

     /**
      * Adjusts the warning level on the given validation result list.
      * The level can be increased or decreased.
      * Only the validation results from checkers or conditions passed on the are adjusted.
      *
      * @param validationResultList The list of validation results
      * @param raiseWarningLevels Whether the warning level should be increased (<code>true</code>
      * is passed) or decreased (<code>false</code> is passed)
      * @param checkerIdsToAdjustWarningLevel The list of checkers whose validation results should
      * have the warning level adjusted
      * @param conditionIdsMap specific checkers conditions to adjust, instead of a whole checker.
      * @param excludedConditionsIds
      */
     public static void adjustWarningLevels(List<ValidationResult> validationResultList,
             boolean raiseWarningLevels, List<String> checkerIdsToAdjustWarningLevel,
             Map<String, List<String>> conditionIdsMap, Map<String, List<String>> exclusionMap)
     {
         if (validationResultList == null)
         {
             throw new IllegalArgumentException("List<ValidationResult> cannot be null"); //$NON-NLS-1$
         }
         if (checkerIdsToAdjustWarningLevel == null)
         {
             checkerIdsToAdjustWarningLevel = Collections.emptyList();
         }
         if (conditionIdsMap == null)
         {
             conditionIdsMap = new HashMap<String, List<String>>(0);
         }

         SEVERITY[] severities = SEVERITY.values();
         for (ValidationResult result : validationResultList)
         {
             String checkerId = result.getCheckerId();
             if (checkerId != null)
             {
                 //Verify if there's anything to be changed
                 if (checkerIdsToAdjustWarningLevel.contains(checkerId)
                         || (conditionIdsMap.containsKey(checkerId)))
                 {
                     List<String> conditionsToAdjust = conditionIdsMap.get(checkerId);

                     //If something has to be changed, process the whole set, applying the changes.
                     for (ValidationResultData resultData : result.getValidationResult())
                     {
                         boolean mustAdjust = true;
                         //User specified only some conditions
                         if (!checkerIdsToAdjustWarningLevel.contains(checkerId)
                                 && (conditionsToAdjust != null))
                         {
                             mustAdjust = conditionsToAdjust.contains(resultData.getConditionID());
                         }
                         else if (exclusionMap != null)
                         {
                             List<String> conditionsToIgnore = exclusionMap.get(checkerId);
                             if (conditionsToIgnore != null)
                             {
                                 mustAdjust =
                                         !conditionsToIgnore.contains(resultData.getConditionID());
                             }
                         }
                         if (mustAdjust)
                         {
                             SEVERITY resultSeverity = resultData.getSeverity();
                             if (raiseWarningLevels)
                             {
                                 // last level is not raised, and above warning is not raised as well
                                 if ((SEVERITY.FATAL.compareTo(resultSeverity) < 0)
                                         && !SEVERITY.OK.equals(resultSeverity))
                                 {
                                     resultData
                                             .setSeverity(severities[resultSeverity.ordinal() - 1]);
                                 }
                             }
                             else
                             {
                                 // level is decreased for warning at least (nothing goes deeper than that)
                                 if (SEVERITY.WARNING.compareTo(resultSeverity) > 0)
                                 {
                                     resultData
                                             .setSeverity(severities[resultSeverity.ordinal() + 1]);
                                 }
                             }
                         }
                     }
                 }
             }
         }
     }
 }
	/*
	* Copyright (C) 2012 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package com.motorolamobility.preflighting.core.verbose;

	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;

	import com.motorolamobility.preflighting.core.i18n.PreflightingCoreNLS;
	import com.motorolamobility.preflighting.core.utils.LimitedList;
	import com.motorolamobility.preflighting.core.validation.ValidationResult;
	import com.motorolamobility.preflighting.core.validation.ValidationResultData;
	import com.motorolamobility.preflighting.core.validation.ValidationResultData.SEVERITY;
	import com.motorolamobility.preflighting.core.verbose.DebugVerboseOutputter.VerboseLevel;

	/**
	* Abstract class responsible for defining warning levels, setting the current warning level,
	* and filtering results and returning appropriate messages based on current warning
	* level set.
	* The warning level will be passed as a parameter to the application, if not,
	* {@link WarningLevelFilter#DEFAULT_WARNING_LEVEL} will be assumed (default warning level).
	*/
	public abstract class WarningLevelFilter
	{
	/**
	* The terminator string for the total message.
	*/
	private static final String TOTAL_MESSAGE_TERMINATOR = "."; //$NON-NLS-1$

	/**
	* The level separator string for the total message.
	*/
	private static final String TOTAL_MESSAGE_LEVEL_SEPARATOR = ", "; //$NON-NLS-1$

	/**
	* Enumeration representing the various warning levels available to the application.
	*/
	public enum WarningLevel
	{
	/**
	* Suppress all messages, just return success or failure.
	*/
	w0,
	/**
	* Only indicate extremely severe conditions that could cause immediate failure of
	* the application on launch (fatal errors).
	*/
	w1,
	/**
	* Indicate improper conditions that will lead to failure or possible problems on
	* different handsets (fatal errors + errors). This is the default warning level.
	*/
	w2,
	/**
	* Indicate all improper conditions (fatal errors + errors + warnings).
	*/
	w3,
	/**
	* Indicate all improper conditions (fatal errors + errors + warnings) and their
	* potential fixes, if known.
	*/
	w4;
	}

	/**
	* The default warning level ({@link WarningLevel#w2}).
	*/
	public static WarningLevel DEFAULT_WARNING_LEVEL = WarningLevel.w2;

	/**
	* The current warning level being used.
	*/
	private static WarningLevel currentWarningLevel = DEFAULT_WARNING_LEVEL;

	/**
	* Retrieve the current warning level for the application.
	*
	* @return Current warning level.
	*/
	public static WarningLevel getCurrentWarningLevel()
	{
	return currentWarningLevel;
	}

	/**
	* Set the current warning level to the given one. If <code>null</code> is
	* passed, the default warning level is used ({@link WarningLevelFilter#DEFAULT_WARNING_LEVEL}).
	*
	* @param warningLevel Warning level to be set.
	*/
	public static void setCurrentWarningLevel(WarningLevel warningLevel)
	{
	if (warningLevel != null)
	{
	currentWarningLevel = warningLevel;
	}
	else
	{
	currentWarningLevel = DEFAULT_WARNING_LEVEL;
	}
	}

	/**
	* Return whether quick fix suggestions should be printed
	* (warning level equals {@link WarningLevel#w4}) or not.
	*
	* @return <code>true</code> if quick fix suggestions should be printed,
	* <code>false</code> otherwise.
	*/
	public static boolean printQuickFixSuggestions()
	{
	return currentWarningLevel.equals(WarningLevel.w4);
	}

	/**
	* Return whether the severities should be printed or not
	* (severities are not printed if warning level equals {@link WarningLevel#w0}).
	*
	* @return <code>true</code> if severities should be printed,
	* <code>false</code> otherwise.
	*/
	public static boolean printSeverity()
	{
	return !currentWarningLevel.equals(WarningLevel.w0);
	}

	/**
	* Filters the given list of validation results so that the returning list
	* of validation results contain only the appropriate issues, according to
	* warning level set.
	*
	* @param validationResultList The list of validation results found by the application
	*
	* @return The filtered validation results list, according to warning level set
	*/
	public static List<ValidationResult> filterValidationResultsForCurrentWarningLevel(
	List<ValidationResult> validationResultList)
	{
	if (validationResultList == null)
	{
	throw new IllegalArgumentException("List<ValidationResult> cannot be null"); //$NON-NLS-1$
	}

	List<ValidationResult> filteredValidationResult = new ArrayList<ValidationResult>();

	if (validationResultList.size() > 0)
	{

	DebugVerboseOutputter.printVerboseMessage(
	PreflightingCoreNLS.WarningLevelFilter_VerboseMessage_FilterningResult,
	VerboseLevel.v2);

	if (currentWarningLevel.equals(WarningLevel.w0))
	{
	boolean fatalErrorsDetected = false, potentialErrorsDetected = false;

	for (ValidationResult result : validationResultList)
	{
	for (ValidationResultData resultData : result.getValidationResult())
	{
	if (resultData.getSeverity().equals(SEVERITY.FATAL))
	{
	fatalErrorsDetected = true;
	break;
	}
	else if (resultData.getSeverity().equals(SEVERITY.ERROR))
	{
	potentialErrorsDetected = true;
	}
	}
	}

	ValidationResult result = null;
	if (fatalErrorsDetected)
	{
	result =
	createValidationResultObject(
	PreflightingCoreNLS.WarningLevelFilter_FatalErrorsMessage,
	SEVERITY.FATAL);
	}
	else if (potentialErrorsDetected)
	{
	result =
	createValidationResultObject(
	PreflightingCoreNLS.WarningLevelFilter_ErrorsMessage,
	SEVERITY.ERROR);
	}
	else
	{
	result =
	createValidationResultObject(
	PreflightingCoreNLS.WarningLevelFilter_NoProblemsMessage,
	SEVERITY.OK);
	}
	filteredValidationResult.add(result);
	}
	else if (currentWarningLevel.equals(WarningLevel.w1)) // fatal errors only
	{
	boolean fatalErrorsDetected =
	filterValidationResultForSeverity(validationResultList,
	filteredValidationResult, SEVERITY.FATAL);
	if (!fatalErrorsDetected)
	{
	ValidationResult result =
	createValidationResultObject(
	PreflightingCoreNLS.WarningLevelFilter_NoFatalErrorsMessage,
	SEVERITY.OK);
	filteredValidationResult.add(result);
	}
	}
	else if (currentWarningLevel.equals(WarningLevel.w2)) // fatal errors and errors only
	{
	boolean errorsOrFatalErrorsDetected =
	filterValidationResultForSeverity(validationResultList,
	filteredValidationResult, SEVERITY.ERROR);
	if (!errorsOrFatalErrorsDetected)
	{
	ValidationResult result =
	createValidationResultObject(
	PreflightingCoreNLS.WarningLevelFilter_NoFatalNorErrorsMessage,
	SEVERITY.OK);
	filteredValidationResult.add(result);
	}
	}
	else if (currentWarningLevel.compareTo(WarningLevel.w3) >= 0) // all levels
	{
	boolean warningsErrorsOrFatalErrorsDetected =
	filterValidationResultForSeverity(validationResultList,
	filteredValidationResult, SEVERITY.WARNING);
	if (!warningsErrorsOrFatalErrorsDetected)
	{
	ValidationResult result =
	createValidationResultObject(
	PreflightingCoreNLS.WarningLevelFilter_NoFatalErrorsNorWarningsMessage,
	SEVERITY.OK);
	filteredValidationResult.add(result);
	}
	}

	DebugVerboseOutputter.printVerboseMessage(
	PreflightingCoreNLS.WarningLevelFilter_VerboseMessage_ResultFiltered,
	VerboseLevel.v2);
	}

	return filteredValidationResult;
	}

	private static ValidationResult createValidationResultObject(String message, SEVERITY severity)
	{
	ValidationResult result = new ValidationResult(null, LimitedList.UNLIMITED);
	ValidationResultData resultData = new ValidationResultData();
	result.addValidationResult(resultData);
	resultData.setSeverity(severity);
	resultData.setIssueDescription(message);
	return result;
	}

	/**
	* Filter the validation results of a particular checker, given the limit severity
	* (which is defined according to warning level set). The result is added to the filtered
	* list also passed.
	* Returns a flag indicating if any issues were found of at least the given severity.
	*
	* @param validationResultList The original list of validation results
	* @param filteredValidationResult The filtered list; entries are added to it by this method
	* @param limitSeverity The limit severity for issues entering the filtered list or not
	*
	* @return <code>true</code> if any issues were found with at least the severity passed
	* (or more severe), <code>false</code> otherwise
	*/
	private static boolean filterValidationResultForSeverity(
	List<ValidationResult> validationResultList,
	List<ValidationResult> filteredValidationResult, SEVERITY limitSeverity)
	{
	boolean expectedLevelDetected = false;

	for (ValidationResult result : validationResultList)
	{
	ValidationResult filteredResult = null;
	for (ValidationResultData resultData : result.getValidationResult())
	{
	if (resultData.getSeverity().compareTo(limitSeverity) <= 0)
	{
	if (filteredResult == null)
	{
	filteredResult =
	new ValidationResult(result.getCheckerId(), LimitedList.UNLIMITED);
	}
	filteredResult.addValidationResult(resultData);
	expectedLevelDetected = true;
	}
	}
	if (filteredResult != null)
	{
	filteredValidationResult.add(filteredResult);
	}
	}

	return expectedLevelDetected;
	}

	/**
	* Retrieves the total message summing up fatal errors, errors and warnings, depending
	* on current warning level.
	*
	* @param validationResultList The list of validation results already filtered (as it
	* was outputted to used)
	*
	* @return The total message string, or <code>null</code> if no message applies
	*/
	public static String getValidationResultTotalMessage(List<ValidationResult> validationResultList)
	{
	String totalMessage = null;
	if (validationResultList != null)
	{
	if (currentWarningLevel.compareTo(WarningLevel.w0) > 0)
	{
	int fatalErrorsCount = 0, errorsCount = 0, warningsCount = 0;

	for (ValidationResult result : validationResultList)
	{
	for (ValidationResultData resultData : result.getValidationResult())
	{
	if (resultData.getSeverity().equals(SEVERITY.FATAL))
	{
	fatalErrorsCount++;
	}
	else if (resultData.getSeverity().equals(SEVERITY.ERROR))
	{
	errorsCount++;
	}
	else if (resultData.getSeverity().equals(SEVERITY.WARNING))
	{
	warningsCount++;
	}
	}
	}

	StringBuilder stringBuilder = new StringBuilder();

	// (some code repetition was used to avoid unnecessary repeated testing that would
	// slow performance)
	if (currentWarningLevel.compareTo(WarningLevel.w3) >= 0)
	{
	if ((fatalErrorsCount > 0) \|\| (errorsCount > 0) \|\| (warningsCount > 0))
	{
	stringBuilder.append(PreflightingCoreNLS.WarningLevelFilter_TotalMessage);
	stringBuilder.append(PreflightingCoreNLS.bind(
	PreflightingCoreNLS.WarningLevelFilter_FatalErrorsCountMessage,
	fatalErrorsCount)
	+ TOTAL_MESSAGE_LEVEL_SEPARATOR);
	stringBuilder.append(PreflightingCoreNLS.bind(
	PreflightingCoreNLS.WarningLevelFilter_ErrorsCountMessage,
	errorsCount)
	+ TOTAL_MESSAGE_LEVEL_SEPARATOR);
	stringBuilder.append(PreflightingCoreNLS.bind(
	PreflightingCoreNLS.WarningLevelFilter_WarningsCountMessage,
	warningsCount)
	+ TOTAL_MESSAGE_TERMINATOR);
	}
	}
	else if (currentWarningLevel.equals(WarningLevel.w2))
	{
	if ((fatalErrorsCount > 0) \|\| (errorsCount > 0))
	{
	stringBuilder.append(PreflightingCoreNLS.WarningLevelFilter_TotalMessage);
	stringBuilder.append(PreflightingCoreNLS.bind(
	PreflightingCoreNLS.WarningLevelFilter_FatalErrorsCountMessage,
	fatalErrorsCount)
	+ TOTAL_MESSAGE_LEVEL_SEPARATOR);
	stringBuilder.append(PreflightingCoreNLS.bind(
	PreflightingCoreNLS.WarningLevelFilter_ErrorsCountMessage,
	errorsCount)
	+ TOTAL_MESSAGE_TERMINATOR);
	}
	}
	else if (currentWarningLevel.equals(WarningLevel.w1))
	{
	if (fatalErrorsCount > 0)
	{
	stringBuilder.append(PreflightingCoreNLS.WarningLevelFilter_TotalMessage);
	stringBuilder.append(PreflightingCoreNLS.bind(
	PreflightingCoreNLS.WarningLevelFilter_FatalErrorsCountMessage,
	fatalErrorsCount)
	+ TOTAL_MESSAGE_TERMINATOR);
	}
	}

	if (stringBuilder.length() > 0)
	{
	totalMessage = stringBuilder.toString();
	}
	}
	}
	return totalMessage;
	}

	/**
	* Adjusts the warning level on the given validation result list.
	* The level can be increased or decreased.
	* Only the validation results from checkers or conditions passed on the are adjusted.
	*
	* @param validationResultList The list of validation results
	* @param raiseWarningLevels Whether the warning level should be increased (<code>true</code>
	* is passed) or decreased (<code>false</code> is passed)
	* @param checkerIdsToAdjustWarningLevel The list of checkers whose validation results should
	* have the warning level adjusted
	* @param conditionIdsMap specific checkers conditions to adjust, instead of a whole checker.
	* @param excludedConditionsIds
	*/
	public static void adjustWarningLevels(List<ValidationResult> validationResultList,
	boolean raiseWarningLevels, List<String> checkerIdsToAdjustWarningLevel,
	Map<String, List<String>> conditionIdsMap, Map<String, List<String>> exclusionMap)
	{
	if (validationResultList == null)
	{
	throw new IllegalArgumentException("List<ValidationResult> cannot be null"); //$NON-NLS-1$
	}
	if (checkerIdsToAdjustWarningLevel == null)
	{
	checkerIdsToAdjustWarningLevel = Collections.emptyList();
	}
	if (conditionIdsMap == null)
	{
	conditionIdsMap = new HashMap<String, List<String>>(0);
	}

	SEVERITY[] severities = SEVERITY.values();
	for (ValidationResult result : validationResultList)
	{
	String checkerId = result.getCheckerId();
	if (checkerId != null)
	{
	//Verify if there's anything to be changed
	if (checkerIdsToAdjustWarningLevel.contains(checkerId)
	\|\| (conditionIdsMap.containsKey(checkerId)))
	{
	List<String> conditionsToAdjust = conditionIdsMap.get(checkerId);

	//If something has to be changed, process the whole set, applying the changes.
	for (ValidationResultData resultData : result.getValidationResult())
	{
	boolean mustAdjust = true;
	//User specified only some conditions
	if (!checkerIdsToAdjustWarningLevel.contains(checkerId)
	&& (conditionsToAdjust != null))
	{
	mustAdjust = conditionsToAdjust.contains(resultData.getConditionID());
	}
	else if (exclusionMap != null)
	{
	List<String> conditionsToIgnore = exclusionMap.get(checkerId);
	if (conditionsToIgnore != null)
	{
	mustAdjust =
	!conditionsToIgnore.contains(resultData.getConditionID());
	}
	}
	if (mustAdjust)
	{
	SEVERITY resultSeverity = resultData.getSeverity();
	if (raiseWarningLevels)
	{
	// last level is not raised, and above warning is not raised as well
	if ((SEVERITY.FATAL.compareTo(resultSeverity) < 0)
	&& !SEVERITY.OK.equals(resultSeverity))
	{
	resultData
	.setSeverity(severities[resultSeverity.ordinal() - 1]);
	}
	}
	else
	{
	// level is decreased for warning at least (nothing goes deeper than that)
	if (SEVERITY.WARNING.compareTo(resultSeverity) > 0)
	{
	resultData
	.setSeverity(severities[resultSeverity.ordinal() + 1]);
	}
	}
	}
	}
	}
	}
	}
	}
	}