public NumericMethodExpression(IObjectExpression containingObject, MethodInfo methodInfo, ListExpression argumentsExpr)
{
this.containingObject = containingObject;
this.methodInfo = methodInfo;
this.argumentsExpr = argumentsExpr;
Type containingObjectType = containingObject.ObjectType;
Type returnType = methodInfo.ReturnType;
MethodInfo generateEvaluatorMethod;
ParameterInfo[] parameters = methodInfo.GetParameters();
switch (parameters.Length)
{
case 0:
generateEvaluatorMethod = GetType()
.GetMethod("GenerateFunctor0", BindingFlags.NonPublic | BindingFlags.Static)
.MakeGenericMethod(containingObjectType, returnType);
break;
case 1:
generateEvaluatorMethod = GetType()
.GetMethod("GenerateFunctor1", BindingFlags.NonPublic | BindingFlags.Static)
.MakeGenericMethod(containingObjectType, parameters[0].ParameterType, returnType);
break;
case 2:
generateEvaluatorMethod = GetType()
.GetMethod("GenerateFunctor2", BindingFlags.NonPublic | BindingFlags.Static)
.MakeGenericMethod(containingObjectType,
parameters[0].ParameterType,
parameters[1].ParameterType,
returnType);
break;
case 3:
generateEvaluatorMethod = GetType()
.GetMethod("GenerateFunctor3", BindingFlags.NonPublic | BindingFlags.Static)
.MakeGenericMethod(containingObjectType,
parameters[0].ParameterType,
parameters[1].ParameterType,
parameters[2].ParameterType,
returnType);
break;
default:
throw new NotSupportedException();
}
var generateEvaluatorDelegate = ReflectionHelper
.CreateDelegate <MethodInfo, ListExpression, Func <Dictionary <string, object>, object, double> >(generateEvaluatorMethod);
evaluator = generateEvaluatorDelegate(methodInfo, argumentsExpr);
}
public void CreateListWithVariableAsTail()
{
Context context = new Context();
var expr = new ListExpression(new IExpression[] { new ConstantExpression(1), new ConstantExpression(2) }, new VariableExpression(new Variable("Tail")));
var result = expr.Evaluate(context, true);
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(List));
Assert.AreEqual("[1,2|Tail]", result.ToString());
}
/// <summary>
/// Provides the expression text
/// </summary>
/// <returns></returns>
public override string ToString()
{
string retVal = OPERATOR + " " + ListExpression.ToString();
if (Condition != null)
{
retVal += " | " + Condition.ToString();
}
return(retVal);
}
/// <summary>
/// Provides the changes performed by this statement
/// </summary>
/// <param name="context">The context on which the changes should be computed</param>
/// <param name="changes">The list to fill with the changes</param>
/// <param name="explanation">The explanatino to fill, if any</param>
/// <param name="apply">Indicates that the changes should be applied immediately</param>
public override void GetChanges(InterpretationContext context, ChangeList changes, ExplanationPart explanation, bool apply)
{
Variables.IVariable variable = ListExpression.GetVariable(context);
if (variable != null)
{
// HacK : ensure that the value is a correct rigth side
// and keep the result of the right side operation
Values.ListValue listValue = variable.Value.RightSide(variable, false) as Values.ListValue;
variable.Value = listValue;
if (listValue != null)
{
Values.ListValue newListValue = new Values.ListValue(listValue);
int i = 0;
foreach (Values.IValue current in newListValue.Val)
{
IteratorVariable.Value = current;
if (conditionSatisfied(context))
{
break;
}
i += 1;
}
if (i < newListValue.Val.Count)
{
Values.IValue value = Value.GetValue(context);
if (value != null)
{
newListValue.Val[i] = value;
Rules.Change change = new Rules.Change(variable, variable.Value, newListValue);
changes.Add(change, apply);
explanation.SubExplanations.Add(new ExplanationPart(Root, change));
}
else
{
Root.AddError("Cannot find value for " + Value.ToString());
}
}
else
{
Root.AddError("Cannot find value in " + ListExpression.ToString() + " which satisfies " + Condition.ToString());
}
}
else
{
Root.AddError("Variable " + ListExpression.ToString() + " does not contain a list value");
}
}
else
{
Root.AddError("Cannot find variable for " + ListExpression.ToString());
}
}
public void ConstructUsing_FactoryMethod_Succeeds()
{
var expression = new ListExpression <Request, Item, Result>();
expression.ConstructUsing(() => new Request());
expression.ModelActivatorDefinition.Method.Should().NotBeNull();
expression.ModelActivatorDefinition.FactoryType.Should().BeNull();
expression.ModelActivatorDefinition.Factory.Should().BeNull();
expression.ModelActivatorDefinition.Method(typeof(Request)).Should().BeOfType <Request>();
}
public IMember GetValueFromList(ListExpression expression)
{
var contents = new List <IMember>();
foreach (var item in expression.Items.Take(MaxCollectionSize))
{
var value = GetValueFromExpression(item) ?? UnknownType;
contents.Add(value);
}
return(PythonCollectionType.CreateList(Module.Interpreter, contents, exact: expression.Items.Count <= MaxCollectionSize));
}
public void SortDirection_Succeeds()
{
var expression = new ListExpression <Request, Item, Result>();
expression.SortDirection();
var definition = expression.SortDirectionDefinition;
definition.RequestProperty.Should().BeNull();
definition.ResultProperty.Should().BeNull();
definition.DefaultValue.Should().BeNull();
definition.Name.Should().BeNull();
}
public void SortDirection_Property_DefaultValueByAttribute_Succeeds()
{
var expression = new ListExpression <Request, Item, Result>();
expression.SortDirection(x => x.Sortd);
var definition = expression.SortDirectionDefinition;
definition.RequestProperty.Name.Should().Be("Sortd");
definition.ResultProperty.Should().BeNull();
definition.DefaultValue.Should().Be(Direction.Ascending);
definition.Name.Should().BeNull();
}
public void SortDirection_Property_MapTo_Property_Succeeds()
{
var expression = new ListExpression <Request, Item, Result>();
expression.SortDirection(x => x.Ordd, x => x.MapTo(m => m.Ordd));
var definition = expression.SortDirectionDefinition;
definition.RequestProperty.Name.Should().Be("Ordd");
definition.ResultProperty.Name.Should().Be("Ordd");
definition.DefaultValue.Should().BeNull();
definition.Name.Should().BeNull();
}
public void Rows_Name_DefaultValue_Succeeds()
{
var expression = new ListExpression <Request, Item, Result>();
expression.Rows("Rows", x => x.DefaultValue(2));
var definition = expression.RowsDefinition;
definition.RequestProperty.Should().BeNull();
definition.ResultProperty.Should().BeNull();
definition.Name.Should().Be("Rows");
definition.DefaultValue.Should().Be(2);
}
public void Rows_Property_DefaultValueByAttribute_Succeeds()
{
var expression = new ListExpression <Request, Item, Result>();
expression.Rows(x => x.CurrentRows);
var definition = expression.RowsDefinition;
definition.RequestProperty.Name.Should().Be("CurrentRows");
definition.ResultProperty.Should().BeNull();
definition.Name.Should().BeNullOrWhiteSpace();
definition.DefaultValue.Should().Be(2);
}
public void Rows_Property_MapTo_Property_Succeeds()
{
var expression = new ListExpression <Request, Item, Result>();
expression.Rows(x => x.Rows, x => x.MapTo(m => m.Rows));
var definition = expression.RowsDefinition;
definition.RequestProperty.Name.Should().Be("Rows");
definition.ResultProperty.Name.Should().Be("Rows");
definition.Name.Should().BeNullOrWhiteSpace();
definition.DefaultValue.Should().BeNull();
}
public void Page_Name_Succeeds()
{
var expression = new ListExpression <Request, Item, Result>();
expression.Page("Page");
var definition = expression.PageDefinition;
definition.RequestProperty.Should().BeNull();
definition.ResultProperty.Should().BeNull();
definition.Name.Should().Be("Page");
definition.DefaultValue.Should().BeNull();
}
public void Page_Property_DefaultValue_Succeeds()
{
var expression = new ListExpression <Request, Item, Result>();
expression.Page(x => x.Page, x => x.DefaultValue(2));
var definition = expression.PageDefinition;
definition.RequestProperty.Name.Should().Be("Page");
definition.ResultProperty.Should().BeNull();
definition.Name.Should().BeNullOrWhiteSpace();
definition.DefaultValue.Should().Be(2);
}
public void Property_Property_DefaultValueByAttribute_Succeeds()
{
var expression = new ListExpression <Request, Item, Result>();
expression.Property(x => x.NotAQuery);
var definition = expression.PropertyDefinitions.First().Value;
definition.RequestProperty.Name.Should().Be("NotAQuery");
definition.ResultProperty.Should().BeNull();
definition.DefaultValue.Should().Be("Test");
definition.Ignore.Should().BeNull();
}
public void Property_Property_Ignore_Succeeds()
{
var expression = new ListExpression <Request, Item, Result>();
expression.Property(x => x.Query, x => x.Ignore());
var definition = expression.PropertyDefinitions.First(x => x.Key.Name == "Query").Value;
definition.RequestProperty.Name.Should().Be("Query");
definition.ResultProperty.Should().BeNull();
definition.DefaultValue.Should().BeNull();
definition.Ignore.Should().BeTrue();
}
public void Rows_Succeeds()
{
var expression = new ListExpression <Request, Item, Result>();
expression.Rows();
var definition = expression.RowsDefinition;
definition.RequestProperty.Should().BeNull();
definition.ResultProperty.Should().BeNull();
definition.Name.Should().BeNullOrWhiteSpace();
definition.DefaultValue.Should().BeNull();
}
public void SortDirection_Name_DefaultValue_Succeeds()
{
var expression = new ListExpression <Request, Item, Result>();
expression.SortDirection("Direction", x => x.DefaultValue(Direction.Ascending));
var definition = expression.SortDirectionDefinition;
definition.RequestProperty.Should().BeNull();
definition.ResultProperty.Should().BeNull();
definition.DefaultValue.Should().Be(Direction.Ascending);
definition.Name.Should().Be("Direction");
}
public static ListExpression ParseExpressionListStr(string code, out string remCode)
{
ListExpression expList = new ListExpression();
char[] codeArr = code.ToCharArray();
int subExpStart = 0;
for (int i = 0; i < code.Length; i++)
{
if (' ' == codeArr[i] ||
'\t' == codeArr[i])
{
string var = code.Substring(subExpStart, i - subExpStart);
if (!String.IsNullOrEmpty(var))
{
VariableExpression subExp = new VariableExpression {
Variable = var
};
expList.expList.Add(subExp);
}
subExpStart = i + 1;
continue;
}
if (')' == codeArr[i])
{
string var = code.Substring(subExpStart, i - subExpStart);
if (!String.IsNullOrEmpty(var))
{
VariableExpression subExp = new VariableExpression {
Variable = var
};
expList.expList.Add(subExp);
}
remCode = code.Substring(i + 1);
//return expList;
}
if ('(' == codeArr[i])
{
code = code.Substring(i + 1);
expList.expList.Add(ParseExpressionListStr(code, out remCode));
code = remCode;
}
}
remCode = "";
return(expList);
}
public async Task <IMember> GetValueFromListAsync(ListExpression expression, CancellationToken cancellationToken = default)
{
var contents = new List <IMember>();
foreach (var item in expression.Items)
{
var value = await GetValueFromExpressionAsync(item, cancellationToken) ?? UnknownType;
contents.Add(value);
}
return(PythonCollectionType.CreateList(Module.Interpreter, GetLoc(expression), contents));
}
protected virtual void EmitListExpression(ListExpression expression)
{
AppendFormat("( ");
for (int index = 0; index < expression.Expressions.Count; index++)
{
if (index > 0)
{
EmitListSeparator();
}
EmitExpression(expression.Expressions[index]);
}
AppendFormat(" )");
}
public void SortColumn_Property_DefaultValueByAttribute_Succeeds()
{
var expression = new ListExpression <Request, Item, Result>();
expression.SortColumn(x => x.Sortx);
var definition = expression.SortColumnDefinition;
definition.RequestProperty.Name.Should().Be("Sortx");
definition.ResultProperty.Should().BeNull();
definition.DefaultProperty.Should().BeNull();
definition.DefaultValue.Should().Be("Text");
definition.Name.Should().BeNull();
}
/// <summary>
/// Checks the statement for semantical errors
/// </summary>
public override void CheckStatement()
{
InterpretationContext context = new InterpretationContext(Root);
Types.Collection listExpressionType = ListExpression.GetExpressionType() as Types.Collection;
if (listExpressionType == null)
{
Root.AddError("Target does not references a list variable");
}
context.LocalScope.setVariable(IteratorVariable);
Call.CheckStatement(context);
}
/// <summary>
/// Provides the expression text
/// </summary>
/// <returns></returns>
public override string ToString()
{
string retVal = OPERATOR + " " + ListExpression.ToString();
if (Condition != null)
{
retVal += " | " + Condition.ToString();
}
retVal = retVal + " USING " + IteratorExpression.ToString() + " INITIAL_VALUE " + InitialValue.ToString();
return(retVal);
}
public void SortColumn_DefaultValue_Property_Succeeds()
{
var expression = new ListExpression <Request, Item, Result>();
expression.SortColumn("", x => x.DefaultTo(s => s.Text));
var definition = expression.SortColumnDefinition;
definition.RequestProperty.Should().BeNull();
definition.ResultProperty.Should().BeNull();
definition.DefaultProperty.Name.Should().Be("Text");
definition.DefaultValue.Should().BeNull();
definition.Name.Should().BeNull();
}
public Task <List <Model.Expression> > Handle(ListExpression message, CancellationToken cancellationToken)
{
return(repository
.Query
.Where(e => e.UserId == message.UserId)
.Select(e => new Model.Expression()
{
ExpressionString = e.ExpressionString,
Id = e.Id,
Name = e.Name
})
.ToListAsync());
}
public void ConstructUsing_ServiceProvider_Succeeds()
{
var expression = new ListExpression <Request, Item, Result>();
expression.ConstructUsing(sp => sp.GetRequiredService <Request>());
var sp = new ServiceCollection().AddSingleton <Request>().BuildServiceProvider();
expression.ModelActivatorDefinition.Method.Should().BeNull();
expression.ModelActivatorDefinition.FactoryType.Should().BeNull();
expression.ModelActivatorDefinition.Factory.Should().NotBeNull();
expression.ModelActivatorDefinition.Factory(sp, typeof(Request)).Should().BeOfType <Request>();
}
public override bool VisitListExpression(ListExpression expression)
{
nodeStack.Push(CurrentNode.Nodes.Add("ListExpression"));
CurrentNode.Tag = expression;
CurrentNode.EnsureVisible();
base.VisitListExpression(expression);
nodeStack.Pop();
return(true);
}
public void CreateListWithTail()
{
Context context = new Context();
var list = List.MakeList(new object[] { 3, 4 });
context.SetValue("Tail", list);
var expr = new ListExpression(new IExpression[] { new ConstantExpression(1), new ConstantExpression(2) }, new VariableExpression(new Variable("Tail")));
var result = expr.Evaluate(context);
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(List));
Assert.AreEqual("[1,2,3,4]", result.ToString());
}
private void AddNames(ListExpression list)
{
// only support the form of __all__ = [ ... ]
if (list == null)
{
return;
}
foreach (var item in list.Items)
{
AddName(item);
}
}
/// <summary>
/// Checks the statement for semantical errors
/// </summary>
public override void CheckStatement()
{
if (ListExpression != null)
{
if (ListExpression.Ref is Parameter)
{
Root.AddError("Cannot change the list value which is a parameter (" + ListExpression + ")");
}
Collection targetListType = ListExpression.GetExpressionType() as Collection;
if (targetListType != null)
{
Type elementType = Value.GetExpressionType();
if (elementType != targetListType.Type)
{
Root.AddError("Inserted element type does not corresponds to list type");
}
if (Condition != null)
{
Condition.CheckExpression();
BoolType conditionType = Condition.GetExpressionType() as BoolType;
if (conditionType == null)
{
Root.AddError("Condition does not evaluates to boolean");
}
}
else
{
Root.AddError("Condition should be provided");
}
}
else
{
Root.AddError("Cannot determine collection type of " + ListExpression);
}
}
else
{
Root.AddError("List should be specified");
}
if (Value != null)
{
Value.CheckExpression();
}
else
{
Root.AddError("Value should be specified");
}
}
/// <summary>
/// Provides the surface of this function if it has been statically defined
/// </summary>
/// <param name="context">the context used to create the surface</param>
/// <param name="xParam">The X axis of this surface</param>
/// <param name="yParam">The Y axis of this surface</param>
/// <param name="explain"></param>
/// <returns>The surface which corresponds to this expression</returns>
public override Surface CreateSurface(InterpretationContext context, Parameter xParam, Parameter yParam,
ExplanationPart explain)
{
Surface retVal = base.CreateSurface(context, xParam, yParam, explain);
Surface surface = InitialValue.CreateSurface(context, xParam, yParam, explain);
if (surface != null)
{
ListValue value = ListExpression.GetValue(context, explain) as ListValue;
if (value != null)
{
int token = PrepareIteration(context);
AccumulatorVariable.Value = surface.Function;
foreach (IValue v in value.Val)
{
if (v != EfsSystem.Instance.EmptyValue)
{
// All elements should always be != from EmptyValue
ElementFound = true;
IteratorVariable.Value = v;
if (ConditionSatisfied(context, explain))
{
MatchingElementFound = true;
AccumulatorVariable.Value = IteratorExpression.GetValue(context, explain);
}
}
NextIteration();
}
Function function = AccumulatorVariable.Value as Function;
if (function != null)
{
retVal = function.Surface;
}
else
{
throw new Exception("Expression does not reduces to a function");
}
EndIteration(context, explain, token);
}
}
else
{
throw new Exception("Cannot create surface for initial value " + InitialValue);
}
retVal.XParameter = xParam;
retVal.YParameter = yParam;
return(retVal);
}
public void CreateSimpleList()
{
Context context = new Context();
var expr = new ListExpression(new IExpression[] { new ConstantExpression(1), new AtomExpression(new Atom("x")), new AtomExpression(new Atom("y")) });
Assert.IsFalse(expr.HasVariable());
var result = expr.Evaluate(context, true);
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(List));
var list = (List)result;
Assert.IsNotNull(list.Head);
Assert.IsNotNull(list.Tail);
Assert.AreEqual("[1,x,y]", list.ToString());
}
public void GetPossibleMatchLengthsOf_List_AB_LookAhead_BB_NegativeLookAhead_AA_At_4_Returns2()
{
int index = 4;
int [] lengths = {1};
var expression =
// new ListExpression<char> (
// new LookBackExpression<char> (
new ListExpression<char> (
m_A,
m_B,
new LookAheadExpression<char> (new RepeatExpression<char>(m_B,2)),
new NegativeLookAheadExpression<char> (new RepeatExpression<char>(m_A,2))
)
// ),
// new GreedyRepeatExpression<char> (m_any)//,
// )
// m_B)
;
var possibleLengths = expression.GetPossibleMatchLengths (index).ToList ();
Assert.AreEqual (1, possibleLengths.Count, "Count");
Assert.AreEqual (2, possibleLengths[0], "PossibleLength[0]");
}
public void GetMatchesOf_LookBack_Start_GreedyAny_B_ForAAABBBReturnsAAABBB()
{
int index = 0;
int [] lengths = new []{6,5,4};
var expression =
new ListExpression<char> (
new LookBackExpression<char> (
new StartExpression<char> ()),
new GreedyRepeatExpression<char> (m_any),
m_B);
var list = AAABBB;
var matches = expression.GetMatches (list, index).ToList ();
Assert.AreEqual (lengths.Length, matches.Count, "Count");
for (int matchIndex = 0; matchIndex < matches.Count; matchIndex++)
{
var match = matches [matchIndex];
Assert.AreEqual (index, match.Index, "match.Index");
Assert.AreEqual (lengths[matchIndex], match.Length, "match.Length");
Assert.IsTrue (match.Success, "match.Success");
Assert.AreEqual (lengths[matchIndex], match.Items.Count, "match.Items.Count at");
for (int i = 0; i < lengths[matchIndex]; i++)
{
Assert.AreEqual (list[index + i], match.Items [i], "match.Items [" + i + "]");
}
}
}
public void GetMatchesOf_LookBack_List_AB_LookAhead_BB_GreedyAny_B_ForAAABBBReturnsBB()
{
int index = 4;
int [] lengths = {2,1};
var expression =
new ListExpression<char> (
new LookBackExpression<char> (
new ListExpression<char> (
m_A,
m_B,
new LookAheadExpression<char> (new RepeatExpression<char>(m_B,2)),
new NegativeLookAheadExpression<char> (new RepeatExpression<char>(m_A,2))
)),
new GreedyRepeatExpression<char> (m_any),
m_B);
var list = AAABBB;
var matches = expression.GetMatches (list, index).ToList ();
Assert.AreEqual (lengths.Length, matches.Count (), "Count");
for(int matchIndex = 0; matchIndex < lengths.Length; matchIndex++)
{
var match = matches[matchIndex];
Assert.AreEqual (index, match.Index, "match.Index");
Assert.AreEqual (lengths[matchIndex], match.Length, "match.Length");
Assert.IsTrue (match.Success, "match.Success");
Assert.AreEqual (lengths[matchIndex], match.Items.Count, "match.Items.Count at");
for (int i = 0; i < lengths[matchIndex]; i++)
{
Assert.AreEqual (list[index + i], match.Items [i], "match.Items [" + i + "]");
}
}
}
public void GetMatchesOf_LookBack_A_B_2_ForAAABBBReturnsBB()
{
int index = 3;
int length = 2;
var expression =
new ListExpression<char> (
new LookBackExpression<char> (m_A),
new RepeatExpression<char> (m_B, length));
var list = AAABBB;
var matches = expression.GetMatches (list, index).ToList ();
Assert.AreEqual (1, matches.Count (), "Count");
foreach (var match in matches)
{
Assert.AreEqual (index, match.Index, "match.Index");
Assert.AreEqual (length, match.Length, "match.Length");
Assert.IsTrue (match.Success, "match.Success");
Assert.AreEqual (length, match.Items.Count, "match.Items.Count");
for (int i = 0; i < length; i++)
{
Assert.AreEqual (list[index + i], match.Items [i], "match.Items [" + i + "]");
}
}
}
public void GetMatchesOf_GreedyA_NegativeLookAhead_B_ForAAABBBReturnsA()
{
var expression =
new ListExpression<char> (
new GreedyRepeatExpression<char> (m_A),
new NegativeLookAheadExpression<char> (m_B));
expression.AssertMatches ("AAABBB", @"A*(?!B)");
}
// ListExpression
public virtual bool Walk(ListExpression node) { return true; }
// listmaker: expression ( list_for | (',' expression)* [','] )
private Expression FinishListValue() {
string proceedingWhiteSpace = _tokenWhiteSpace;
var oStart = GetStart();
var oEnd = GetEnd();
int grouping = _tokenizer.GroupingLevel;
Expression ret;
bool ateRightBracket;
if (MaybeEat(TokenKind.RightBracket)) {
ret = new ListExpression();
ateRightBracket = true;
} else {
bool prevAllow = _allowIncomplete;
try {
_allowIncomplete = true;
Expression t0 = ParseExpression();
if (MaybeEat(TokenKind.Comma)) {
string commaWhiteSpace = _tokenWhiteSpace;
bool trailingComma;
List<string> listWhiteSpace;
var l = ParseTestListAsExpr(t0, out listWhiteSpace, out trailingComma);
ateRightBracket = Eat(TokenKind.RightBracket);
ret = new ListExpression(l.ToArray());
if (listWhiteSpace != null) {
AddListWhiteSpace(ret, listWhiteSpace.ToArray());
}
} else if (PeekToken(Tokens.KeywordForToken)) {
ret = FinishListComp(t0, out ateRightBracket);
} else {
ateRightBracket = Eat(TokenKind.RightBracket);
ret = new ListExpression(t0);
}
} finally {
_allowIncomplete = prevAllow;
}
}
if (_verbatim) {
AddPreceedingWhiteSpace(ret, proceedingWhiteSpace);
AddSecondPreceedingWhiteSpace(ret, _tokenWhiteSpace);
if (!ateRightBracket) {
AddErrorMissingCloseGrouping(ret);
}
}
var cStart = GetStart();
var cEnd = GetEnd();
ret.SetLoc(oStart, cEnd);
return ret;
}
public override void PostWalk(ListExpression node) { PostWalkWorker(node); }
// ListExpression
public override bool Walk(ListExpression node) { return ShouldWalkWorker(node); }
public void SupportsLookBack_For_LookBackSupported()
{
var expression = new ListExpression<char> (LookBackSupported);
Assert.IsTrue (expression.SupportsLookBack);
}
public void AnyLength_For_AnyLength_NotAnyLength()
{
var expression = new ListExpression<char> (AnyLength, NotAnyLength);
Assert.IsTrue (expression.AnyLength);
}
private IExpression ParseTerm()
{
Token token = this.NextToken();
IExpression expression = null;
if (token == null)
return null;
if (token.Type == TokenType.Variable)
{
expression = new VariableExpression(new Variable(token.Value));
if (this.TryParseToken(TokenType.Separator, "("))
{
var list = this.ParseExpressionList();
this.ParseToken(TokenType.Separator, ")");
expression = new CallExpression(expression, list);
}
}
else if (token.Type == TokenType.Atom)
{
if (token.Value == "false")
return new ConstantExpression(false);
if (token.Value == "true")
return new ConstantExpression(true);
if (token.Value == "fun")
return this.ParseFunExpression();
if (token.Value == "receive")
return this.ParseReceiveExpression();
expression = new AtomExpression(new Atom(token.Value));
if (this.TryParseToken(TokenType.Separator, "("))
{
var list = this.ParseExpressionList();
this.ParseToken(TokenType.Separator, ")");
expression = new CallExpression(expression, list);
}
else if (this.TryParseToken(TokenType.Separator, ":"))
{
var nexpression = new AtomExpression(new Atom(this.ParseAtom()));
this.ParseToken(TokenType.Separator, "(");
var list = this.ParseExpressionList();
this.ParseToken(TokenType.Separator, ")");
expression = new QualifiedCallExpression(expression, nexpression, list);
}
}
else if (token.Type == TokenType.Integer)
expression = new ConstantExpression(int.Parse(token.Value, CultureInfo.InvariantCulture));
else if (token.Type == TokenType.Real)
expression = new ConstantExpression(double.Parse(token.Value, CultureInfo.InvariantCulture));
else if (token.Type == TokenType.String)
expression = new ConstantExpression(token.Value);
else if (token.Type == TokenType.Separator && token.Value == "(")
{
expression = this.ParseSimpleExpression();
this.ParseToken(TokenType.Separator, ")");
}
else if (token.Type == TokenType.Separator && token.Value == "{")
{
var expressions = this.ParseExpressionList();
this.ParseToken(TokenType.Separator, "}");
expression = new TupleExpression(expressions);
}
else if (token.Type == TokenType.Separator && token.Value == "[")
{
var expressions = this.ParseExpressionList();
IExpression tailexpression = null;
if (this.TryParseToken(TokenType.Separator, "|"))
tailexpression = this.ParseSimpleExpression();
this.ParseToken(TokenType.Separator, "]");
expression = new ListExpression(expressions, tailexpression);
}
else
this.PushToken(token);
return expression;
}
public override bool Walk(ListExpression node) {
return UpdateLineInfo(node, true);
}
// ListExpression
public override bool Walk(ListExpression node) { return Location >= node.StartIndex && Location <= node.EndIndex; }
public void RaiseWhenUnboundVariable()
{
Context context = new Context();
var expr = new ListExpression(new IExpression[] { new ConstantExpression(1), new VariableExpression(new Variable("X")), new AtomExpression(new Atom("y")) });
Assert.IsTrue(expr.HasVariable());
try
{
expr.Evaluate(context, false);
Assert.Fail();
}
catch (Exception ex)
{
Assert.AreEqual("variable 'X' is unbound", ex.Message);
}
}
public void GetMatchesOf_A_3_BForAAABBB_GetEnumerator_MoveNextTooManyTimesThrows()
{
int index = 0;
var expression =
new ListExpression<char> (
new RepeatExpression<char> (m_A, 3),
m_B);
var list = AAABBB;
var matches = expression.GetMatches (list, index).ToList ();
var enumerator = matches.GetEnumerator ();
var current = enumerator.Current;
Assert.IsNull (current, "current");
for (int i = 0; i < 100; i++)
{
enumerator.MoveNext ();
}
}
public void GetMatchesOf_GreedyA_NegativeLookAheadBx3_ForAAABBBReturnsAA()
{
//string [] expectedValues = new [] {"AA", "A", ""};
//int index = 0;
var expression =
new ListExpression<char> (
new GreedyRepeatExpression<char> (m_A),
new NegativeLookAheadExpression<char> (
new RepeatExpression<char> (m_B, 3)));
expression.AssertMatches ("AAABBB", @"A*(?!B{3})");
//var list = AAABBB;
//var matches = expression.GetMatches (list, index).ToList ();
//Assert.AreEqual (expectedValues.Length, matches.Count (), "Count");
//for (int i = 0; i < matches.Count; i++)
//{
// var match = matches[i];
// int length = expectedValues[i].Length;
// Assert.AreEqual (index, match.Index, "match.Index");
// Assert.AreEqual (length, match.Length, "match.Length");
// Assert.IsTrue (match.Success, "match.Success");
// Assert.AreEqual (expectedValues[i], new string (match.Items.ToArray()), "match.Items.Count at");
//}
}
public void ConstructorSucceedsForNonNullInput()
{
var expression = new ListExpression<char> (m_a, m_any);
}
// ListExpression
public override bool Walk(ListExpression node) { return false; }
public void GetMatchesOf_A_3_BForAAABBBReturnsAAAB()
{
int index = 0;
int length = 4;
var expression =
new ListExpression<char> (
new GreedyRepeatExpression<char> (m_A, 3),
m_B);
var list = AAABBB;
var matches = expression.GetMatches (list, index).ToList ();
Assert.AreEqual (1, matches.Count (), "Count");
foreach (var match in matches)
{
Assert.AreEqual (index, match.Index, "match.Index");
Assert.AreEqual (length, match.Length, "match.Length");
Assert.IsTrue (match.Success, "match.Success");
Assert.AreEqual (length, match.Items.Count, "match.Items.Count at");
for (int i = 0; i < length; i++)
{
Assert.AreEqual (list[index + i], match.Items [i], "match.Items [" + i + "]");
}
}
}
public void ConstructorThrowArgumentNullExceptionForFirst()
{
var expression = new ListExpression<char> ((IExpression<char>) null, m_a);
}
public override bool Walk(ListExpression node) {
return WalkCollection(node, node.Items);
}
public void ConstructorThrowArgumentNullExceptionForSecond()
{
var expression = new ListExpression<char> (m_a, (IExpression<char>) null);
}
public override void PostWalk(ListExpression node) { }
public override bool Walk(ListExpression node) {
AddTagIfNecessary(node);
return base.Walk(node);
}
public virtual void PostWalk(ListExpression node) { }
public void RaiseIfUnboundVariableAsTail()
{
Context context = new Context();
var expr = new ListExpression(new IExpression[] { new ConstantExpression(1), new ConstantExpression(2) }, new VariableExpression(new Variable("Tail")));
try
{
expr.Evaluate(context, false);
Assert.Fail();
}
catch (Exception ex)
{
Assert.AreEqual("variable 'Tail' is unbound", ex.Message);
}
}
