Example #1
0
 /// <summary>
 /// Constructor that uses a parent instruction instead if the id is null.
 /// </summary>
 /// <param name="id">Instruction name or id, can be null</param>
 /// <param name="parent">Parent instruction of this DataRef</param>
 public DataRef(string id, Instruction parent)
 {
     m_ts = TestState.getOnly();
     //Assert.IsNotNull(id,"Null id passed for constructing a DataRef");
     //Assert.IsFalse(id == "","Empty id passed for constructing a DataRef");
     Assert.IsNotNull(m_ts,"Null TestState passed for constructing a DataRef");
     Assert.IsNotNull(parent,"Non-null parent instruction expected for constructing a DataRef");
     // the id can be $id.data or $id or $.data or $ (parent default data)
     // these may occur with suffix ';' or space
     // replace all '$.' with '$genid.data'
     if (id == null || id.Equals("")) id = "$";
     m_id = id;
     int dol = m_id.IndexOf('$');
     if (dol >= 0)
     { // there are data references
         string genId = "Internal#Data#Ref"+sm_next_id.ToString();
         string dgenId = "$"+genId;
         sm_next_id += 1;
         m_id = m_id.Replace("$.",dgenId+".");
         m_id = m_id.Replace("$;",dgenId+";");
         m_id = m_id.Replace("$ ",dgenId+" ");
         if (m_id == "$") m_id = dgenId;
         if (m_id[m_id.Length-1] == '$') // last char
             m_id = m_id.Substring(0,m_id.Length-1) + dgenId;
         // if dgenId was substituted, add the parent to the ts list
         if (-1 < m_id.IndexOf(dgenId))
             m_ts.AddNamedInstruction(genId,parent);
     }
     else Assert.IsNotNull(id,"A DataRef has no ref prefixed with '$'. Read: "+id);
 }
Example #2
0
 /// <summary>
 /// Initialize an Instruction.
 /// </summary>
 public Instruction()
 {
     m_number = -1;
     m_parent = null;
     m_log = Logger.getOnly();
     m_id = "NONE";
     m_Rest = 0; // default is not to wait for execution
     m_tag = "NONE";
     m_doneOnce = false;
     m_path = null;
     m_select = null;
     m_selectPath = null;
 }
Example #3
0
		public ApplicationContext()
		{
			m_tag      = "on-application";
			m_source   = null;
			m_app      = null;
			m_run      = null;
			m_title    = null;
			m_exeName  = null;
			m_GuiModel = null;
			m_GuiModelPath = null;
			m_close    = false;
			m_args     = null;
			m_work     = null;
			m_gui      = null;
			m_model_root = null;
			// get the model root if there is one
		}
Example #4
0
 /// <summary>
 /// Adds an instruction to this context immediately after the one referenced.
 /// </summary>
 /// <param name="afterThis">The instruction to add ins after.</param>
 /// <param name="ins">The instruction to add.</param>
 public void Add(Instruction afterThis, Instruction ins)
 {
     m_log.isNotNull(afterThis, base.makeNameTag() + " Tried to reference a null instruction");
     m_log.isNotNull(ins, base.makeNameTag() + " Tried to add a null instruction");
     m_instructions.Insert(m_instructions.IndexOf(afterThis)+1, ins);
 }
Example #5
0
 /// <summary>
 /// Adds an instruction to this context.
 /// </summary>
 /// <param name="ins">The instruction to add.</param>
 public void Add(Instruction ins)
 {
     m_log.isNotNull(ins, base.makeNameTag() + " Tried to add a null instruction");
     m_instructions.Add(ins);
 }
		/// <summary>
		/// Determines if an instruction has an id. If it does, it adds to the named instruction list.
		/// </summary>
		/// <param name="xn">The XML repersentation of the instruction to be checked</param>
		/// <param name="ins">The instruction to be checked</param>
		static void CheckForId(XmlNode xn, Instruction ins)
		{
			XmlAttribute xa = xn.Attributes["id"];
			if (xa != null)
			{
				TestState.getOnly().AddNamedInstruction(xa.Value, ins);
				ins.Id = xa.Value;
			}
		}
		/// <summary>
		/// Adds an instruction to the growing tree, sets the log level
		/// and records it to the log.
		/// </summary>
		/// <param name="xn">An element node</param>
		/// <param name="ins">The instruction to be added</param>
		/// <param name="con">The current context object</param>
		static private void AddInstruction(XmlNode xn, Instruction ins, Context con)
		{	// Vars put themselves on ts, making sure there is only one
			ins.Element = (XmlElement)xn;
			if (xn.Name != "var") CheckForId(xn, ins);
			// If not a new one, make sure the model node is propagated to each child context
			if (ins is Context && con.ModelNode != null)
				((Context)ins).ModelNode = con.ModelNode;
			ins.Parent = con;
			con.Add(ins);
			string logLevel = XmlFiler.getAttribute(xn, "log");
			if (logLevel != null && "all" == logLevel) ins.LogLevel = 1;
			if (logLevel != null && "time" == logLevel) ins.LogLevel = 2;
			// add one to the instruction count, then assign it to the instruction
			// A context might already have a number
			//if (ins.Number == -1) ins.Number = TestState.getOnly().IncInstructionCount;
			//Logger.getOnly().mark(ins); // log the progress of interpretation
		}
