public void ParseSeparatedSimpleAssignmentCommands()
{
Parser parser = new Parser("a=1;b=1;");
ICommand command = parser.ParseCommand();
Assert.IsNotNull(command);
Assert.That(command is SetVariableCommand);
SetVariableCommand scommand = (SetVariableCommand)command;
Assert.AreEqual("a", scommand.Name);
Assert.That(scommand.Expression is ConstantExpression);
ConstantExpression cexpr = (ConstantExpression)scommand.Expression;
Assert.AreEqual(1, cexpr.Value);
command = parser.ParseCommand();
Assert.IsNotNull(command);
Assert.That(command is SetVariableCommand);
scommand = (SetVariableCommand)command;
Assert.AreEqual("b", scommand.Name);
Assert.That(scommand.Expression is ConstantExpression);
cexpr = (ConstantExpression)scommand.Expression;
Assert.AreEqual(1, cexpr.Value);
Assert.IsNull(parser.ParseCommand());
}
public EventCommandVariable(SetVariableCommand refCommand, FrmEvent editor)
{
InitializeComponent();
mMyCommand = refCommand;
mEventEditor = editor;
mLoading = true;
InitLocalization();
//Numerics
cmbNumericCloneGlobalVar.Items.Clear();
cmbNumericCloneGlobalVar.Items.AddRange(ServerVariableBase.Names);
cmbNumericClonePlayerVar.Items.Clear();
cmbNumericClonePlayerVar.Items.AddRange(PlayerVariableBase.Names);
//Booleans
cmbBooleanCloneGlobalVar.Items.Clear();
cmbBooleanCloneGlobalVar.Items.AddRange(ServerVariableBase.Names);
cmbBooleanClonePlayerVar.Items.Clear();
cmbBooleanClonePlayerVar.Items.AddRange(PlayerVariableBase.Names);
if (mMyCommand.VariableType == VariableTypes.ServerVariable)
{
rdoGlobalVariable.Checked = true;
}
else
{
rdoPlayerVariable.Checked = true;
}
mLoading = false;
InitEditor();
}
public void ExecuteWhileCommand()
{
IExpression incrementX = new ArithmeticBinaryExpression(ArithmeticOperator.Add, new ConstantExpression(1), new VariableExpression("a"));
IExpression decrementY = new ArithmeticBinaryExpression(ArithmeticOperator.Subtract, new VariableExpression("b"), new ConstantExpression(1));
ICommand setX = new SetVariableCommand("a", incrementX);
ICommand setY = new SetVariableCommand("b", decrementY);
List <ICommand> commands = new List <ICommand>();
commands.Add(setX);
commands.Add(setY);
ICommand command = new CompositeCommand(commands);
IExpression yexpr = new VariableExpression("b");
WhileCommand whilecmd = new WhileCommand(yexpr, command);
Context context = new Context();
context.SetValue("a", 0);
context.SetValue("b", 5);
whilecmd.Execute(context);
Assert.AreEqual(0, context.GetValue("b"));
Assert.AreEqual(5, context.GetValue("a"));
}
public void ParseTwoLineSimpleAssignmentCommands()
{
Parser parser = new Parser("a=1\r\nb=1");
ICommand command = parser.ParseCommand();
Assert.IsNotNull(command);
Assert.IsInstanceOfType(command, typeof(SetVariableCommand));
SetVariableCommand scommand = (SetVariableCommand)command;
Assert.AreEqual("a", scommand.Name);
Assert.IsInstanceOfType(scommand.Expression, typeof(ConstantExpression));
ConstantExpression cexpr = (ConstantExpression)scommand.Expression;
Assert.AreEqual(1, cexpr.Value);
command = parser.ParseCommand();
Assert.IsNotNull(command);
Assert.IsInstanceOfType(command, typeof(SetVariableCommand));
scommand = (SetVariableCommand)command;
Assert.AreEqual("b", scommand.Name);
Assert.IsInstanceOfType(scommand.Expression, typeof(ConstantExpression));
cexpr = (ConstantExpression)scommand.Expression;
Assert.AreEqual(1, cexpr.Value);
Assert.IsNull(parser.ParseCommand());
}
private static string GetVariableModText(SetVariableCommand command, StringVariableMod mod)
{
var varvalue = "";
switch (mod.ModType)
{
case Enums.VariableMods.Set:
varvalue = Strings.EventCommandList.setvariable.ToString(mod.Value);
break;
case Enums.VariableMods.Replace:
varvalue = Strings.EventCommandList.replace.ToString(mod.Value, mod.Replace);
break;
}
if (command.VariableType == VariableTypes.PlayerVariable)
{
return(Strings.EventCommandList.playervariable.ToString(
PlayerVariableBase.GetName(command.VariableId), varvalue
));
}
if (command.VariableType == VariableTypes.ServerVariable)
{
return(Strings.EventCommandList.globalvariable.ToString(
ServerVariableBase.GetName(command.VariableId), varvalue
));
}
return(Strings.EventCommandList.invalid);
}
public void ExecuteCompositeCommand()
{
BindingEnvironment environment = new BindingEnvironment();
SetVariableCommand command1 = new SetVariableCommand("foo", new ConstantExpression("bar"));
SetVariableCommand command2 = new SetVariableCommand("one", new ConstantExpression(1));
SetVariableCommand command3 = new SetVariableCommand("bar", new VariableExpression("foo"));
List <ICommand> commands = new List <ICommand>();
commands.Add(command1);
commands.Add(command2);
commands.Add(command3);
CompositeCommand command = new CompositeCommand(commands);
environment.SetValue("foo", null);
environment.SetValue("one", null);
command.Execute(environment);
Assert.AreEqual("bar", environment.GetValue("foo"));
Assert.AreEqual(1, environment.GetValue("one"));
Assert.AreEqual("bar", environment.GetValue("bar"));
}
public void ExecuteForCommand()
{
ICommand setX = new SetVariableCommand("x", new ConstantExpression(0));
ICommand setY = new SetVariableCommand("y", new ConstantExpression(0));
List <ICommand> commands = new List <ICommand>();
commands.Add(setX);
commands.Add(setY);
ICommand initialCommand = new CompositeCommand(commands);
IExpression condition = new CompareExpression(ComparisonOperator.Less, new VariableExpression("x"), new ConstantExpression(6));
IExpression addXtoY = new ArithmeticBinaryExpression(ArithmeticOperator.Add, new VariableExpression("y"), new VariableExpression("x"));
ICommand addToY = new SetVariableCommand("y", addXtoY);
ICommand endCommand = new SetVariableCommand("x", new ArithmeticBinaryExpression(ArithmeticOperator.Add, new VariableExpression("x"), new ConstantExpression(1)));
ForCommand forcmd = new ForCommand(initialCommand, condition, endCommand, addToY);
Context context = new Context();
context.SetValue("y", null);
forcmd.Execute(context);
Assert.AreEqual(15, context.GetValue("y"));
}
public void ExecuteSetCommand()
{
SetVariableCommand command = new SetVariableCommand("foo", new ConstantExpression("bar"));
this.host.Execute(command);
Assert.AreEqual("bar", this.host.Machine.Environment.GetValue("foo"));
}
public void ExecuteSetLocalVariableCommandWithVariable()
{
Context context = new Context();
SetVariableCommand command = new SetVariableCommand("a", new ConstantExpression("bar"));
command.Execute(context);
Assert.AreEqual("bar", context.GetValue("a"));
}
public void SetVariable()
{
Context context = new Context();
SetVariableCommand command = new SetVariableCommand("One", new ConstantExpression(1));
object result = command.Execute(context);
Assert.AreEqual(1, result);
Assert.AreEqual(1, context.GetValue("One"));
}
public void SetVariable()
{
ICommand command = new SetVariableCommand("foo", new ConstantExpression("bar"));
ValueEnvironment environment = new ValueEnvironment();
command.Execute(null, environment);
Assert.AreEqual("bar", environment.GetValue("foo"));
}
public void ExecuteSetVariableCommand()
{
BindingEnvironment environment = new BindingEnvironment();
SetVariableCommand command = new SetVariableCommand("foo", new ConstantExpression("bar"));
command.Execute(environment);
Assert.AreEqual("bar", environment.GetValue("foo"));
}
//OLD
//public class SetSwitchCommand : EventCommand
//{
// public override EventCommandType Type { get; } = EventCommandType.SetSwitch;
// public SwitchTypes SwitchType { get; set; } = SwitchTypes.PlayerSwitch;
// public Guid SwitchId { get; set; }
// public bool Value { get; set; }
// public bool SyncParty { get; set; }
//}
private static JObject ConvertSetSwitchCommand(JObject obj)
{
var cmd = new SetVariableCommand();
if (obj.ContainsKey("SwitchId"))
{
cmd.VariableId = Guid.Parse(obj["SwitchId"].ToString());
}
if (obj.ContainsKey("SwitchType") && int.Parse(obj["SwitchType"].ToString()) == 1)
{
cmd.VariableType = VariableTypes.ServerVariable;
}
else
{
cmd.VariableType = VariableTypes.PlayerVariable;
}
if (obj.ContainsKey("SyncParty") && bool.Parse(obj["SyncParty"].ToString()))
{
cmd.SyncParty = true;
}
else
{
cmd.SyncParty = false;
}
var mod = new BooleanVariableMod();
cmd.Modification = mod;
if (obj.ContainsKey("Value") && bool.Parse(obj["Value"].ToString()))
{
mod.Value = true;
}
else
{
mod.Value = false;
}
var newJson = JsonConvert.SerializeObject(
cmd, typeof(EventCommand),
new JsonSerializerSettings()
{
Formatting = Formatting.None,
TypeNameHandling = TypeNameHandling.Auto,
DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate,
ObjectCreationHandling = ObjectCreationHandling.Replace
}
);
return(JObject.Parse(newJson));
}
public void ExecuteIfCommandWhenFalse()
{
IExpression condition = new ConstantExpression(false);
ICommand setCommand = new SetVariableCommand("x", new ConstantExpression(1));
IfCommand command = new IfCommand(condition, setCommand);
BindingEnvironment environment = new BindingEnvironment();
command.Execute(environment);
Assert.IsNull(environment.GetValue("x"));
}
public void ExecuteIfCommandWhenFalse()
{
IExpression condition = new ConstantExpression(false);
ICommand setCommand = new SetVariableCommand("a", new ConstantExpression(1));
IfCommand command = new IfCommand(condition, setCommand);
Context context = new Context();
command.Execute(context);
Assert.AreEqual(Undefined.Instance, context.GetValue("a"));
}
public async void SetsVariableWithMath()
{
_engine = new AutomationEngineInstance(null);
_setVariable = new SetVariableCommand();
VariableMethods.CreateTestVariable("1", _engine, "testValue", typeof(string));
VariableMethods.CreateTestVariable(null, _engine, "setVariable", typeof(string));
_setVariable.v_Input = "{testValue}+1";
_setVariable.v_OutputUserVariableName = "{setVariable}";
_setVariable.RunCommand(_engine);
Assert.Equal("2", (string)await "{setVariable}".EvaluateCode(_engine));
}
public void SetsVariable()
{
_engine = new AutomationEngineInstance(null);
_setVariable = new SetVariableCommand();
VariableMethods.CreateTestVariable("valueToSet", _engine, "testValue", typeof(string));
VariableMethods.CreateTestVariable(null, _engine, "setVariable", typeof(string));
_setVariable.v_Input = "{testValue}";
_setVariable.v_OutputUserVariableName = "{setVariable}";
_setVariable.RunCommand(_engine);
Assert.Equal("valueToSet", "{setVariable}".ConvertUserVariableToString(_engine));
}
private static string GetVariableModText(SetVariableCommand command, BooleanVariableMod mod)
{
var varvalue = "";
if (mod.DuplicateVariableId != Guid.Empty)
{
if (mod.DupVariableType == VariableTypes.PlayerVariable)
{
varvalue = Strings.EventCommandList.dupplayervariable.ToString(
PlayerVariableBase.GetName(mod.DuplicateVariableId)
);
}
else if (mod.DupVariableType == VariableTypes.ServerVariable)
{
varvalue = Strings.EventCommandList.dupglobalvariable.ToString(
ServerVariableBase.GetName(mod.DuplicateVariableId)
);
}
}
else
{
if (mod.Value == true)
{
varvalue = Strings.EventCommandList.setvariable.ToString(Strings.EventCommandList.True);
}
else
{
varvalue = Strings.EventCommandList.setvariable.ToString(Strings.EventCommandList.False);
}
}
if (command.VariableType == VariableTypes.PlayerVariable)
{
return(Strings.EventCommandList.playervariable.ToString(
PlayerVariableBase.GetName(command.VariableId), varvalue
));
}
if (command.VariableType == VariableTypes.ServerVariable)
{
return(Strings.EventCommandList.globalvariable.ToString(
ServerVariableBase.GetName(command.VariableId), varvalue
));
}
return(Strings.EventCommandList.invalid);
}
public void ForWithAddExpression()
{
var command = new SetVariableCommand("a", new ArithmeticBinaryExpression(ArithmeticOperator.Add, new VariableExpression("k"), new VariableExpression("a")));
var forcommand = new ForCommand("k", new ConstantExpression(new int[] { 1, 2, 3, 4 }), command);
Context context = new Context();
var result = forcommand.Execute(context);
Assert.IsNull(result);
Assert.AreEqual("k", forcommand.VariableName);
Assert.IsNotNull(forcommand.Expression);
Assert.IsNotNull(forcommand.Command);
Assert.AreEqual(4, context.GetValue("k"));
Assert.AreEqual(10, context.GetValue("a"));
}
public void ExecuteForEachCommand()
{
IExpression addToX = new ArithmeticBinaryExpression(ArithmeticOperator.Add, new VariableExpression("b"), new VariableExpression("a"));
ICommand setX = new SetVariableCommand("a", addToX);
IExpression values = new ConstantExpression(new int [] { 1, 2, 3 });
ForEachCommand foreachcmd = new ForEachCommand("b", values, setX);
Context context = new Context();
context.SetValue("a", 0);
foreachcmd.Execute(context);
Assert.AreEqual(6, context.GetValue("a"));
}
public void ExecuteForEachCommand()
{
IExpression addToX = new ArithmeticBinaryExpression(ArithmeticOperator.Add, new VariableExpression("y"), new VariableExpression("x"));
ICommand setX = new SetVariableCommand("x", addToX);
IExpression values = new ConstantExpression(new int [] { 1, 2, 3 });
ForEachCommand foreachcmd = new ForEachCommand("y", values, setX);
BindingEnvironment environment = new BindingEnvironment();
environment.SetValue("x", 0);
foreachcmd.Execute(environment);
Assert.AreEqual(6, environment.GetValue("x"));
}
public void CreateAndExecuteForCommand()
{
var command = new SetVariableCommand("a", new VariableExpression("k"));
var forcommand = new ForCommand("k", new ConstantExpression((new int[] { 1, 2, 3 })), command);
Context context = new Context();
context.SetValue("a", 0);
var result = forcommand.Execute(context);
Assert.IsNull(result);
Assert.AreEqual("k", forcommand.VariableName);
Assert.IsNotNull(forcommand.Expression);
Assert.IsNotNull(forcommand.Command);
Assert.AreEqual(3, context.GetValue("k"));
Assert.AreEqual(3, context.GetValue("a"));
}
public void WhileWithAddExpression()
{
var expression = new CompareExpression(ComparisonOperator.Less, new VariableExpression("a"), new ConstantExpression(10));
var inccommand = new SetVariableCommand("k", new ArithmeticBinaryExpression(ArithmeticOperator.Add, new VariableExpression("k"), new ConstantExpression(1)));
var addcommand = new SetVariableCommand("a", new ArithmeticBinaryExpression(ArithmeticOperator.Add, new VariableExpression("k"), new VariableExpression("a")));
var command = new CompositeCommand(new ICommand[] { inccommand, addcommand });
var whilecommand = new WhileCommand(expression, command);
Context context = new Context();
context.SetValue("a", 0);
context.SetValue("k", 0);
var result = whilecommand.Execute(context);
Assert.IsNull(result);
Assert.IsNotNull(whilecommand.Condition);
Assert.IsNotNull(whilecommand.Command);
Assert.AreEqual(4, context.GetValue("k"));
Assert.AreEqual(10, context.GetValue("a"));
}
public void IfFalseThen()
{
var condition = new CompareExpression(ComparisonOperator.Less, new VariableExpression("a"), new ConstantExpression(10));
var thencommand = new SetVariableCommand("k", new ConstantExpression(1));
var ifcommand = new IfCommand(condition, thencommand);
Context context = new Context();
context.SetValue("a", 10);
context.SetValue("k", 0);
var result = ifcommand.Execute(context);
Assert.IsNull(result);
Assert.IsNotNull(ifcommand.Condition);
Assert.IsNotNull(ifcommand.ThenCommand);
Assert.IsNull(ifcommand.ElseCommand);
Assert.AreEqual(0, context.GetValue("k"));
}
public void ExecuteCompositeCommand()
{
Context context = new Context();
SetVariableCommand command1 = new SetVariableCommand("a", new ConstantExpression("bar"));
SetVariableCommand command2 = new SetVariableCommand("b", new ConstantExpression(1));
SetVariableCommand command3 = new SetVariableCommand("c", new VariableExpression("a"));
List <ICommand> commands = new List <ICommand>();
commands.Add(command1);
commands.Add(command2);
commands.Add(command3);
CompositeCommand command = new CompositeCommand(commands);
command.Execute(context);
Assert.AreEqual("bar", context.GetValue("a"));
Assert.AreEqual(1, context.GetValue("b"));
Assert.AreEqual("bar", context.GetValue("c"));
}
public void ParseTwoCommands()
{
Parser parser = new Parser("a=1;\r\nb=1;");
IList <ICommand> commands = parser.ParseCommands();
Assert.IsNotNull(commands);
Assert.AreEqual(2, commands.Count);
ICommand command = commands[0];
Assert.IsNotNull(command);
Assert.That(command is SetVariableCommand);
SetVariableCommand scommand = (SetVariableCommand)command;
Assert.AreEqual("a", scommand.Name);
Assert.That(scommand.Expression is ConstantExpression);
ConstantExpression cexpr = (ConstantExpression)scommand.Expression;
Assert.AreEqual(1, cexpr.Value);
command = commands[1];
Assert.IsNotNull(command);
Assert.That(command is SetVariableCommand);
scommand = (SetVariableCommand)command;
Assert.AreEqual("b", scommand.Name);
Assert.That(scommand.Expression is ConstantExpression);
cexpr = (ConstantExpression)scommand.Expression;
Assert.AreEqual(1, cexpr.Value);
Assert.IsNull(parser.ParseCommand());
}
public void ParseNewVariableDefinitionAndInitialization()
{
ICommand command = ParseCommand("var x = 1;");
Assert.IsNotNull(command);
Assert.IsInstanceOfType(command, typeof(CompositeCommand));
CompositeCommand composite = (CompositeCommand)command;
Assert.AreEqual(2, composite.CommandCount);
Assert.IsInstanceOfType(composite.Commands.First(), typeof(VarCommand));
VarCommand varcmd = (VarCommand)composite.Commands.First();
Assert.AreEqual("x", varcmd.Name);
Assert.IsInstanceOfType(composite.Commands.ElementAt(1), typeof(SetVariableCommand));
SetVariableCommand setcmd = (SetVariableCommand)composite.Commands.ElementAt(1);
Assert.IsInstanceOfType(setcmd.Expression, typeof(ConstantExpression));
ConstantExpression consexpr = (ConstantExpression)setcmd.Expression;
Assert.AreEqual(1, consexpr.Value);
}
bool HandleCommand(Plugin plugin,
Sequence sequence,
XmlNode commandNode,
ref string errorString)
{
string sCommandName = commandNode.Name;
string sCommandDestination;
XmlNode commandSource1;
string sCommandSource1;
bool bIsCommandSource1Variable;
XmlNode commandSource2;
string sCommandSource2;
bool bIsCommandSource2Variable;
switch (sCommandName)
{
case "CatenateString":
sCommandDestination = commandNode.SelectSingleNode("Destination").InnerText;
if (plugin.GetVariable(sCommandDestination) == null)
{
errorString = "Invalid Catenate String Destination";
return(false);
}
commandSource1 = commandNode.SelectSingleNode("Source1");
if (commandSource1.HasChildNodes && commandSource1.ChildNodes[0].NodeType != XmlNodeType.Text)
{
sCommandSource1 = commandSource1.ChildNodes[0].InnerText;
bIsCommandSource1Variable = true;
if (plugin.GetVariable(sCommandSource1) == null)
{
errorString = "Invalid Catenate String Source1";
return(false);
}
}
else
{
sCommandSource1 = commandSource1.InnerText;
bIsCommandSource1Variable = false;
}
commandSource2 = commandNode.SelectSingleNode("Source2");
if (commandSource2.HasChildNodes && commandSource2.ChildNodes[0].NodeType != XmlNodeType.Text)
{
sCommandSource2 = commandSource2.ChildNodes[0].InnerText;
bIsCommandSource2Variable = true;
if (plugin.GetVariable(sCommandSource2) == null)
{
errorString = "Invalid Catenate String Source2";
return(false);
}
}
else
{
sCommandSource2 = commandSource2.InnerText;
bIsCommandSource2Variable = false;
}
CatenateStringCommand catenateCommand = new CatenateStringCommand(sCommandDestination,
sCommandSource1,
bIsCommandSource1Variable,
sCommandSource2,
bIsCommandSource2Variable);
sequence.AddCommand(catenateCommand);
break;
case "Click":
sCommandDestination = commandNode.SelectSingleNode("Destination").InnerText;
ClickElementWebDriverCommand clickCommand = new ClickElementWebDriverCommand(sCommandDestination);
sequence.AddCommand(clickCommand);
break;
case "GetItem":
string sGetItemName = commandNode.Attributes["name"].Value.ToLower();
string sGetItemParentElement = commandNode.SelectSingleNode("ParentElement").InnerText.ToLower();
string sGetItemSearchType = commandNode.SelectSingleNode("SearchType").InnerText.ToLower();
string sGetItemSearchValue = commandNode.SelectSingleNode("SearchValue").InnerText;
if (sGetItemName == "" || sGetItemSearchType == "" || sGetItemSearchValue == "")
{
errorString = "Invalid Get Item name \"" + sGetItemName;
return(false);
}
if (sGetItemParentElement != "" && plugin.GetWebElement(sGetItemParentElement) == null)
{
errorString = "Invalid Get Item parent element";
return(false);
}
if (sGetItemSearchType == "id")
{
GetElementByIdWebDriverCommand getItemByID = new GetElementByIdWebDriverCommand(sGetItemParentElement,
sGetItemName,
sGetItemSearchValue);
sequence.AddCommand(getItemByID);
}
else if (sGetItemSearchType == "xpath")
{
GetElementByXPathWebDriverCommand getItemByXPath = new GetElementByXPathWebDriverCommand(sGetItemParentElement,
sGetItemName,
sGetItemSearchValue);
sequence.AddCommand(getItemByXPath);
}
break;
case "GoBack":
GoBackWebDriverCommand goBackCommand = new GoBackWebDriverCommand();
sequence.AddCommand(goBackCommand);
break;
case "GoTo":
string sGoToDestination;
bool bGoToDestIsVariable;
if (commandNode.HasChildNodes && commandNode.ChildNodes[0].NodeType != XmlNodeType.Text)
{
sGoToDestination = commandNode.ChildNodes[0].InnerText.ToLower();
bGoToDestIsVariable = true;
if (plugin.GetVariable(sGoToDestination) == null)
{
errorString = "Invalid GoTo Destination";
return(false);
}
}
else
{
sGoToDestination = commandNode.InnerText;
bGoToDestIsVariable = false;
}
GoToWebDriverCommand goToCommand = new GoToWebDriverCommand(sGoToDestination, bGoToDestIsVariable);
sequence.AddCommand(goToCommand);
break;
case "Refresh":
RefreshWebDriverCommand refreshCommand = new RefreshWebDriverCommand();
sequence.AddCommand(refreshCommand);
break;
case "Type":
sCommandDestination = commandNode.SelectSingleNode("Destination").InnerText.ToLower();
string sTypeValue;
bool bTypeIsVariable;
if (commandNode.HasChildNodes && commandNode.ChildNodes[0].NodeType != XmlNodeType.Text)
{
sTypeValue = commandNode.SelectSingleNode("String").ChildNodes[0].InnerText.ToLower();
bTypeIsVariable = true;
if (plugin.GetVariable(sTypeValue) == null)
{
errorString = "Invalid Type Command Variable";
return(false);
}
}
else
{
sTypeValue = commandNode.InnerText;
bTypeIsVariable = false;
}
TypeElementWebDriverCommand typeCommand = new TypeElementWebDriverCommand(sCommandDestination, sTypeValue, bTypeIsVariable);
sequence.AddCommand(typeCommand);
break;
case "Sleep":
int dwSleepTime = Int32.Parse(commandNode.InnerText);
SleepCommand sleepCommand = new SleepCommand(dwSleepTime);
sequence.AddCommand(sleepCommand);
break;
case "SetVariable":
string sSetVariableName = commandNode.SelectSingleNode("Destination").InnerText;
string sSetVariableValue = commandNode.SelectSingleNode("String").InnerText;
SetVariableCommand setVariableCommand = new SetVariableCommand(sSetVariableName, sSetVariableValue);
sequence.AddCommand(setVariableCommand);
break;
case "IncreaseVariable":
string sIncreaseVariableName = commandNode.SelectSingleNode("Destination").InnerText;
int dwIncreaseVariableValue = Int32.Parse(commandNode.SelectSingleNode("String").InnerText);
IncreaseVariableCommand increaseVariableCommand = new IncreaseVariableCommand(sIncreaseVariableName, dwIncreaseVariableValue);
sequence.AddCommand(increaseVariableCommand);
break;
default:
errorString = "Invalid command " + sCommandName + " in sequence " + sequenceName;
return(false);
}
}
private void ParseCommand(string line)
{
if (string.IsNullOrEmpty(line))
{
return;
}
//NOTE: Parse in ascending length order!
if (line.Substring(0, 1).Equals("#"))
{
return;
}
if (line.Length < 4)
{
Warn("invalid command: {0}", line);
return;
}
if (line.Substring(0, 4).ToLower().Equals("quit") || line.Substring(0, 4).ToLower().Equals("exit"))
{
return;
}
var idx = line.IndexOf(' ');
string cmd;
if (idx < 0)
{
idx = 0;
cmd = line;
}
else
{
cmd = line.Substring(0, idx).ToLower();
}
var args = idx == 0 ? string.Empty : line.Substring(idx + 1).Trim();
if (CR.abort.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new AbortCommand();
c.Execute(context);
StopTimer(CR.abort + " " + args);
return;
}
if (CR.addalias.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new AddAliasCommand();
c.Execute(context, args);
StopTimer(CR.addalias + " " + args);
return;
}
if (CR.addindex.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new AddIndexCommand();
c.Execute(context, args);
StopTimer(CR.addindex + " " + args);
return;
}
if (CR.close.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new CloseCommand();
c.Execute(context, args);
StopTimer(CR.close + " " + args);
return;
}
if (CR.commit.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new CommitCommand();
c.Execute(context, args);
StopTimer(CR.commit + " " + args);
return;
}
if (CR.compactcontainer.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new CompactContainerCommand();
c.Execute(context, args);
StopTimer(CR.compactcontainer + " " + args);
return;
}
if (CR.contextquery.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new ContextQueryCommand();
c.Execute(context, args);
StopTimer(CR.contextquery + " " + args);
return;
}
if (CR.cquery.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new CQueryCommand();
c.Execute(context, args);
StopTimer(CR.cquery + " " + args);
return;
}
if (CR.createcontainer.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new CreateContainerCommand();
c.Execute(context, args);
StopTimer(CR.createcontainer + " " + args);
return;
}
if (CR.delindex.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new DeleteIndexCommand();
c.Execute(context, args);
StopTimer(CR.delindex + " " + args);
return;
}
if (CR.echo.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
Msg(args);
return;
}
if (CR.getdocuments.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new GetDocumentsCommand();
c.Execute(context, args);
StopTimer(CR.getdocuments + " " + args);
return;
}
if (CR.getmetadata.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new GetMetadataCommand();
c.Execute(context, args);
StopTimer(CR.getmetadata + " " + args);
return;
}
if (CR.help.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
var c = new HelpCommand();
c.Execute(args);
return;
}
if (CR.info.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new InfoCommand();
c.Execute(context, args);
StopTimer(CR.info + " " + args);
return;
}
if (CR.listindexes.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new ListIndexesCommand();
c.Execute(context, args);
StopTimer(CR.listindexes + " " + args);
return;
}
if (CR.lookupedgeindex.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new LookupEdgeIndexCommand();
c.Execute(context, args);
StopTimer(CR.lookupedgeindex + " " + args);
return;
}
if (CR.lookupindex.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new LookupIndexCommand();
c.Execute(context, args);
StopTimer(CR.lookupindex + " " + args);
return;
}
if (CR.lookupstats.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new LookupStatisticsCommand();
c.Execute(context, args);
StopTimer(CR.lookupstats + " " + args);
return;
}
if (CR.opencontainer.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new OpenContainerCommand();
c.Execute(context, args);
StopTimer(CR.opencontainer + " " + args);
return;
}
if (CR.preload.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new PreloadCommand();
c.Execute(context, args);
StopTimer(CR.preload + " " + args);
return;
}
if (CR.prepare.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new PrepareCommand();
c.Execute(context, args);
StopTimer(CR.prepare + " " + args);
return;
}
if (CR.print.IndexOf(cmd, 0, StringComparison.Ordinal) == 0 || cmd.ToLower().Equals("printnames"))
{
StartTimer();
var c = new PrintCommand();
c.Execute(context, cmd.Equals("printnames") ? "printnames " + args : args);
StopTimer(cmd.Equals("printnames") ? "printNames" : CR.print);
return;
}
if (CR.putdocuments.Equals(cmd))
{
StartTimer();
var c = new PutDocumentsCommand();
c.Execute(context, args);
StopTimer(CR.putdocuments + " " + args);
return;
}
if (CR.putdocument.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new PutDocumentCommand();
c.Execute(context, args);
StopTimer(CR.putdocument + " " + args);
return;
}
if (CR.query.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new QueryCommand();
c.Execute(context, args);
StopTimer(CR.query + " " + args);
return;
}
if (CR.queryplan.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new QueryPlanCommand();
c.Execute(context, args);
StopTimer(CR.queryplan + " " + args);
return;
}
if (CR.reindexcontainer.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new ReindexContainerCommand();
c.Execute(context, args);
StopTimer(CR.reindexcontainer + " " + args);
return;
}
if (CR.removealias.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new RemoveAliasCommand();
c.Execute(context, args);
StopTimer(CR.removealias + " " + args);
return;
}
if (CR.removecontainer.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new RemoveContainerCommand();
c.Execute(context, args);
StopTimer(CR.removecontainer + " " + args);
return;
}
if (CR.removedocument.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new RemoveDocumentCommand();
c.Execute(context, args);
StopTimer(CR.removedocument + " " + args);
return;
}
if (CR.run.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
var c = new RunCommand();
c.Execute(context, args);
var l2 = new List <string>(originalArgs)
{
"-s", c.Script
};
StartTimer();
Main(l2.ToArray());
StopTimer(CR.run + " " + args);
return;
}
if (CR.setautoindexing.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new SetAutoIndexingCommand();
c.Execute(context, args);
StopTimer(CR.setautoindexing + " " + args);
return;
}
if (CR.setbaseuri.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new SetBaseUriCommand();
c.Execute(context, args);
StopTimer(CR.setbaseuri + " " + args);
return;
}
if (CR.setignore.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
var c = new SetIgnoreCommand();
c.Execute(context, args);
ignoreErrors = c.Ignore;
return;
}
if (CR.setlazy.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new SetLazyCommand();
c.Execute(context, args);
StopTimer(CR.setlazy + " " + args);
return;
}
if (CR.setmetadata.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new SetMetadataCommand();
c.Execute(context, args);
StopTimer(CR.setmetadata + " " + args);
return;
}
if (CR.setnamespace.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new SetNamespaceCommand();
c.Execute(context, args);
StopTimer(CR.setnamespace + " " + args);
return;
}
if (CR.setprojection.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new SetProjectionCommand();
c.Execute(context, args);
StopTimer(CR.setprojection + " " + args);
return;
}
if (CR.setquerytimeout.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new SetQueryTimeoutCommand();
c.Execute(context, args);
StopTimer(CR.setquerytimeout + " " + args);
return;
}
if (CR.setvariable.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new SetVariableCommand();
c.Execute(context, args);
StopTimer(CR.setvariable + " " + args);
return;
}
if (CR.setverbose.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new SetVerboseCommand();
c.Execute(context, args);
StopTimer(CR.setverbose + " " + args);
return;
}
if (CR.sync.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
context.Sync();
StopTimer(CR.sync + " " + args);
return;
}
if (CR.time.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
time = true;
ParseCommand(args);
return;
}
if (CR.transaction.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new TransactionCommand();
c.Execute(context, args);
StopTimer(CR.transaction + " " + args);
return;
}
if (CR.upgradecontainer.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new UpgradeContainerCommand();
c.Execute(context, args);
StopTimer(CR.upgradecontainer + " " + args);
return;
}
Warn("Command not recognized: {0}", cmd);
}
public ICommand ParseCommand()
{
Token token = this.NextToken();
if (token == null)
{
return(null);
}
if (token.Type == TokenType.Separator)
{
if (token.Value == ";")
{
return(NullCommand.Instance);
}
if (token.Value == "{")
{
ICommand commands = new CompositeCommand(this.ParseCommands());
this.ParseToken("}", TokenType.Separator);
return(commands);
}
}
if (token.Type == TokenType.Name)
{
if (token.Value == "if")
{
return(this.ParseIfCommand());
}
if (token.Value == "while")
{
return(this.ParseWhileCommand());
}
if (token.Value == "class")
{
return(this.ParseDefineClassCommand());
}
if (token.Value == "return")
{
var expr = this.ParseExpression();
this.ParseToken(";", TokenType.Separator);
return(new ReturnCommand(expr));
}
if (token.Value == "void")
{
return(this.ParseDefineFunction(this.ParseName()));
}
if (token.Value == "main")
{
return(this.ParseDefineFunction(token.Value));
}
}
this.PushToken(token);
IExpression expression = this.ParseExpression();
if (expression == null)
{
return(null);
}
token = this.NextToken();
if (token != null && token.Type == TokenType.Name && this.IsTypeExpression(expression))
{
if (this.TryPeekToken("(", TokenType.Separator))
{
return(this.ParseDefineFunction(token.Value));
}
return(this.ParseDefineVariableCommand(expression, token.Value));
}
ICommand command = null;
if (expression is VariableExpression && token.Type == TokenType.Operator && token.Value == "=")
{
string name = ((VariableExpression)expression).Name;
IExpression expr = this.ParseExpression();
command = new SetVariableCommand(name, expr);
token = this.NextToken();
}
else
{
command = new ExpressionCommand(expression);
}
if (token == null || token.Type != TokenType.Separator || token.Value != ";")
{
throw new ParserException("Expected ';'");
}
return(command);
}
