Catel - Part 4 of n: Unit testing with Catel

// --------------------------------------------------------------------------------------------------------------------
// <copyright file="BooleanToTextConverter.cs" company="Catel development team">
//   Copyright (c) 2008 - 2011 Catel development team. All rights reserved.
// </copyright>
// <summary>
//   Available modes for the <see cref="BooleanToTextConverter" />.
// </summary>
// --------------------------------------------------------------------------------------------------------------------

using System;
using System.Windows;
using System.Windows.Data;
using Catel.Windows.Properties;
using log4net;

namespace Catel.Windows.Data.Converters
{
    #region Enums
    /// <summary>
    /// Available modes for the <see cref="BooleanToTextConverter"/>.
    /// </summary>
    enum BooleanToTextConverterMode
    {
        /// <summary>
        /// True becomes <c>Yes</c>, false becomes <c>No</c>.
        /// </summary>
        YesNo,

        /// <summary>
        /// True becomes <c>x</c>, false becomes <c></c> (thus empty).
        /// </summary>
        X
    }
    #endregion

	/// <summary>
	/// BooleanToTextConverter.
	/// </summary>
#if !SILVERLIGHT
	[ValueConversion(typeof(bool), typeof(string))]
#endif
    public class BooleanToTextConverter : IValueConverter
	{
		#region Properties
        /// <summary>
        /// The <see cref="ILog">log</see> object.
        /// </summary>
		private static readonly ILog Log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
		#endregion

		#region Methods
		/// <summary>
        /// Converts a boolean value to text.
        /// </summary>
        /// <param name="value">Value to convert.</param>
        /// <param name="targetType">Not used.</param>
        /// <param name="parameter"><see cref="BooleanToTextConverterMode"/>.</param>
        /// <param name="culture">Not used.</param>
        /// <returns>Text presentation of the boolean value.</returns>
        /// <remarks>
        /// If the parameter is invalid, or the method fails to parse the parameter, <see cref="BooleanToTextConverterMode.YesNo"/>
        /// will be used to convert the value.
        /// </remarks>
        public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        {
            // Validate input
            if ((value == null) || !(value is bool))
            {
                return string.Empty;
            }

            // Parse the value
            bool typedValue = (bool)value;

            // Parse the mode
            BooleanToTextConverterMode mode = (parameter is BooleanToTextConverterMode) ? (BooleanToTextConverterMode)parameter : ParseMode(parameter as string);

            // Now convert the value
            switch (mode)
            {
                case BooleanToTextConverterMode.X:
                    return (typedValue) ? "x" : string.Empty;

                case BooleanToTextConverterMode.YesNo:
                    return (typedValue) ? Resources.Yes : Resources.No;

                default:
                    // Some strange way, this method fails (all known modes must be handled), so return "failed"
					return Resources.Failed;
            }
        }

        /// <summary>
        /// Not supported.
        /// </summary>
        /// <param name="value"></param>
        /// <param name="targetType"></param>
        /// <param name="parameter"></param>
        /// <param name="culture"></param>
        /// <returns></returns>
        public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        {
            return ConverterHelper.DoNothingBindingValue;
        }

        /// <summary>
        /// Parses the parameter and returns a <see cref="BooleanToTextConverterMode"/> that represents the parameter. 
        /// </summary>
        /// <param name="parameter"><see cref="BooleanToTextConverterMode"/> as text.</param>
        /// <returns><see cref="BooleanToTextConverterMode"/> as it was passed as a string.</returns>
        /// <remarks>
        /// If the parameter is invalid, or the method fails to parse the parameter, <see cref="BooleanToTextConverterMode.YesNo"/>
        /// will be returned as a default value.
        /// </remarks>
        private static BooleanToTextConverterMode ParseMode(string parameter)
        {
            // Declare variables
            BooleanToTextConverterMode mode = BooleanToTextConverterMode.YesNo;

            // Check input
            if (string.IsNullOrEmpty(parameter))
            {
                // Log
				Log.Error(TraceMessages.ConverterParameterIsNullSoDefaultIsUsed, mode.ToString());

                // Return mode
                return mode;
            }

            try
            {
                // Parse
                mode = (BooleanToTextConverterMode)Enum.Parse(typeof(BooleanToTextConverterMode), parameter, false);
            }
            catch (ArgumentException)
            {
                // Log
				Log.Error(TraceMessages.ParseFailed, parameter, "BooleanToTextConverterMode");

                // Return mode
                return mode;
            }

            // Return
            return mode;
        }
        #endregion
    }
}