static void CheckArgs(List <object> expectedArgs, ExpressionArgumentList actualArgs)
{
Assert.AreEqual(expectedArgs.Count, actualArgs.Arguments.Count);
for (int i = 0; i < expectedArgs.Count; i++)
{
var expected = expectedArgs[i];
var actual = actualArgs.Arguments[i];
if (actual is QuotedExpression quotedExpr)
{
actual = quotedExpr.Expression;
}
void AssertLiteral <T> (T expectedLit)
=> Assert.AreEqual(expectedLit, AssertCast <ExpressionArgumentLiteral <T> > (actual).Value);
switch (expected)
{
case int intVal:
AssertLiteral <long> (intVal);
break;
case bool boolVal:
AssertLiteral <bool> (boolVal);
break;
case float floatVal:
AssertLiteral <double> (floatVal);
break;
case string stringVal:
if (stringVal.Length > 0)
{
if (stringVal[0] == '$')
{
var prop = AssertCast <ExpressionProperty> (actual);
Assert.IsTrue(prop.IsSimpleProperty, "Expected property to be simple");
Assert.AreEqual(stringVal.Substring(1), prop.Name);
break;
}
if (stringVal[0] == '%')
{
var meta = AssertCast <ExpressionMetadata> (actual);
var metaName = meta.IsQualified ? meta.ItemName + meta.MetadataName : meta.MetadataName;
Assert.AreEqual(stringVal.Substring(1), metaName);
break;
}
}
if (actual is ExpressionText txt)
{
Assert.AreEqual(expected, txt.Value);
break;
}
AssertLiteral <string> (stringVal);
break;
}
}
}
public ExpressionItemFunctionInvocation(int offset, int length, ExpressionItemNode target, ExpressionFunctionName methodName, ExpressionArgumentList arguments)
: base(offset, length)
{
Target = target;
target.SetParent(this);
Function = methodName;
methodName?.SetParent(this);
Arguments = arguments;
arguments?.SetParent(this);
}
public ExpressionPropertyFunctionInvocation(int offset, int length, ExpressionPropertyNode target, ExpressionFunctionName function, ExpressionArgumentList arguments)
: base(offset, length)
{
Target = target;
target?.SetParent(this);
Function = function;
function?.SetParent(this);
Arguments = arguments;
arguments?.SetParent(this);
}
static void CheckArgs(List <object> expected, ExpressionArgumentList actual)
{
Assert.AreEqual(expected.Count, actual.Arguments.Count);
for (int i = 0; i < expected.Count; i++)
{
var arg = actual.Arguments [i];
if (arg is ExpressionText et)
{
Assert.AreEqual(expected [i], et.Value);
}
else
{
var lit = AssertCast <ExpressionArgumentLiteral> (arg);
Assert.AreEqual(expected [i], lit.Value);
}
}
}
