public void ColumnHeaderConverter_GetProperties_Invoke_ReturnsExpected()
{
var converter = new ColumnHeaderConverter();
using var item = new ColumnHeader();
Assert.Equal(TypeDescriptor.GetProperties(item, null).Count, converter.GetProperties(null, item, null).Count);
}
public void ColumnHeaderConverter_ConvertTo_NoPublicDefaultConstructor_ThrowsArgumentException()
{
using var value = new PrivateDefaultConstructor(-1);
var converter = new ColumnHeaderConverter();
Assert.Throws <ArgumentException>(null, () => converter.ConvertTo(value, typeof(InstanceDescriptor)));
}
public void ColumnHeaderConverter_ConvertTo_InstanceDescriptor_ReturnsExpected(ColumnHeader value, Type[] parameterTypes, object[] arguments)
{
var converter = new ColumnHeaderConverter();
InstanceDescriptor descriptor = Assert.IsType <InstanceDescriptor>(converter.ConvertTo(value, typeof(InstanceDescriptor)));
Assert.Equal(value.GetType().GetConstructor(parameterTypes), descriptor.MemberInfo);
Assert.Equal(arguments, descriptor.Arguments);
}
/// <summary>
/// Extends ConvertTo so that methods that return a specific type object given a Type parameter can be
/// used as generic method and casting is not required.
/// <example>
/// columnheaderconverter.ConvertTo<int>(context, culture, value);
/// </example>
/// </summary>
public static T ConvertTo <T>(this ColumnHeaderConverter columnheaderconverter, System.ComponentModel.ITypeDescriptorContext context, System.Globalization.CultureInfo culture, Object value)
{
if (columnheaderconverter == null)
{
throw new ArgumentNullException("columnheaderconverter");
}
return((T)columnheaderconverter.ConvertTo(context, culture, value, typeof(T)));
}
/// <summary>
/// Extends ConvertTo so that methods that return a specific type object given a Type parameter can be
/// used as generic method and casting is not required.
/// <example>
/// typeconverter.ConvertTo<int>(value);
/// </example>
/// </summary>
public static T ConvertTo <T>(this ColumnHeaderConverter typeconverter, Object value)
{
if (typeconverter == null)
{
throw new ArgumentNullException("typeconverter");
}
return((T)typeconverter.ConvertTo(value, typeof(T)));
}
public void ColumnHeaderConverter_CanConvertTo_Invoke_ReturnsExpected(Type destinationType, bool expected)
{
var converter = new ColumnHeaderConverter();
Assert.Equal(expected, converter.CanConvertTo(destinationType));
}
public void ColumnHeaderConverter_ConvertFrom_InvalidValue_ThrowsNotSupportedException(object value)
{
var converter = new ColumnHeaderConverter();
Assert.Throws <NotSupportedException>(() => converter.ConvertFrom(value));
}
public void ColumnHeaderConverter_CanConvertFrom_Invoke_ReturnsExpected(Type sourceType, bool expected)
{
var converter = new ColumnHeaderConverter();
Assert.Equal(expected, converter.CanConvertFrom(sourceType));
}
public void ColumnHeaderConverter_GetStandardValuesSupported_Invoke_ReturnsFalse()
{
var converter = new ColumnHeaderConverter();
Assert.False(converter.GetStandardValuesSupported(null));
}
public void ColumnHeaderConverter_GetStandardValues_Invoke_ReturnsNull()
{
var converter = new ColumnHeaderConverter();
Assert.Null(converter.GetStandardValues(null));
}
public void ColumnHeaderConverter_GetPropertiesSupported_Invoke_ReturnsTrue()
{
var converter = new ColumnHeaderConverter();
Assert.True(converter.GetPropertiesSupported(null));
}
public void ColumnHeaderConverter_ConvertTo_InvalidDestinationType_ThrowsNotSupportedException(Type destinationType)
{
var converter = new ColumnHeaderConverter();
Assert.Throws <NotSupportedException>(() => converter.ConvertTo(new ColumnHeader(), destinationType));
}
public void ColumnHeaderConverter_ConvertTo_ValueNotThrowsNotSupportedException()
{
var converter = new ColumnHeaderConverter();
Assert.Throws <NotSupportedException>(() => converter.ConvertTo(1, typeof(InstanceDescriptor)));
}
public void ColumnHeaderConverter_ConvertTo_NullDestinationType_ThrowsArgumentNullException()
{
var converter = new ColumnHeaderConverter();
Assert.Throws <ArgumentNullException>("destinationType", () => converter.ConvertTo(new object(), null));
}
public void ColumnHeaderConverter_ConvertTo_String_ReturnsExpected(object value, string expected)
{
var converter = new ColumnHeaderConverter();
Assert.Equal(expected, converter.ConvertTo(value, typeof(string)));
}
