/// <summary>
/// Called to finish construction when an instruction has been instantiated by
/// a factory and had its properties set.
/// This can check the integrity of the instruction or perform other initialization tasks.
/// </summary>
/// <param name="xn">XML node describing the instruction</param>
/// <param name="con">Parent xml node instruction</param>
/// <returns></returns>
public override bool finishCreation(XmlNode xn, Context con)
{
// finish factory construction
m_log.isNotNull(Path, makeNameTag() + "Hover-over instruction must have a path.");
m_log.isTrue(Path != "", makeNameTag() + "Hover-over instruction must have a non-empty path.");
return true;
}
public override void Execute()
{
base.Execute();
Context con = (Context)Ancestor(typeof(Context));
isNotNull(con, makeNameTag() + " must occur in some context");
m_Result = Condition.EvaluateList(m_conditions);
if (m_Result == true)
{
XmlNode xThen = m_elt.SelectSingleNode("then");
if (xThen != null)
{ // then may have been created via do-once before this
if (m_then == null)
{ // not created yet
Context thenCon = new Context();
thenCon.ModelNode = con.ModelNode;
thenCon.Parent = this;
string rest = XmlFiler.getAttribute(xThen, "wait");
if (rest != null) thenCon.Rest = Convert.ToInt32(rest);
foreach (XmlNode child in xThen.ChildNodes)
{ // MakeShell adds the ins to thenCon
XmlInstructionBuilder.MakeShell(child, thenCon);
}
SetThen(thenCon);
}
m_then.Execute();
}
}
else
{
XmlNode xElse = m_elt.SelectSingleNode("else");
if (xElse != null)
{ // else may have been created via do-once before this
if (m_else == null)
{ // not created yet
Context elseCon = new Context();
elseCon.ModelNode = con.ModelNode;
elseCon.Parent = this;
string rest = XmlFiler.getAttribute(xElse, "wait");
if (rest != null) elseCon.Rest = Convert.ToInt32(rest);
foreach (XmlNode child in xElse.ChildNodes)
{ // MakeShell adds the ins to elseCon
XmlInstructionBuilder.MakeShell(child, elseCon);
}
SetElse(elseCon);
}
m_else.Execute();
}
}
Logger.getOnly().result(this);
Finished = true; // tell do-once it's done
}
/// <summary>
/// Creates a variable to be referenced by other instruction attributes.
/// </summary>
/// <param name="xn">The XML repersentation of the instruction to be checked</param>
/// <param name="con">The current context object</param>
public static Var CreateVar(XmlNode xn, Context con)
{
Var var = new Var();
var.Id = XmlFiler.getAttribute(xn, "id");
Logger.getOnly().isNotNull(var.Id, "Var instruction must have a id.");
Logger.getOnly().isTrue(var.Id != "", "Var instruction must have a non-empty id.");
string s = XmlFiler.getAttribute(xn, "set");
// select should be move to var.execute so it is dynamic!
string select = XmlFiler.getAttribute(xn, "select");
if (select != null && select != "")
{ // the variable can only have one text node or one other node assigned to it.
XmlNodeList pathNodes = selectNodes(con, select, "var"+var.Id);
Logger.getOnly().isNotNull(pathNodes, "var " + var.Id + " select='" + select + "' returned no result");
if (pathNodes.Count > 0)
{ // append first node to set string
XmlNode modNode = pathNodes.Item(0);
// which property of the node to get?
string prop = null;
string propName = XmlFiler.getAttribute(xn, "prop");
if (propName == null && modNode is XmlElement) propName = "path";
if (propName == null) propName = "value";
if (propName != null && propName == "value") prop = XmlPath.ResolveModelPath(modNode, modNode.Value);
if (propName != null && propName == "name") prop = modNode.Name;
if (propName != null && propName == "type") prop = modNode.NodeType.ToString();
if (propName != null && propName == "path")
{
XmlPath xp = new XmlPath(modNode);
if (xp.isValid()) prop = xp.Path;
else prop = null;
}
s += prop;
}
else s += "#NoSelection#";
}
var.Set = s;
string when = XmlFiler.getAttribute(xn, "when");
string add = XmlFiler.getAttribute(xn, "add");
if (add != null) var.Add = add;
if (var.Set == null && when == null)
{ // if there is a select/when then don't complain if the select found nothing
Logger.getOnly().isNotNull(var.Add, "Var " + var.Id +
@" set, select or add must result in a string or number value unless when=""exists"" is set.");
if (select != null && select != "") var.Set = @"#not-"+when+@"#";
}
string exists = XmlFiler.getAttribute(xn, "file-exists");
if (exists != null) var.FileExists = exists;
string rest = XmlFiler.getAttribute(xn, "wait");
if (rest != null) var.Rest = Convert.ToInt32(rest);
AddInstruction(xn, var, con);
return var;
}
/// <summary>
/// Called to finish construction when an instruction has been instantiated by
/// a factory and had its properties set.
/// This can check the integrity of the instruction or perform other initialization tasks.
/// </summary>
/// <param name="xn">XML node describing the instruction</param>
/// <param name="con">Parent xml node instruction</param>
/// <returns></returns>
public override bool finishCreation(XmlNode xn, Context con)
{
// finish factory construction
Logger.getOnly().isNotNull(m_pathName, @"include must have a 'from' path.");
Logger.getOnly().isTrue(m_pathName != "", @"include must have a 'from' path.");
string pathname = TestState.getOnly().getScriptPath() + @"\" + m_pathName;
XmlDocument doc = new XmlDocument();
doc.PreserveWhitespace = true; // allows <insert> </insert>
try { doc.Load(pathname); }
catch (System.IO.FileNotFoundException ioe)
{
Logger.getOnly().fail(@"include '" + pathname + "' not found: " + ioe.Message);
}
catch (System.Xml.XmlException xme)
{
Logger.getOnly().fail(@"include '" + pathname + "' not loadable: " + xme.Message);
}
XmlNode include = doc["include"];
Logger.getOnly().isNotNull(include, "Missing document element 'include'.");
XmlElement conEl = con.Element;
// clone insert and add it before so there's an insert before and after
// after adding elements, delete the "after" one
XmlDocumentFragment df = xn.OwnerDocument.CreateDocumentFragment();
df.InnerXml = xn.OuterXml;
conEl.InsertBefore(df, xn);
foreach (XmlNode xnode in include.ChildNodes)
{
string image = xnode.OuterXml;
if (image.StartsWith("<"))
{
XmlDocumentFragment dfrag = xn.OwnerDocument.CreateDocumentFragment();
dfrag.InnerXml = xnode.OuterXml;
conEl.InsertBefore(dfrag, xn);
}
}
conEl.RemoveChild(xn);
//Logger.getOnly().paragraph(Utilities.attrText(textImage));
return true;
}
/// <summary>
/// Called to finish construction when an instruction has been instantiated by
/// a factory and had its properties set.
/// This can check the integrity of the instruction or perform other initialization tasks.
/// </summary>
/// <param name="xn">XML node describing the instruction</param>
/// <param name="con">Parent xml node instruction</param>
/// <returns></returns>
public override bool finishCreation(XmlNode xn, Context con)
{
// finish factory construction
m_log.isNotNull(Id, makeNameTag() + " instruction must have a id.");
m_log.isTrue(Id != "", makeNameTag() + " instruction must have a non-empty id.");
if (m_select != null && m_select != "")
{ // the variable can only have one text node or one other node assigned to it.
m_log.isNotNull(con, "makeNameTag() + select has no context.");
XmlNodeList pathNodes = Instructionator.selectNodes(con, m_select, "var" + Id);
m_log.isNotNull(pathNodes, makeNameTag() + "var " + Id + " select='" + m_select + "' returned no result");
if (pathNodes.Count > 0)
{ // append first node to set string
XmlNode modNode = pathNodes.Item(0);
string prop = null;
// which property of the node to get?
if (m_prop == null && modNode is XmlElement) m_prop = "path";
if (m_prop == null) m_prop = "value";
if (m_prop != null && m_prop == "value") prop = XmlPath.ResolveModelPath(modNode, modNode.Value);
if (m_prop != null && m_prop == "name") prop = modNode.Name;
if (m_prop != null && m_prop == "type") prop = modNode.NodeType.ToString();
if (m_prop != null && m_prop == "path")
{
XmlPath xp = new XmlPath(modNode);
if (xp.isValid()) prop = xp.Path;
else prop = null;
}
m_set += prop;
}
else m_set += "#NoSelection#";
}
if (Set == null && m_when == null)
{ // if there is a select/when then don't complain if the select found nothing
m_log.isNotNull(Add, makeNameTag() + Id +
@" set, select or add must result in a string or number value unless when=""exists"" is set.");
if (m_select != null && m_select != "") Set = @"#not-" + m_when + @"#";
}
return true;
}
public void SetThen (Context thenCon)
{
isNotNull(thenCon,"A then clause is null");
m_then = thenCon;
}
/// <summary>
/// Creates a match-strings instruction and parses its content.
/// </summary>
/// <param name="xn">The XML repersentation of the instruction to be checked</param>
/// <param name="con">The current context object</param>
static MatchStrings CreateMatchStrings(XmlNode xn, Context con)
{
MatchStrings ms = new MatchStrings();
ms.Of = XmlFiler.getAttribute(xn, "of");
Logger.getOnly().isNotNull(ms.Of, "Match-strings instruction must have an 'of'.");
Logger.getOnly().isTrue(ms.Of != "", "Match-strings instruction must have a non-empty 'of'.");
ms.To = XmlFiler.getAttribute(xn, "to");
Logger.getOnly().isNotNull(ms.To, "Match-strings instruction must have a 'to'.");
Logger.getOnly().isTrue(ms.To != "", "Match-strings instruction must have a non-empty 'to'.");
ms.Expect = XmlFiler.getAttribute(xn, "expect");
ms.OnPass = XmlFiler.getAttribute(xn, "on-pass");
ms.OnFail = XmlFiler.getAttribute(xn, "on-fail");
string rest = XmlFiler.getAttribute(xn, "wait");
if (rest != null) ms.Rest = Convert.ToInt32(rest);
InterpretMessage(ms,xn.ChildNodes);
AddInstruction(xn, ms, con);
return ms;
}
/// <summary>
/// Creates a sound instruction.
/// </summary>
/// <param name="xn">The XML repersentation of the instruction to be checked</param>
/// <param name="con">The current context object</param>
static Sound CreateSound(XmlNode xn, Context con)
{
Sound sound = CreateSound(xn);
AddInstruction(xn, sound, con);
return sound;
}
/// <summary>
/// Creates a select-text instruction.
/// </summary>
/// <param name="xn">The XML repersentation of the instruction to be checked</param>
/// <param name="con">The current context object</param>
static SelectText CreateSelectText(XmlNode xn, Context con)
{
SelectText sel = new SelectText();
sel.Path = XmlFiler.getAttribute(xn, "path");
Logger.getOnly().isNotNull(sel.Path, "Select-text instruction must have a path.");
Logger.getOnly().isTrue(sel.Path != "", "Select-text instruction must have a non-empty path.");
sel.Loc = XmlFiler.getAttribute(xn, "loc");
string sAt = XmlFiler.getAttribute(xn, "at");
if (sAt == null) sel.At = 0;
else sel.At = Convert.ToInt32(sAt);
string sRun = XmlFiler.getAttribute(xn, "run");
if (sRun == null) sel.Run = 0;
else sel.Run = Convert.ToInt32(sRun);
string rest = XmlFiler.getAttribute(xn, "wait");
if (rest != null) sel.Rest = Convert.ToInt32(rest);
AddInstruction(xn, sel, con);
return sel;
}
/// <summary>
/// Creates a glimpse-extra instruction and parses its content.
/// </summary>
/// <param name="xn">The XML repersentation of the instruction to be checked</param>
/// <param name="con">The current context object</param>
static GlimpseExtra CreateGlimpseExtra(XmlNode xn, Context con)
{
GlimpseExtra glimpse = new GlimpseExtra();
glimpse.Path = XmlFiler.getAttribute(xn, "path");
glimpse.SelectPath = XmlFiler.getAttribute(xn, "select-path");
glimpse.Names = XmlFiler.getAttribute(xn, "names");
glimpse.Select = XmlFiler.getAttribute(xn, "select");
glimpse.OnPass = XmlFiler.getAttribute(xn, "on-pass");
glimpse.OnFail = XmlFiler.getAttribute(xn, "on-fail");
string rest = XmlFiler.getAttribute(xn, "wait");
if (rest != null) glimpse.Rest = Convert.ToInt32(rest);
InterpretMessage(glimpse,xn.ChildNodes);
AddInstruction(xn, glimpse, con);
return glimpse;
}
/// <summary>
/// Creates a time context instruction.
/// </summary>
/// <param name="xn">The XML repersentation of the instruction to be checked</param>
/// <param name="con">The current context object</param>
static TimeContext CreateTime(XmlNode xn, Context con)
{
string expect = XmlFiler.getAttribute(xn, "expect");
TimeContext timeIt = new TimeContext(Convert.ToInt32(expect));
string desc = XmlFiler.getAttribute(xn, "desc");
timeIt.Decsription = desc;
/* foreach (XmlNode xnChild in xn.ChildNodes)
{
InterpretChild(xnChild, timeIt);
}
*/
timeIt.ModelNode = con.ModelNode;
AddInstruction(xn, timeIt, con);
return timeIt;
}
/// <summary>
/// Creates a doOnce context instruction.
/// </summary>
/// <param name="xn">The XML repersentation of the instruction to be checked</param>
/// <param name="con">The current context object</param>
static DoOnceContext CreateDoOnceContext(XmlNode xn, Context con)
{
string maxWait = XmlFiler.getAttribute(xn, "until");
// Assert.IsTrue(maxWait == null || maxWait.Length == 0, "Do-Once context must have an until attribute.");
Logger.getOnly().isNotNull(maxWait, "Do-Once context must have an until attribute.");
Logger.getOnly().isTrue(maxWait != "", "Do-Once context must have a non-empty 'until' attribute.");
DoOnceContext doOnce = new DoOnceContext(Convert.ToInt32(maxWait));
doOnce.WaitingFor = XmlFiler.getAttribute(xn, "waiting-for");
doOnce.OnPass = XmlFiler.getAttribute(xn, "on-pass");
doOnce.OnFail = XmlFiler.getAttribute(xn, "on-fail");
doOnce.ModelNode = con.ModelNode;
AddInstruction(xn, doOnce, con);
/* foreach (XmlNode xnChild in xn.ChildNodes)
{
InterpretChild(xnChild, doOnce);
}
*/
return doOnce;
}
/// <summary>
/// Creates a startup context instruction.
/// </summary>
/// <param name="xn">The XML repersentation of the instruction to be checked</param>
/// <param name="con">The current context object</param>
static StartUpContext CreateStartUpContext(XmlNode xn, Context con)
{
StartUpContext su = new StartUpContext();
su.OnPass = XmlFiler.getAttribute(xn, "on-pass");
su.OnFail = XmlFiler.getAttribute(xn, "on-fail");
su.ModelNode = con.ModelNode;
AddInstruction(xn, su, con);
/* foreach (XmlNode xnChild in xn.ChildNodes)
{
InterpretChild(xnChild, su);
}
*/
return su;
}
static Model CreateModelContext(XmlNode xn, Context con)
{ // check select and path attributes
Model model = new Model();
model.Select = XmlFiler.getAttribute(xn, "select");
Logger.getOnly().isTrue(model.Select != null, "Model instruction must have a select attribute.");
Logger.getOnly().isTrue(model.Select != "", "Model instruction must have a non-empty select.");
model.When = XmlFiler.getAttribute(xn, "when");
model.OnPass = XmlFiler.getAttribute(xn, "on-pass");
model.OnFail = XmlFiler.getAttribute(xn, "on-fail");
string rest = XmlFiler.getAttribute(xn, "wait");
if (rest != null) model.Rest = Convert.ToInt32(rest);
AddInstruction(xn, model, con);
return model;
}
/// <summary>
/// Creates an application context instruction.
/// </summary>
/// <param name="xn">The XML repersentation of the instruction to be checked</param>
/// <param name="con">The current context object</param>
static ApplicationContext CreateApplicationContext(XmlNode xn, Context con)
{
ApplicationContext ac = new ApplicationContext();
ac.Run = XmlFiler.getAttribute(xn, "run");
if (ac.Run == null || ac.Run == "") ac.Run = "ok";
ac.Gui = XmlFiler.getAttribute(xn, "gui");
ac.Path = XmlFiler.getAttribute(xn, "path");
ac.Exe = XmlFiler.getAttribute(xn, "exe");
ac.Args = XmlFiler.getAttribute(xn, "args");
ac.Work = XmlFiler.getAttribute(xn, "work");
ac.Title = XmlFiler.getAttribute(xn, "title");
string src = XmlFiler.getAttribute(xn, "source");
if (src != null) ac.SetSource(src);
ac.Close = XmlFiler.getAttribute(xn, "close");
ac.OnPass = XmlFiler.getAttribute(xn, "on-pass");
ac.OnFail = XmlFiler.getAttribute(xn, "on-fail");
string rest = XmlFiler.getAttribute(xn, "wait");
if (rest != null) ac.Rest = Convert.ToInt32(rest);
ac.Configure(); // set model root for use by children
ac.ModelNode = con.ModelNode;
AddInstruction(xn, ac, con);
return ac;
}
/// <summary>
/// Creates an insert instruction and parses its content.
/// </summary>
/// <param name="xn">The XML repersentation of the instruction to be checked</param>
/// <param name="con">The current context object</param>
static Insert CreateInsert(XmlNode xn, Context con)
{
Insert insert = new Insert();
string rest = XmlFiler.getAttribute(xn, "wait");
if (rest != null) insert.Rest = Convert.ToInt32(rest);
string pause = XmlFiler.getAttribute(xn, "pause");
if (pause != null) insert.Pause = Convert.ToInt32(pause);
foreach (XmlNode node in xn.ChildNodes)
{
switch (node.Name)
{
case "#text":
case "#whitespace":
case "#significant-whitespace": // a nameless text node
insert.Text = node.Value;
break;
default:
Logger.getOnly().fail("Insert instruction must have something to insert.");
break;
}
}
Logger.getOnly().isNotNull(insert.Text, "Insert instruction must have some content.");
Logger.getOnly().isTrue(insert.Text != "", "Insert instruction must have non-empty content.");
AddInstruction(xn, insert, con);
return insert;
}
/// <summary>
/// Creates a desktop context instruction.
/// </summary>
/// <param name="xn">The XML repersentation of the instruction to be created</param>
/// <param name="con">The current context object</param>
static Desktop CreateDesktopContext(XmlNode xn, Context con)
{
Desktop dt = new Desktop();
string rest = XmlFiler.getAttribute(xn, "wait");
if (rest != null) dt.Rest = Convert.ToInt32(rest);
dt.OnPass = XmlFiler.getAttribute(xn, "on-pass");
dt.OnFail = XmlFiler.getAttribute(xn, "on-fail");
dt.ModelNode = con.ModelNode;
AddInstruction(xn, dt, con);
/* foreach (XmlNode xnChild in xn.ChildNodes)
{
InterpretChild(xnChild, dt);
}
*/
return dt;
}
/// <summary>
/// Creates an if instruction and parses its content.
/// </summary>
/// <param name="xn">The XML repersentation of the instruction to be checked</param>
/// <param name="ts">The TestState containing the named instruction list</param>
/// <param name="con">The current context object</param>
static If CreateIf(XmlNode xn, Context con)
{
Logger.getOnly().isNotNull(xn["condition"], "If instruction must have a condition.");
If ifIns = new If();
string rest = XmlFiler.getAttribute(xn, "wait");
if (rest != null) ifIns.Rest = Convert.ToInt32(rest);
AddInstruction(xn, ifIns, con);
foreach (XmlNode elt in xn.ChildNodes)
{
switch (elt.Name)
{
case "condition":
Condition cond = CreateCondition(elt);
ifIns.AddCondition(cond);
break;
}
}
return ifIns;
}
/// <summary>
/// Creates a dialog context instruction.
/// </summary>
/// <param name="xn">The XML repersentation of the instruction to be created</param>
/// <param name="con">The current context object</param>
static DialogContext CreateDialogContext(XmlNode xn, Context con)
{
DialogContext dc = new DialogContext();
dc.Name = XmlFiler.getAttribute(xn, "name");
dc.Title = XmlFiler.getAttribute(xn, "title");
dc.Select = XmlFiler.getAttribute(xn, "select");
Logger.getOnly().isTrue(dc.Title != null || dc.Select != null, "Dialog context '" + dc.Name + "' has no Title or selected model.");
string rest = XmlFiler.getAttribute(xn, "wait");
if (rest != null) dc.Rest = Convert.ToInt32(rest);
string until = XmlFiler.getAttribute(xn, "until");
if (until != null) dc.Until = Convert.ToInt32(until);
dc.OnPass = XmlFiler.getAttribute(xn, "on-pass");
dc.OnFail = XmlFiler.getAttribute(xn, "on-fail");
dc.ModelNode = con.ModelNode;
AddInstruction(xn, dc, con);
/* foreach (XmlNode xnChild in xn.ChildNodes)
{
InterpretChild(xnChild, dc);
}
*/
return dc;
}
/// <summary>
/// Creates a registry instruction.
/// </summary>
/// <param name="xn">The XML repersentation of the instruction to be checked</param>
/// <param name="con">The current context object</param>
static Registry CreateRegistry(XmlNode xn, Context con)
{
string key = XmlFiler.getAttribute(xn, "key");
string data = XmlFiler.getAttribute(xn, "data");
Logger.getOnly().isTrue(key != null && data != null, "Registry instruction must have a key and data.");
Registry reg = new Registry(key, data);
AddInstruction(xn, reg, con);
return reg;
}
/// <summary>
/// Creates a beep instruction.
/// </summary>
/// <param name="xn">The XML repersentation of the instruction to be created</param>
/// <param name="con">The current context object</param>
static Beep CreateBeep(XmlNode xn, Context con)
{
Beep beep = CreateBeep(xn);
AddInstruction(xn, beep, con);
return beep;
}
/// <summary>
/// Creates a file-comp instruction and parses its content.
/// </summary>
/// <param name="xn">The XML repersentation of the instruction to be checked</param>
/// <param name="con">The current context object</param>
static FileComp CreateFileComp(XmlNode xn, Context con)
{
FileComp fc = new FileComp();
fc.Of = XmlFiler.getAttribute(xn, "of");
Logger.getOnly().isNotNull(fc.Of, "File-Comp instruction must have an 'of'.");
Logger.getOnly().isTrue(fc.Of != "", "File-Comp instruction must have a non-empty 'of'.");
fc.To = XmlFiler.getAttribute(xn, "to");
Logger.getOnly().isNotNull(fc.To, "File-Comp instruction must have a 'to'.");
Logger.getOnly().isTrue(fc.To != "", "File-Comp instruction must have a non-empty 'to'.");
fc.OnPass = XmlFiler.getAttribute(xn, "on-pass");
fc.OnFail = XmlFiler.getAttribute(xn, "on-fail");
string rest = XmlFiler.getAttribute(xn, "wait");
if (rest != null) fc.Rest = Convert.ToInt32(rest);
InterpretMessage(fc,xn.ChildNodes);
AddInstruction(xn, fc, con);
return fc;
}
/// <summary>
/// Creates a garbage instruction.
/// </summary>
/// <param name="xn">The XML repersentation of the instruction to be created</param>
/// <param name="con">The current context object</param>
static Garbage CreateGarbage(XmlNode xn, Context con)
{
Garbage gc = CreateGarbage(xn);
AddInstruction(xn, gc, con);
return gc;
}
/// <summary>
/// Called to finish construction when an instruction has been instantiated by
/// a factory and had its properties set.
/// This can check the integrity of the instruction or perform other initialization tasks.
/// </summary>
/// <param name="xn">XML node describing the instruction</param>
/// <param name="con">Parent xml node instruction</param>
/// <returns></returns>
public override bool finishCreation(XmlNode xn, Context con)
{
// finish factory construction
m_log.isNotNull(Of, "Match-strings instruction must have an 'of'.");
m_log.isTrue(Of != "", "Match-strings instruction must have a non-empty 'of'.");
m_log.isNotNull(To, "Match-strings instruction must have a 'to'.");
m_log.isTrue(To != "", "Match-strings instruction must have a non-empty 'to'.");
InterpretMessage(xn.ChildNodes);
return true;
}
/// <summary>
/// Creates a click instruction.
/// </summary>
/// <param name="xn">The XML repersentation of the instruction to be created</param>
/// <param name="con">The current context object</param>
static Click CreateClick(XmlNode xn, Context con)
{ // check select and path attributes
Click click = new Click();
click.Select = XmlFiler.getAttribute(xn, "select");
click.Path = XmlFiler.getAttribute(xn, "path");
Logger.getOnly().isTrue(click.Path != null || click.Select != null, "Click instruction must have a path or select.");
Logger.getOnly().isTrue(click.Path != "" || click.Select != "", "Click instruction must have a non-empty path or select.");
click.When = XmlFiler.getAttribute(xn, "when");
string until = XmlFiler.getAttribute(xn, "until");
if (until != null) click.Until = Convert.ToInt32(until);
string repeat = XmlFiler.getAttribute(xn, "repeat");
if (repeat != null) click.Repeat = Convert.ToInt32(repeat);
click.Side = XmlFiler.getAttribute(xn, "side");
click.For = XmlFiler.getAttribute(xn, "for");
string rest = XmlFiler.getAttribute(xn, "wait");
if (rest != null)
{
if (rest.ToLower().Equals("no")) click.Rest = -1;
else click.Rest = Convert.ToInt32(rest);
}
string dx = XmlFiler.getAttribute(xn, "dx");
if (dx != null) click.Dx = Convert.ToInt32(dx);
string dy = XmlFiler.getAttribute(xn, "dy");
if (dy != null) click.Dy = Convert.ToInt32(dy);
AddInstruction(xn, click, con);
return click;
}
public void SetElse (Context elseCon)
{
isNotNull(elseCon,"An else clause is null");
m_else = elseCon;
}
/// <summary>
/// Creates a hover-over instruction.
/// </summary>
/// <param name="xn">The XML repersentation of the instruction to be checked</param>
/// <param name="con">The current context object</param>
static HoverOver CreateHoverOver(XmlNode xn, Context con)
{
HoverOver hover = new HoverOver();
hover.Path = XmlFiler.getAttribute(xn, "path");
Logger.getOnly().isNotNull(hover.Path, "Hover-over instruction must have a path.");
Logger.getOnly().isTrue(hover.Path != "", "Hover-over instruction must have a non-empty path.");
string rest = XmlFiler.getAttribute(xn, "wait");
if (rest != null) hover.Rest = Convert.ToInt32(rest);
AddInstruction(xn, hover, con);
return hover;
}
/// <summary>
/// Interpret a node as some kind of Instruction.
/// Make the class but don't process its child instructions if any.
/// Don't execute the instruction.
/// Some instructions do not return objects:
/// bug - a bug annotation element
/// #comment
/// #significant-whitespace
/// #whitespace
/// The ones with '#' are generated by the XML parser.
/// </summary>
/// <param name="xn">The XML repersentation of the instruction to be checked</param>
/// <param name="con">The current context object</param>
/// <returns>Returns an unexecuted instruction or null</returns>
static public Instruction MakeShell(XmlNode xn, Context con)
{
// number the context if it doesn't have one yet to avoid depth-first numbering.
if (con != null && con.Number == -1) con.Number = TestState.getOnly().IncInstructionCount;
switch(xn.Name)
{ // cases listed in ascending alphabetical order
case "beep":
return CreateBeep(xn, con);
case "click":
return CreateClick(xn, con);
case "do-once":
return CreateDoOnceContext(xn, con);
case "file-comp":
return CreateFileComp(xn, con);
case "garbage":
return CreateGarbage(xn, con);
case "glimpse":
return CreateGlimpse(xn, con);
case "glimpse-extra":
return CreateGlimpseExtra(xn, con);
case "hover-over":
return CreateHoverOver(xn, con);
case "include":
return CreateInclude(xn, con);
case "insert":
return CreateInsert(xn, con);
case "if":
return CreateIf(xn, con);
case "match-strings":
return CreateMatchStrings(xn, con);
case "model":
return CreateModelContext(xn, con);
case "monitor-time":
return CreateTime(xn, con);
case "on-application":
return CreateApplicationContext(xn, con);
case "on-desktop":
return CreateDesktopContext(xn, con);
case "on-dialog":
return CreateDialogContext(xn, con);
case "on-startup":
return CreateStartUpContext(xn, con);
case "registry":
return CreateRegistry(xn, con);
case "skip":
return new Skip();
case "sound":
return CreateSound(xn, con);
case "select-text":
return CreateSelectText(xn, con);
case "var":
return CreateVar(xn, con);
case "bug": // bug annotation element
case "#comment": // ignore comments, etc..
case "#significant-whitespace":
case "#whitespace":
return null;
default:
Logger.getOnly().fail("Unexpected instruction <"+xn.Name+"> found");
break;
}
return null;
}
/// <summary>
/// Creates a glimpse instruction and parses its content.
/// </summary>
/// <param name="xn">The XML repersentation of the instruction to be checked</param>
/// <param name="con">The current context object</param>
static Glimpse CreateGlimpse(XmlNode xn, Context con)
{
Glimpse glimpse = new Glimpse();
glimpse.Path = XmlFiler.getAttribute(xn, "path");
glimpse.Select = XmlFiler.getAttribute(xn, "select");
Logger.getOnly().isTrue(glimpse.Path != null || glimpse.Select != null, "Glimpse instruction must have a path or select.");
Logger.getOnly().isTrue(glimpse.Path != "" || glimpse.Select != "", "Glimpse instruction must have a non-empty path or select.");
glimpse.Prop = XmlFiler.getAttribute(xn, "prop");
glimpse.Expect = XmlFiler.getAttribute(xn, "expect");
glimpse.OnPass = XmlFiler.getAttribute(xn, "on-pass");
glimpse.OnFail = XmlFiler.getAttribute(xn, "on-fail");
string rest = XmlFiler.getAttribute(xn, "wait");
if (rest != null) glimpse.Rest = Convert.ToInt32(rest);
InterpretMessage(glimpse, xn.ChildNodes);
AddInstruction(xn, glimpse, con);
return glimpse;
}
/// <summary>
/// Called to finish construction when an instruction has been instantiated by
/// a factory and had its properties set.
/// This can check the integrity of the instruction or perform other initialization tasks.
/// </summary>
/// <param name="xn">XML node describing the instruction</param>
/// <param name="con">Parent xml node instruction</param>
/// <returns></returns>
public override bool finishCreation(XmlNode xn, Context con)
{
// finish factory construction
m_log.isTrue(Path != null || Select != null, makeNameTag() + "Click instruction must have a path or select.");
m_log.isTrue(Path != "" || Select != "", makeNameTag() + "Click instruction must have a non-empty path or select.");
return true;
}
/// <summary>
/// Read instruction file.
/// Interpret script nodes according to tne instruction file.
/// Make the class but don't process its child instructions if any.
/// Don't execute the instruction.
/// </summary>
/// <param name="xn">The XML repersentation of the instruction to be checked</param>
/// <param name="con">The current context object</param>
/// <returns>Returns an unexecuted instruction or null</returns>
static public Instruction MakeShell(XmlNode xn, Context con)
{
Logger.getOnly().isNotNull(xn, "Instruction can't be created from nothing!");
if (m_actPrototypes == null) {
Logger.getOnly().fail("Can not create: No instruction prototypes loaded.");
return null;
}
Instruction FluffedInstruction = null;
// number the context if it doesn't have one yet to avoid depth-first numbering.
if (con != null && con.Number == -1) con.Number = TestState.getOnly().IncInstructionCount;
// figure out what to do with this node
switch (xn.Name)
{
case "#comment": // ignore comments, etc..
case "#significant-whitespace":
case "#whitespace":
case "#text":
break;
default: // Find the instruction prototype based on node name.
InsPrototype prototype = findPrototype(xn.Name, m_actPrototypes);
if (prototype != null)
{
var AtValues = new ArrayList();
ArrayList atts = prototype.Attributes;
Logger.getOnly().startList("Instruction " + prototype.Name);
XmlAttributeCollection atNodes = xn.Attributes;
if (atNodes != null && atts != null)
{
foreach (XmlAttribute atx in atNodes)
{ // find each attribute in the prototype
string atValue = null;
foreach (Attribute at in atts)
{
if (at.Name == atx.Name)
{ // its this one
atValue = XmlFiler.getAttribute(xn, at.Name);
if (atValue != null && at.Name != "log")
{ // log is dealt with in AddInstruction()
var atVar = new Attribute(at.Name, atValue, at.Value);
AtValues.Add(atVar);
Logger.getOnly().listItem(" " + atx.Name + "=" + atValue);
break;
}
}
}
if (atValue == null)
{ // This attribute is not expected: make it a variable
// Add it as a var instruction so it gets bound at the right time
// Use <var id="atx.Name" set="atValue"/>
var var = new Var();
var.Id = atx.Name;
var.Set = XmlFiler.getAttribute(xn, atx.Name);
// Add the var to the growing list of instructions
AddInstruction(xn, var, con);
Logger.getOnly().paragraph("Added <var id=\"" + var.Id + "\" set=\"" + var.Set + "\"/>");
}
}
}
Logger.getOnly().endList();
// Create the instruction using prototype.Name, AtValues.Name and AtValues.Value
string protoName = XmlNameToCName(prototype.Name);
string protoNameQ = prefix + protoName;
Assembly assem = Assembly.GetExecutingAssembly();
// All instruction classes must have empty constructors
Object protoInstruction = null;
try { protoInstruction = assem.CreateInstance(protoNameQ, true,
BindingFlags.CreateInstance, null, null, null, null);}
catch (Exception e) { Logger.getOnly().fail("Instruction " + protoName + " not created: " + e.Message); }
Logger.getOnly().isNotNull(protoInstruction, "Instruction " + protoName + " is DOA");
FluffedInstruction = (Instruction)protoInstruction;
foreach (Attribute at in AtValues)
{ // Call each setter to set the instruction properties.
int number = 0;
UInt32 unsigned = 0;
string primative = "string";
if (at.Type == "msec" || at.Type == "int" || at.Type.Contains("[0-10]"))
{
try
{
number = Convert.ToInt32(at.Value);
primative = "int";
}
catch (FormatException) { }
}
if (at.Type == "m-sec" || at.Type == "hz")
{
try
{
unsigned = Convert.ToUInt32(at.Value, 10);
primative = "UInt32";
}
catch (FormatException) { }
}
if (primative == "string" && at.Type.Contains("|"))
{
string[] enumList = makeEnumList(at.Type);
foreach (string value in enumList)
{
if (value == at.Value)
{
primative = value;
break;
}
}
if (primative == "string")
Logger.getOnly().fail("Invalid enum {" + at.Value + "} for " + protoNameQ + "." + at.Name + "(" + at.Type + ")");
}
string propName = XmlNameToCName(at.Name);
string propNameQ = protoNameQ + "." + XmlNameToCName(at.Name);
PropertyInfo pi = null;
MethodInfo m = null;
try
{
if (primative == "int")
{
pi = assem.GetType(protoNameQ).GetProperty(propName, typeof(int));
m = pi.GetSetMethod();
m.Invoke(protoInstruction, new Object[] { number });
}
else if (primative == "UInt32")
{
pi = assem.GetType(protoNameQ).GetProperty(propName, typeof(UInt32));
m = pi.GetSetMethod();
m.Invoke(protoInstruction, new Object[] { unsigned });
}
else
{
Type t = assem.GetType(protoNameQ);
pi = t.GetProperty(propName, typeof(string));
m = pi.GetSetMethod();
m.Invoke(protoInstruction, new Object[] { at.Value });
}
}
catch
{ Logger.getOnly().fail(" Can't find setter: " + protoNameQ + "." + propName + "(" + at.Type + ") using value {" + at.Value + "}"); }
if (at.Name == "id" && protoName != "Var")
TestState.getOnly().AddNamedInstruction(at.Value, FluffedInstruction);
} // end of process attributes
// Call the finishCreation method
FluffedInstruction.finishCreation(xn, con);
//if (prototype.Name != "if" &&
// prototype.Name != "then" && prototype.Name != "else")
// Add the instruction to the growing list of instructions
AddInstruction(xn, FluffedInstruction, con);
}
else
{
bool unknown = true;
if (m_pasPrototypes != null)
{
InsPrototype IgnoredPrototype = findPrototype(xn.Name, m_pasPrototypes);
if (IgnoredPrototype != null) unknown = false;
}
if (unknown) Logger.getOnly().fail("Can't make <" + xn.Name + "> instruction");
}
break;
}
return FluffedInstruction;
}
