public void GetHashCode_WhenNotEquivalent_AreNotEqual()
{
var info1 = new ExecutableParameterInfo("name", "one", "two");
var info2 = new ExecutableParameterInfo("name", "one", "three");
info1.GetHashCode().Should().NotBe(info2.GetHashCode());
}
public object Create(Type targetType, ExecutableParameterInfo parameter)
{
var constructor = GetWrappedBasicConstructor(targetType);
var parameterType = GetWrappedBasicType(targetType);
return(constructor.Invoke(new [] { Convert.ChangeType(parameter.SingleValue, parameterType) }));
}
public void GetHashCode_WhenEquivalentButValuesInDifferentOrder_AreEqual()
{
var info1 = new ExecutableParameterInfo("name", "one", "two");
var info2 = new ExecutableParameterInfo("name", "two", "one");
info1.GetHashCode().Should().Be(info2.GetHashCode());
}
public void Equals_WhenEquivalent_ReturnsTrue()
{
var info = new ExecutableParameterInfo("name", "one", "two");
var result = info.Equals(new ExecutableParameterInfo("name", "one", "two"));
result.Should().BeTrue();
}
public object Create(Type targetType, ExecutableParameterInfo parameter)
{
if (parameter.SingleValue.GetType() != typeof(string))
{
throw new InvalidOperationException($"Unsupported type for {typeof(IExecutable)}:{targetType} parameter conversion: {parameter.SingleValue.GetType()}");
}
var constructor = GetWrappedGuidConstructor(targetType);
return(constructor.Invoke(new[] { (object)new Guid(parameter.SingleValue) }));
}
public InspectionExecutableParameterInfo(
ExecutableParameterInfo result
)
{
var pName = result.PropertyName;
var tName = result.TypeName;
this.PropertyName = ArgumentValidator.ValidateNotEmpty(nameof(pName), pName);
this.TypeName = ArgumentValidator.ValidateNotEmpty(nameof(tName), tName);
this.IsRequired = result.IsRequired;
this.IsEnum = result.IsEnum;
}
public object Create(Type targetType, ExecutableParameterInfo parameter)
{
try
{
return(targetType == typeof(object)
? parameter.SingleValue
: Convert.ChangeType(parameter.SingleValue, targetType));
}
catch (Exception ex)
{
throw new InvalidOperationException(
$"Unable to convert {parameter.SingleValue} to type {targetType}", ex);
}
}
public object Create(Type targetType, ExecutableParameterInfo parameter)
{
if (targetType == typeof(DateTime?))
{
if (string.IsNullOrWhiteSpace(parameter.SingleValue))
{
return(null);
}
}
if (DateTime.TryParse(parameter.SingleValue,
_culture, DateTimeStyles.None, out var result))
{
return(result);
}
throw new InvalidOperationException("Invalid DateTime format.");
}
public object Create(Type targetType, ExecutableParameterInfo parameter)
{
var genericType = targetType.GetGenericArguments().First();
var paramFactory = _parameterValueFactories.ToList()
.FirstOrDefault(f => f.Qualifies(genericType));
if (paramFactory == null)
{
throw new NoQualifyingParameterValueFactoryException(genericType.Name);
}
var result = (IList)Activator.CreateInstance(typeof(List <>).MakeGenericType(genericType));
parameter.Values
.Select(v => paramFactory.Create(genericType, new ExecutableParameterInfo(string.Empty, v)))
.ToList().ForEach(v => result.Add(v));
return(result);
}
public object Create(Type targetType, ExecutableParameterInfo parameter)
{
var genericType = targetType.GetGenericArguments().First();
var paramFactory = _parameterValueFactories.ToList()
.FirstOrDefault(f => f.Qualifies(genericType));
if (paramFactory == null)
{
throw new NoQualifyingParameterValueFactoryException(genericType.Name);
}
var paramValues = parameter.Values
.Select((v, i) => new
{
Index = i,
Value = paramFactory.Create(genericType, new ExecutableParameterInfo(string.Empty, v))
}).ToList();
var result = Array.CreateInstance(genericType, paramValues.Count);
paramValues.ForEach(pv => result.SetValue(pv.Value, pv.Index));
return(result);
}
public object Create(Type targetType, ExecutableParameterInfo parameter)
{
return(new Guid(parameter.SingleValue));
}
