protected override string ConvertTo(TypeConverterOptions options, object value)
 {
     double d = Convert.ToDouble(value);
     string format = options.NumberStyle.HasValue ? "#.#" : "###.#";
     string s = d.IsZero() ? "Unknown" : d.ToString(format);
     return s;
 }

 protected override string ConvertTo(TypeConverterOptions options, object value)
 {
     if (value == null) return "Unknown";
     var dt = Convert.ToDateTime(value);
     if (dt == DateTime.MinValue) return "Unknown";
     return dt.ToString("g");
 }

        public string ConvertToString(TypeConverterOptions options, object value)
        {
            var color = (Color)value;
            var stringValue = ColorTranslator.ToHtml(color);

            return stringValue;
        }

		public void ConvertFromStringTest()
		{
			var converter = new EnumConverter( typeof( TestEnum ) );
			var typeConverterOptions = new TypeConverterOptions
			{
				CultureInfo = CultureInfo.CurrentCulture
			};

			Assert.AreEqual( TestEnum.One, converter.ConvertFromString( typeConverterOptions, "One" ) );
			Assert.AreEqual( TestEnum.One, converter.ConvertFromString( typeConverterOptions, "one" ) );
			Assert.AreEqual( TestEnum.One, converter.ConvertFromString( typeConverterOptions, "1" ) );
			try
			{
				Assert.AreEqual( TestEnum.One, converter.ConvertFromString( typeConverterOptions, "" ) );
				Assert.Fail();
			}
			catch( CsvTypeConverterException )
			{
			}

			try
			{
				Assert.AreEqual( TestEnum.One, converter.ConvertFromString( typeConverterOptions, null ) );
				Assert.Fail();
			}
			catch( CsvTypeConverterException )
			{
			}
		}

		/// <summary>
		/// Converts the string to an object.
		/// </summary>
		/// <param name="options">The options to use when converting.</param>
		/// <param name="text">The string to convert to an object.</param>
		/// <returns>The object created from the string.</returns>
		public override object ConvertFromString( TypeConverterOptions options, string text )
		{
			var formatProvider = (IFormatProvider)options.CultureInfo;

			TimeSpan span;

#if !NET_2_0 && !NET_3_5 && !PCL
			var timeSpanStyle = options.TimeSpanStyle ?? TimeSpanStyles.None;
			if( !string.IsNullOrEmpty( options.Format ) && TimeSpan.TryParseExact( text, options.Format, formatProvider, timeSpanStyle, out span ) )
			{
				return span;
			}

			if( string.IsNullOrEmpty( options.Format ) && TimeSpan.TryParse( text, formatProvider, out span ) )
			{
				return span;
			}
#else
			if( TimeSpan.TryParse( text, out span ) )
			{
				return span;
			}
#endif

			return base.ConvertFromString( options, text );
		}

        public void ConvertTest()
        {
            var converter = new EnumerableConverter();
            var typeConverterOptions = new TypeConverterOptions
            {
                CultureInfo = CultureInfo.CurrentCulture
            };

            Assert.IsTrue( converter.CanConvertFrom( typeof( string ) ) );
            Assert.IsTrue( converter.CanConvertTo( typeof( string ) ) );
            try
            {
                converter.ConvertFromString( typeConverterOptions, "" );
                Assert.Fail();
            }
            catch( CsvTypeConverterException )
            {
            }
            try
            {
                converter.ConvertToString( typeConverterOptions, 5 );
                Assert.Fail();
            }
            catch( CsvTypeConverterException )
            {
            }
        }

        public void ConvertFromStringTest()
        {
            var converter = new DateTimeConverter();
            var typeConverterOptions = new TypeConverterOptions
            {
                CultureInfo = CultureInfo.CurrentCulture
            };

            var dateTime = DateTime.Now;

            // Valid conversions.
            Assert.AreEqual( dateTime.ToString(), converter.ConvertFromString( typeConverterOptions, dateTime.ToString() ).ToString() );
            Assert.AreEqual( dateTime.ToString(), converter.ConvertFromString( typeConverterOptions, dateTime.ToString( "o" ) ).ToString() );
            Assert.AreEqual( dateTime.ToString(), converter.ConvertFromString( typeConverterOptions, " " + dateTime + " " ).ToString() );

            // Invalid conversions.
            try
            {
                converter.ConvertFromString( typeConverterOptions, null );
                Assert.Fail();
            }
            catch( CsvTypeConverterException )
            {
            }
        }

		/// <summary>
		/// Merges TypeConverterOptions by applying the values of sources in order to a
		/// new TypeConverterOptions instance.
		/// </summary>
		/// <param name="sources">The sources that will be applied.</param>
		/// <returns>A new instance of TypeConverterOptions with the source applied to it.</returns>
		public static TypeConverterOptions Merge( params TypeConverterOptions[] sources )
		{
			var options = new TypeConverterOptions();
			foreach( var source in sources )
			{
				if( source == null )
				{
					continue;
				}

				if( source.CultureInfo != null )
				{
					options.CultureInfo = source.CultureInfo;
				}

				if( source.DateTimeStyle != null )
				{
					options.DateTimeStyle = source.DateTimeStyle;
				}

#if !NET_2_0 && !NET_3_5 && !PCL
				if( source.TimeSpanStyle != null )
				{
					options.TimeSpanStyle = source.TimeSpanStyle;
				}
#endif

				if( source.NumberStyle != null )
				{
					options.NumberStyle = source.NumberStyle;
				}

				if( source.Format != null )
				{
					options.Format = source.Format;
				}

#if NET_2_0
				if( !EnumerableHelper.SequenceEqual( options.booleanTrueValues, source.booleanTrueValues ) )
#else
				if( !options.booleanTrueValues.SequenceEqual( source.booleanTrueValues ) )
#endif
				{
					options.booleanTrueValues.Clear();
					options.booleanTrueValues.AddRange( source.booleanTrueValues );
				}

#if NET_2_0
				if( !EnumerableHelper.SequenceEqual( options.booleanFalseValues, source.booleanFalseValues ) )
#else
				if( !options.booleanFalseValues.SequenceEqual( source.booleanFalseValues ) )
#endif
				{
					options.booleanFalseValues.Clear();
					options.booleanFalseValues.AddRange( source.booleanFalseValues );
				}
			}

			return options;
		}

 /// <summary>
 ///     Converts the string to an object.
 /// </summary>
 /// <param name="options">The options to use when converting.</param>
 /// <param name="text">The string to convert to an object.</param>
 /// <returns>
 ///     The object created from the string.
 /// </returns>
 public override object ConvertFromString(TypeConverterOptions options, string text)
 {
     var numberStyle = options.NumberStyle;
     var style = numberStyle.HasValue ? numberStyle.GetValueOrDefault() : NumberStyles.Float;
     double result;
     if (double.TryParse(text, style, options.CultureInfo, out result))
         return Length.FromMillimeters(result);
     return base.ConvertFromString(options, text);
 }

        public object ConvertFromString(TypeConverterOptions options, string text)
        {
            if (string.IsNullOrWhiteSpace(text))
                return new DateTime?();

            var value = ParseDate(options, text);

            return value;
        }

        public override object ConvertFromString(TypeConverterOptions options, string text)
        {
            if (string.IsNullOrWhiteSpace(text))
            {
                return null;
            }

            return base.ConvertFromString(options, text);
        }

		/// <summary>
		/// Converts the string to an object.
		/// </summary>
		/// <param name="options">The options to use when converting.</param>
		/// <param name="text">The string to convert to an object.</param>
		/// <returns>The object created from the string.</returns>
		public override object ConvertFromString( TypeConverterOptions options, string text )
		{
			if( string.IsNullOrEmpty( text ) )
			{
				return null;
			}

			return UnderlyingTypeConverter.ConvertFromString( options, text );
		}

        public object ConvertFromString(TypeConverterOptions options, string text)
        {
            if (string.IsNullOrWhiteSpace(text))
            {
                text = Resources.DependencyNone;
            }

            return text;
        }

        /// <summary>
        /// Converts the string to an object.
        /// </summary>
        /// <param name="options">The options to use when converting.</param>
        /// <param name="text">The string to convert to an object.</param>
        /// <returns>The object created from the string.</returns>
        public override object ConvertFromString( TypeConverterOptions options, string text )
        {
            if( text == null )
            {
                return base.ConvertFromString( options, text );
            }

            return new Guid( text );
        }

        /// <summary>
        /// Converts the string to an object.
        /// </summary>
        /// <param name="options">The options to use when converting.</param>
        /// <param name="text">The string to convert to an object.</param>
        /// <returns>The object created from the string.</returns>
        public override object ConvertFromString( TypeConverterOptions options, string text )
        {
            if( text == null )
            {
                return string.Empty;
            }

            return text;
        }

        public string ConvertToString(TypeConverterOptions options, object value)
        {
            if (value == null)
                return null;

            var dateValue = (DateTime) value;
            var formattedDate = dateValue.ToString("yyyyMMdd");

            return formattedDate;
        }

        /// <summary>
        /// Converts the string to an object.
        /// </summary>
        /// <param name="options">The options to use when converting.</param>
        /// <param name="text">The string to convert to an object.</param>
        /// <returns>The object created from the string.</returns>
        public override object ConvertFromString( TypeConverterOptions options, string text )
        {
            TimeSpan span;

            if( TimeSpan.TryParse( text, out span ) )
            {
                return span;
            }

            return base.ConvertFromString( options, text );
        }

 /// <summary>
 /// Converts the string to an object.
 /// </summary>
 /// <param name="options">The options to use when converting.</param>
 /// <param name="text">The string to convert to an object.</param>
 /// <returns>The object created from the string.</returns>
 public override object ConvertFromString( TypeConverterOptions options, string text )
 {
     try
     {
         return Enum.Parse( type, text + "some unneeded string here", true );
     }
     catch
     {
         return base.ConvertFromString( options, text );
     }
 }

        public void ConvertToStringTest()
        {
            var converter = new ByteConverter();
            var typeConverterOptions = new TypeConverterOptions
            {
                CultureInfo = CultureInfo.CurrentCulture
            };

            Assert.AreEqual( "123", converter.ConvertToString( typeConverterOptions, (byte)123 ) );

            Assert.AreEqual( "", converter.ConvertToString( typeConverterOptions, null ) );
        }

		/// <summary>
		/// Converts the string to an object.
		/// </summary>
		/// <param name="options">The options to use when converting.</param>
		/// <param name="text">The string to convert to an object.</param>
		/// <returns>The object created from the string.</returns>
		public override object ConvertFromString( TypeConverterOptions options, string text )
		{
			var numberStyle = options.NumberStyle ?? NumberStyles.Float;

			float f;
			if( float.TryParse( text, numberStyle, options.CultureInfo, out f ) )
			{
				return f;
			}

			return base.ConvertFromString( options, text );
		}