private static void VerifyArrayExpression(IIdiomaticAssertion assertion, NewArrayExpression arrayExpression)
{
foreach (var expression in arrayExpression.Expressions)
{
VerifyExpression(assertion, expression);
}
}
public static void VerifyType <T>(this IIdiomaticAssertion assertion)
{
if (assertion == null)
{
throw new ArgumentNullException("assertion");
}
assertion.Verify(typeof(T));
}
public static void Verify <T>(this IIdiomaticAssertion assertion, Expression <Func <T, object> > memberSelector)
{
if (assertion == null)
{
throw new ArgumentNullException(nameof(assertion));
}
if (memberSelector == null)
{
throw new ArgumentNullException(nameof(memberSelector));
}
VerifyExpression(assertion, memberSelector.Body);
}
private static void VerifyMemberExpression(IIdiomaticAssertion assertion, MemberExpression memberExpression)
{
switch (memberExpression.Member)
{
case PropertyInfo propertyInfo:
assertion.Verify(propertyInfo);
break;
case FieldInfo fieldInfo:
assertion.Verify(fieldInfo);
break;
default:
throw new ArgumentException("The expression is not a valid member selector");
}
}
private static void VerifyExpression(IIdiomaticAssertion assertion, Expression expression)
{
switch (expression)
{
case MemberExpression memberExpression:
VerifyMemberExpression(assertion, memberExpression);
break;
case NewArrayExpression arrayExpression:
VerifyArrayExpression(assertion, arrayExpression);
break;
default:
throw new ArgumentException("The expression is not a valid member selector");
}
}
/// <summary>
/// Verify guard clauses for the first constructor having parameters
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="assertion"></param>
/// <param name="actions"></param>
public static void VerifyConstructorHavingParameter <T>(this IIdiomaticAssertion assertion)
{
var constructor = typeof(T).GetConstructors().First(c => c.GetParameters().Any());
assertion.Verify(constructor);
}
/// <summary>
/// Verify guard clauses for the first constructor
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="assertion"></param>
/// <param name="actions"></param>
public static void VerifyConstructors <T>(this IIdiomaticAssertion assertion)
{
var constructor = typeof(T).GetConstructors();
assertion.Verify(constructor);
}
public static void VerifyProperties(this IIdiomaticAssertion assertion, params Expression <Func <object> >[] actions)
{
var memberInfos = actions.Select(expression => expression.GetMemberInfo()).ToArray();
assertion.Verify(memberInfos);
}
public static void VerifyProperty <T1>(this IIdiomaticAssertion assertion, Expression <Func <T1> > action)
{
assertion.Verify(action.GetMemberInfo());
}
public static void Verify <TSut, T1, T2>(this IIdiomaticAssertion assertion, Expression <Action <TSut, T1, T2> > action)
{
assertion.Verify(((MethodCallExpression)action.Body).Method);
}
public void Method(IIdiomaticAssertion arg1, object arg2)
{
}
public ClassForIndirectReference(IIdiomaticAssertion arg1, object arg2)
{
}
