public void TestEnumerationConverter()
{
EnumerationConverter enumerationConverter = new EnumerationConverter();
Assert.True(enumerationConverter.CanConvertTo(typeof(DayOfWeek)));
Assert.True(enumerationConverter.CanConvertTo(typeof(Animal)));
Assert.True(enumerationConverter.CanConvertTo(typeof(PlatformID)));
Assert.False(enumerationConverter.CanConvertTo(typeof(string)));
Assert.False(enumerationConverter.CanConvertTo(typeof(int)));
Assert.False(enumerationConverter.CanConvertTo(typeof(bool)));
Assert.False(enumerationConverter.CanConvertTo(typeof(float)));
Assert.False(enumerationConverter.CanConvertTo(typeof(Enum)));
Assert.False(enumerationConverter.CanConvertFrom("abc"));
Assert.False(enumerationConverter.CanConvertFrom("123"));
Assert.False(enumerationConverter.CanConvertFrom(""));
Assert.Equal(Animal.Cat, enumerationConverter.Convert(typeof(Animal), "Cat"));
Assert.Equal(Animal.Dog, enumerationConverter.Convert(typeof(Animal), "Dog"));
Assert.Equal(Animal.Bird, enumerationConverter.Convert(typeof(Animal), "Bird"));
Assert.Equal(Animal.Bird, enumerationConverter.Convert(typeof(Animal), "2"));
Assert.Throws <InvalidOperationException>(() => enumerationConverter.Convert(typeof(object), "Dog"));
Assert.Throws <InvalidOperationException>(() => enumerationConverter.Convert(typeof(Animal), "Fish"));
}
public void WriteTests()
{
// Arrange
var inputs = new Dictionary <string, SampleEnumeration>
{
{ "\"Value1\"", SampleEnumeration.Value1 },
{ "\"Value2\"", SampleEnumeration.Value2 },
{ "\"Value3\"", SampleEnumeration.Value3 }
};
var target = new EnumerationConverter();
// Act & Assert
foreach (var(expectedResult, input) in inputs)
{
using var memoryStream = new MemoryStream();
var writer = new Utf8JsonWriter(memoryStream);
target.Write(writer, input, new JsonSerializerOptions());
writer.Flush();
memoryStream.Position = 0;
using var reader = new StreamReader(memoryStream);
var result = reader.ReadToEnd();
Assert.Equal(expectedResult, result);
}
}
public void ReadKnownValuesTests()
{
// Arrange
var inputs = new Dictionary <string, SampleEnumeration>
{
{ "\"Value1\"", SampleEnumeration.Value1 },
{ "\"valuE1\"", SampleEnumeration.Value1 },
{ "\"Value2\"", SampleEnumeration.Value2 },
{ "\"value2\"", SampleEnumeration.Value2 },
{ "\"Value3\"", SampleEnumeration.Value3 },
{ "\"value3\"", SampleEnumeration.Value3 }
};
var target = new EnumerationConverter();
// Act & Assert
foreach (var(json, expectedResult) in inputs)
{
Enumeration?result = null;
var utf8JsonBytes = Encoding.UTF8.GetBytes(json);
var reader = new Utf8JsonReader(utf8JsonBytes, true, new JsonReaderState());
while (reader.Read())
{
result = target.Read(ref reader, typeof(SampleEnumeration), new JsonSerializerOptions());
}
Assert.Equal(expectedResult, result);
}
}
public void Test_ConvertHorizontalAlignment_HabaneroToVWG_Center()
{
//---------------Set up test pack-------------------
//---------------Execute Test ----------------------
Gizmox.WebGUI.Forms.HorizontalAlignment horizontalAlignment =
EnumerationConverter.HorizontalAlignmentToVWG(HorizontalAlignment.Center);
//---------------Test Result -----------------------
Assert.AreEqual(typeof(Gizmox.WebGUI.Forms.HorizontalAlignment), horizontalAlignment.GetType());
Assert.AreEqual(Gizmox.WebGUI.Forms.HorizontalAlignment.Center.ToString(), horizontalAlignment.ToString());
}
/// <summary>
/// Adds an enumeration conversion for the given type
/// </summary>
/// <typeparam name="T">The type to convert to an enumeration</typeparam>
/// <typeparam name="TItem">The returning type of the IEnumerable items</typeparam>
/// <param name="expr">How to convert the type to IEnumerable</param>
/// <returns>The builder for chaining calls</returns>
public CompilerSettingsBuilder AddEnumerationConverter <T, TItem>(Expression <Func <T, IEnumerable <TItem> > > expr)
{
var @param = Expression.Parameter(typeof(object));
var convertLambda = Expression.Lambda <Func <object, IEnumerable> >(
Expression.Invoke(expr, Expression.Convert(param, typeof(T))),
@param);
EnumerationConverters[typeof(T)] = new EnumerationConverter(convertLambda, typeof(TItem));
return(this);
}
public void Test_ConvertHorizontalAlignment_VWGToHabanero_Right()
{
//---------------Set up test pack-------------------
//---------------Execute Test ----------------------
HorizontalAlignment horizontalAlignment =
EnumerationConverter.HorizontalAlignmentToHabanero(Gizmox.WebGUI.Forms.HorizontalAlignment.Right);
//---------------Test Result -----------------------
Assert.AreEqual(typeof(HorizontalAlignment), horizontalAlignment.GetType());
Assert.AreEqual(HorizontalAlignment.Right.ToString(), horizontalAlignment.ToString());
}
public void CanConvertTests(Type requestedType, bool expectedResult)
{
// Arrange
var target = new EnumerationConverter();
// Act
var result = target.CanConvert(requestedType);
// Assert
Assert.Equal(expectedResult, result);
}
public void ReadUnknownValuesTests()
{
// Arrange
var target = new EnumerationConverter();
// Act
Enumeration?result = null;
var utf8JsonBytes = Encoding.UTF8.GetBytes("\"UNKNOWN_VALUE\"");
var reader = new Utf8JsonReader(utf8JsonBytes, true, new JsonReaderState());
while (reader.Read())
{
result = target.Read(ref reader, typeof(SampleEnumeration), new JsonSerializerOptions());
}
// Assert
Assert.Null(result);
}
public ValueInfo GetInfo(string name)
{
Configuration.Argument arg = this.CurrentRecipe.ArgumentsByName[name];
if (arg == null)
{
return(null);
}
// We need to cache the ArgumentMetaData, otherwise the Wizard validation for repeated arguments will fail
if (!metaData.ContainsKey(arg))
{
ITypeResolutionService typeResolutionService =
(ITypeResolutionService)GetService(typeof(ITypeResolutionService));
Type argType = null;
if (typeResolutionService != null)
{
argType = typeResolutionService.GetType(arg.Type);
}
else
{
argType = Type.GetType(arg.Type);
}
TypeConverter converter = null;
if (arg.Converter != null)
{
Type converterType = null;
if (typeResolutionService != null)
{
converterType = typeResolutionService.GetType(arg.Converter.Type);
}
else
{
converterType = Type.GetType(arg.Converter.Type);
}
if (converterType != null)
{
converter = (TypeConverter)Activator.CreateInstance(converterType);
}
}
if (converter == null && argType != null)
{
TypeConverter cinstance = TypeDescriptor.GetConverter(argType);
if (argType.IsEnum)
{
converter = new EnumerationConverter(argType);
}
else if (argType.IsCOMObject ||
Attribute.GetCustomAttribute(argType, typeof(ComImportAttribute), true) != null)
{
converter = new ComObjectConverter(argType);
}
else if (cinstance != null && cinstance.GetType() != typeof(ComponentConverter))
{
// Only use converters that are not the generic ComponentConverter.
converter = cinstance;
}
}
ValueInfo argumentMetaData = new ValueInfo(
arg.Name,
arg.Required,
argType,
converter);
metaData[arg] = argumentMetaData;
}
return((ValueInfo)metaData[arg]);
}
public EnumerationConverterTests()
{
Sut = new EnumerationConverter <BooleanEnumeration>();
}
