private static bool Execute(string[] args)
{
bool success = true;
string fileName = ConfigurationManager.AppSettings["filepath"];
if (fileName == null || fileName == "")
{
Console.WriteLine("No location stated in config file.");
}
List <ScriptResult> resultSet = new List <ScriptResult>();
List <Script> scripts = XmlHelper.MapScriptsFromXml(fileName);
for (int i = 0; i < scripts.Count; i++)
{
var script = scripts[i];
//Get contents of a fluent script file
string fileContent = FluentHelper.GetFluentScriptFileContent(script.Name);
// 1. Create instance of interpreter.
var ip = FluentHelper.GetInterpreter();
// 2. Check if emtpy file.
if (!string.IsNullOrEmpty(fileContent))
{
// 3. Execute script.
Console.Write("Executing : " + script.Name);
ip.Execute(fileContent);
// 4. Check result.
ScriptResult result = new ScriptResult();
result.FilePath = script.Name;
result.Duration = ip.Result.Duration.TotalMilliseconds;
result.Succeed = ip.Result.Success;
if (!result.Succeed)
{
WriteScriptError(script.Name, ip.Result.Message);
}
else
{
Console.WriteLine();
}
CheckExpectedResults(ip, fileContent, script, result);
if (!result.Succeed)
{
success = false;
WriteExpectedResultsFailedError();
// highlight
}
resultSet.Add(result);
}
}
// Writes result in Xml file
LogHelper.WriteInLogFile(resultSet);
return(success);
}
private static void CheckExpectedResults(Interpreter ip, string fileContent, Script script, ScriptResult result)
{
// Load the expected results from filecontent... if they are there.
LoadExpectedResults(fileContent, script, result);
// Check that each expected result is correct.
for (int z = 0; z < script.ExceptedValues.Count; z++)
{
var resultData = new ExpectedData();
var exceptedValue = script.ExceptedValues[z];
// Result after executing a script
object actualValue = ip.Memory.Get <object>(exceptedValue.Name);
actualValue = ((LObject)actualValue).GetValue();
// Check if the expected value matched
resultData.Actual = actualValue.ToString();
resultData.Expected = exceptedValue.Value;
resultData.Name = exceptedValue.Name;
resultData.IsMatched = FluentHelper.IsMatchingValue(actualValue, exceptedValue.DataType, exceptedValue.Value);
// The script result is a failure if at least 1 of the expected results fails.
if (resultData.IsMatched)
{
//Console.WriteLine(exceptedValue.Name + " matched : " + actualValue.ToString() + " with : " + exceptedValue.Value);
}
else
{
result.Succeed = false;
//Console.WriteLine(exceptedValue.Name + " did not match");
}
result.ExpectedResults.Add(resultData);
}
}
/// <summary>
/// Parses the day expression.
/// Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday
/// </summary>
/// <returns></returns>
public Expr ParseFunction(ParameterExpr expr)
{
_tokenIt.ExpectIdText(this.Name);
var expectParens = _tokenIt.NextToken.Token == Tokens.LeftParenthesis;
FluentHelper.ParseFuncParameters(expr.ParamListExpressions, _tokenIt, _parser, expectParens, true, _funcMeta);
return(expr);
}
private string GetResponseMessage(string responseMessage, Message message)
{
while (responseMessage == null)
{
FluentHelper.WaitFor(100).Milliseconds();
_messageDictionary.TryRemove(message.MessageId, out responseMessage);
}
return(responseMessage);
}
/// <summary>
/// This can not handle all idtoken based expressions.
/// </summary>
/// <param name="current"></param>
/// <returns></returns>
public override bool CanHandle(Token current)
{
if (!(current.Kind == TokenKind.Ident))
{
return(false);
}
var next = _tokenIt.Peek(1, false);
if (!(next.Token.Kind == TokenKind.Ident))
{
return(false);
}
// Check if multi-word function name.
// e.g. "refill inventory"
// 1. Is it a function call?
var tokens = _tokenIt.PeekConsequetiveIdsAppendedWithTokenCounts(true, _tokenIt.LLK);
_result = FluentHelper.MatchFunctionName(_parser.Context, tokens);
// Validate.
// 1. The function must exist.
if (!_result.Exists)
{
return(false);
}
// 2. Only fluentscript functions support wildcard.
if (_result.FunctionMode != MemberMode.FunctionScript)
{
return(false);
}
// 3. Has wildcard flag must be turned on.
var sym = _parser.Context.Symbols.GetSymbol(_result.Name) as SymbolFunction;
var func = sym.FuncExpr as FunctionExpr;
//var func = _parser.Context.Functions.GetByName(_result.Name);
if (!func.Meta.HasWildCard)
{
return(false);
}
return(true);
}
/// <summary>
/// This can not handle all idtoken based expressions.
/// </summary>
/// <param name="current"></param>
/// <returns></returns>
public override bool CanHandle(Token current)
{
if (!(current.Kind == TokenKind.Ident))
{
return(false);
}
var next = _tokenIt.Peek(1, false);
if (!(next.Token.Kind == TokenKind.Ident))
{
return(false);
}
// Check if multi-word function name.
var ids = _tokenIt.PeekConsequetiveIdsAppendedWithTokenCounts(true, _tokenIt.LLK);
_result = FluentHelper.MatchFunctionName(_parser.Context, ids);
return(_result.Exists);
}