Example #8
0
 /// <summary>
 /// Simple results are logged via this empty report element.
 /// More complex ones use the other logging methods.
 /// This uses the resultImage() method from the instruction.
 /// This is typically called after mark().
 /// </summary>
 /// <param name="ins">An instruction</param>
 public void result(Instruction ins)
 {
     if (!s_isClosed)
     {
         if (!m_init) initLog();
         m_sw.WriteLine(@" <result {0}/>", ins.resultImage());
         m_sw.Flush();
     }
 }
Example #9
0
 /// <summary>
 /// Create an empty element in the log using the image() method
 /// on an instruction. This is invoked from Instruction.Execute
 /// to insure each instruction is marked at some point before or
 /// during its execution. The image() methods report the state of
 /// the instruction, including some internal class members for
 /// debugging.
 /// </summary>
 /// <param name="ins">An instruction</param>
 public void mark(Instruction ins)
 {
     if (!s_isClosed)
     {
         if (!m_init) initLog();
         m_sw.WriteLine(@" <{0}/>", ins.image());
         m_sw.Flush();
     }
 }
Example #10
0
 /// <summary>
 /// Adds a sound or beep instruction to the message.
 /// It is played when the sound is read.
 /// </summary>
 /// <param name="ins">The sound or beep instruction.</param>
 public void AddSound(Instruction ins)
 {
     int index = m_Body.Add(ins);
 }
Example #11
0
 /// <summary>
 /// Adds a DataRef to the message using the parent if the id is null.
 /// </summary>
 /// <param name="id">Instruction name or id, can be null</param>
 /// <param name="name">Name of the data item, can be null</param>
 /// <param name="parent">Parent instruction of this DataRef</param>
 public void AddDataRef(string id, Instruction parent)
 {
     DataRef dref = new DataRef(id, parent);
     int index = m_Body.Add(dref);
 }
Example #12
0
		/// <summary>
		/// Add a named instruction to the pool to be retrieved by calling "Instruction".
		/// </summary>
		/// <param name="name">The id of the instruction.</param>
		/// <param name="ins">The instruction called by name.</param>
		public void AddNamedInstruction(string name, Instruction ins)
		{
			m_htNamedInstructions.Add(name, ins);
		}
Example #13
0
 public void SetSource(string name)
 {
     // It has to be the name of another on-application element already encountered.
     TestState ts = TestState.getOnly();
     Instruction insSource = ts.Instruction(name);
     m_log.isTrue(insSource != null, "Source is null.");
     m_log.isTrue(insSource is OnApplication, "Source is not an on-application instruction."); // eventually or other types.
     m_source = insSource;
 }
Example #14
0
		/// <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;
		}
Example #15
0
		/// <summary>
		/// Adds an instruction to this context immediately after the one referenced.
		/// </summary>
		/// <param name="afterThis">The instruction to add ins after.</param>
		/// <param name="ins">The instruction to add.</param>
		public void Add(Instruction afterThis, Instruction ins)
		{
			isNotNull(afterThis, base.makeName() + " Tried to reference a null instruction");
			isNotNull(ins, base.makeName() + " Tried to add a null instruction");
			m_components.Insert(m_components.IndexOf(afterThis)+1, ins);
		}
Example #16
0
		/// <summary>
		/// Adds an instruction to this context.
		/// </summary>
		/// <param name="ins">The instruction to add.</param>
		public void Add(Instruction ins)
		{
			isNotNull(ins, base.makeName()+" Tried to add a null instruction");
			m_components.Add(ins);
		}