clover

Clover coverage report - clover

Coverage timestamp: Sat Oct 8 2005 22:54:17 EDT

FRAMES NO FRAMES

file stats:	LOC:	354		Methods:	25
	NCLOC:	234		Classes:	1

Source file

Conditionals

Statements

Methods

TOTAL

Step.java

61.1%

68.7%

80%

68.8%

 package abbot.script;
 
 import java.awt.Component;
 import java.io.*;
 import java.lang.reflect.*;
 import java.util.*;
 
 import org.jdom.*;
 import org.jdom.input.SAXBuilder;
 import org.jdom.output.XMLOutputter;
 
 import abbot.Log;
 import abbot.finder.*;
 import abbot.i18n.Strings;
 import abbot.tester.ComponentTester;
 
 /**
  * Provides access to one step (line) from a script.  A Step is the basic
  * unit of execution.  
  * <b>Custom Step classes</b><p>
  * All custom {@link Step} classes must supply a {@link Constructor} with the
  * signature <code>&lt;init&gt;(${link Resolver}, {@link Map})</code>.  If 
  * the step has contents (e.g. {@link Sequence}), then it should also
  * provide a {@link Constructor} with the signature
  * <code>&lt;init&gt;({@link Resolver}, {@link Element}, {@link Map})</code>.
  * <p>
  * The XML tag for a given {@link Step} will be used to auto-generate the
  * {@link Step} class name, e.g. the tag &lt;aphrodite/&gt; causes the
  * parser to create an instance of class <code>abbot.script.Aphrodite</code>,
  * using one of the {@link Constructor}s described above. 
  * <p>
  * All derived classes should include an entry in the
  * <a href={@docRoot}/../abbot.xsd>schema</a>, or validation must be turned
  * off by setting the System property
  * <code>abbot.script.validate=false</code>. 
  * <p>
  * You can make the custom <code>Aphrodite</code> step do just about anything
  * by overriding the {@link #runStep()} method.  
  * <p>
  * See the source for any {@link Step} implementation in this package for
  * examples. 
  */
 public abstract class Step implements XMLConstants, XMLifiable, Serializable {
 
     private String description = null;
     private Resolver resolver;
     /** Error encountered on parse. */
     private Throwable invalidScriptError = null;
 
     public Step(Resolver resolver, Map attributes) {
         this(resolver, "");
         Log.debug("Instantiating " + getClass());
         if (Log.expectDebugOutput) {
             Iterator iter = attributes.keySet().iterator();
             while (iter.hasNext()) {
                 String key = (String)iter.next();
                 Log.debug(key + "=" + attributes.get(key));
             }
         }
         parseStepAttributes(attributes);
     }
 
     public Step(Resolver resolver, String description) {
         // Kind of a hack; a Script is its own resolver
         if (resolver == null) {
             if (!(this instanceof Resolver)) {
                 throw new Error("Resolver must be provided");
             }
             resolver = (Resolver)this;
         }
         else if (this instanceof Resolver) {
             resolver = (Resolver)this;
         }
         this.resolver = resolver;
         if ("".equals(description))
             description = null;
         this.description = description;
     }
     
     /** Only exposed so that Script may invoke it on load from disk. */
     protected final void parseStepAttributes(Map attributes) {
         Log.debug("Parsing attributes for " + getClass());
         description = (String)attributes.get(TAG_DESC);
     }
 
     /** Main run method.  Should <b>never</b> be run on the event dispatch
      * thread, although no check is explicitly done here.
      */
     public final void run() throws Throwable {
         if (invalidScriptError != null)
             throw invalidScriptError;
         Log.debug("Running " + toString());
         runStep();
     }
 
     /** Implement the step's behavior here. */
     protected abstract void runStep() throws Throwable;
 
     public String getDescription() { 
         return description != null ? description : getDefaultDescription();
     }
     public void setDescription(String desc) { 
         description = desc;
     }
 
     /** Define the XML tag to use for this script step. */
     public abstract String getXMLTag();
 
     /** Provide a usage String for this step. */
     public abstract String getUsage();
 
     /** Return a reasonable default description for this script step.
         This value is used in the absence of an explicit description. 
      */
     public abstract String getDefaultDescription();
 
     /** For use by subclasses when an error is encountered during parsing. 
      * Should only be used by the XML parsing ctors.
      */
     protected void setScriptError(Throwable thr) {
         if (invalidScriptError == null) {
             invalidScriptError = thr;
         }
         else {
             Log.warn("More than one script error encountered: " + thr);
             Log.warn("Already have: " + invalidScriptError);
         }
     }
 
     /** Throw an invalid script exception describing the proper script
      * usage.  This should be used by derived classes whenever parsing
      * indicates invalid input.
      */ 
     protected void usage() {
         usage(null);
     }
 
     /** Store an invalid script exception describing the proper script
      * usage.  This should be used by derived classes whenever parsing
      * indicates invalid input.  
      */ 
     protected void usage(String details) {
         String msg = getUsage();
         if (details != null) {
             msg = Strings.get("step.usage", new Object[] { msg, details });
         }
         setScriptError(new InvalidScriptException(msg));
     }
 
     /** Attributes to save in script. */
     public Map getAttributes() {
         Map map = new HashMap();
         if (description != null
             && !description.equals(getDefaultDescription()))
             map.put(TAG_DESC, description);
         return map;
     }
 
     public Resolver getResolver() { return resolver; }
 
     /** Override if the step actually has some contents.  In most cases, it
      * won't.
      */
     protected Element addContent(Element el) { 
         return el;
     }
 
     /** Add an attribute to the given XML Element.  Attributes are kept in
         alphabetical order. */
     protected Element addAttributes(Element el) {
         // Use a TreeMap to keep the attributes sorted on output
         Map atts = new TreeMap(getAttributes());
         Iterator iter = atts.keySet().iterator();
         while (iter.hasNext()) {
             String key = (String)iter.next();
             String value = (String)atts.get(key);
             if (value == null) {
                 Log.warn("Attribute '" + key + "' value was null in step "
                          + getXMLTag());
                 value = "";
             }
             el.setAttribute(key, value);
         }
         return el;
     }
 
     /** Convert this Step into a String suitable for editing.  The default is
         the XML representation of the Step. */
     public String toEditableString() {
         return toXMLString(this);
     }
 
     /** Provide a one-line XML string representation. */
     public static String toXMLString(XMLifiable obj) {
         // Comments are the only things that aren't actually elements...
         if (obj instanceof Comment) {
             return "<!-- " + ((Comment)obj).getDescription() + " -->";
         }
         Element el = obj.toXML();
         StringWriter writer = new StringWriter();
         try {
             XMLOutputter outputter = new XMLOutputter();
             outputter.output(el, writer);
         }
         catch(IOException io) {
             Log.warn(io);
         }
         return writer.toString();
     }
 
     /** Convert the object to XML.  */
     public Element toXML() {
         return addAttributes(addContent(new Element(getXMLTag())));
     }
 
     /** Create a new step from an in-line XML string. */
     public static Step createStep(Resolver resolver, String str) 
         throws InvalidScriptException, IOException {
         StringReader reader = new StringReader(str);
         try {
             SAXBuilder builder = new SAXBuilder();
             Document doc = builder.build(reader);
             Element el = doc.getRootElement();
             return createStep(resolver, el);
         }
         catch(JDOMException e) {
             throw new InvalidScriptException(e.getMessage());
         }
     }
 
     /** Convert the attributes in the given XML Element into a Map of
         name/value pairs. */
     protected static Map createAttributeMap(Element el) {
         Log.debug("Creating attribute map for " + el);
         Map attributes = new HashMap();
         Iterator iter = el.getAttributes().iterator();
         while (iter.hasNext()) {
             Attribute att = (Attribute)iter.next();
             attributes.put(att.getName(), att.getValue());
         }
         return attributes;
     }
 
     /**
      * Factory method, equivalent to a "fromXML" for step creation.  Looks for
      * a class with the same name as the XML tag, with the first letter
      * capitalized.  For example, &lt;call /&gt; is abbot.script.Call.
      */
     public static Step createStep(Resolver resolver, Element el) 
         throws InvalidScriptException {
         String tag = el.getName();
         Map attributes = createAttributeMap(el);
         String name = tag.substring(0, 1).toUpperCase() + tag.substring(1);
         if (tag.equals(TAG_WAIT)) {
             attributes.put(TAG_WAIT, "true");
             name = "Assert";
         }
         try {
             name = "abbot.script." + name;
             Log.debug("Instantiating " + name);
             Class cls = Class.forName(name);
             try {
                 // Steps with contents require access to the XML element
                 Class[] argTypes = new Class[] {
                     Resolver.class, Element.class, Map.class
                 };
                 Constructor ctor = cls.getConstructor(argTypes);
                 return (Step)ctor.newInstance(new Object[] {
                     resolver, el, attributes
                 });
             }
             catch(NoSuchMethodException nsm) {
                 // All steps must support this ctor
                 Class[] argTypes = new Class[] { 
                     Resolver.class, Map.class
                 };
                 Constructor ctor = cls.getConstructor(argTypes);
                 return (Step)ctor.newInstance(new Object[] {
                     resolver, attributes
                 });
             }
         }
         catch(ClassNotFoundException cnf) {
             String msg = Strings.get("step.unknown_tag", new Object[] { tag });
             throw new InvalidScriptException(msg);
         }
         catch(InvocationTargetException ite) {
             Log.warn(ite);
             throw new InvalidScriptException(ite.getTargetException().
                                              getMessage());
         }
         catch(Exception exc) {
             Log.warn(exc);
             throw new InvalidScriptException(exc.getMessage());
         }
     }
 
     protected String simpleClassName(Class cls) {
         return ComponentTester.simpleClassName(cls);
     }
 
     /** Return a description of this script step. */
     public String toString() {
         return getDescription();
     }
 
     /** Returns the Class corresponding to the given class name.  Provides
      * just-in-time classname resolution to ensure loading by the proper class
      * loader. <p>
      */
     public Class resolveClass(String className) throws ClassNotFoundException {
         ClassLoader cl = getResolver().getContextClassLoader();
         return Class.forName(className, true, cl);
     }
 
     /** Look up an appropriate ComponentTester given an arbitrary
      * Component-derived class.
      * If the class is derived from abbot.tester.ComponentTester, instantiate
      * one; if it is derived from java.awt.Component, return a matching Tester.
      * Otherwise return abbot.tester.ComponentTester.<p>
      * @throws ClassNotFoundException If the given class can't be found.
      * @throws IllegalArgumentException If the tester cannot be instantiated.
      */
     protected ComponentTester resolveTester(String className) 
         throws ClassNotFoundException {
         Class testedClass = resolveClass(className);
         if (Component.class.isAssignableFrom(testedClass))
             return ComponentTester.getTester(testedClass);
         else if (ComponentTester.class.isAssignableFrom(testedClass)) {
             try {
                 return (ComponentTester)testedClass.newInstance();
             }
             catch(Exception e) {
                 String msg = "Custom ComponentTesters must provide "
                     + "an accessible no-args Constructor: " + e.getMessage();
                 throw new IllegalArgumentException(msg);
             }
         }
         String msg = "The given class '" + className
             + "' is neither a Component nor a ComponentTester";
         throw new IllegalArgumentException(msg);
     }
 
     private void writeObject(ObjectOutputStream out) {
         // NOTE: this is only to avoid drag/drop errors
         out = null;
     }
 
     private void readObject(ObjectInputStream in) {
         // NOTE: this is only to avoid drag/drop errors
         in = null;
     }
 }
 

1		package abbot.script;
2
3		import java.awt.Component;
4		import java.io.*;
5		import java.lang.reflect.*;
6		import java.util.*;
7
8		import org.jdom.*;
9		import org.jdom.input.SAXBuilder;
10		import org.jdom.output.XMLOutputter;
11
12		import abbot.Log;
13		import abbot.finder.*;
14		import abbot.i18n.Strings;
15		import abbot.tester.ComponentTester;
16
17		/**
18		* Provides access to one step (line) from a script. A Step is the basic
19		* unit of execution.
20		* <b>Custom Step classes</b><p>
21		* All custom {@link Step} classes must supply a {@link Constructor} with the
22		* signature <code><init>(${link Resolver}, {@link Map})</code>. If
23		* the step has contents (e.g. {@link Sequence}), then it should also
24		* provide a {@link Constructor} with the signature
25		* <code><init>({@link Resolver}, {@link Element}, {@link Map})</code>.
26		* <p>
27		* The XML tag for a given {@link Step} will be used to auto-generate the
28		* {@link Step} class name, e.g. the tag <aphrodite/> causes the
29		* parser to create an instance of class <code>abbot.script.Aphrodite</code>,
30		* using one of the {@link Constructor}s described above.
31		* <p>
32		* All derived classes should include an entry in the
33		* <a href={@docRoot}/../abbot.xsd>schema</a>, or validation must be turned
34		* off by setting the System property
35		* <code>abbot.script.validate=false</code>.
36		* <p>
37		* You can make the custom <code>Aphrodite</code> step do just about anything
38		* by overriding the {@link #runStep()} method.
39		* <p>
40		* See the source for any {@link Step} implementation in this package for
41		* examples.
42		*/
43		public abstract class Step implements XMLConstants, XMLifiable, Serializable {
44
45		private String description = null;
46		private Resolver resolver;
47		/** Error encountered on parse. */
48		private Throwable invalidScriptError = null;
49
50	674	public Step(Resolver resolver, Map attributes) {
51	674	this(resolver, "");
52	674	Log.debug("Instantiating " + getClass());
53	674	if (Log.expectDebugOutput) {
54	0	Iterator iter = attributes.keySet().iterator();
55	0	while (iter.hasNext()) {
56	0	String key = (String)iter.next();
57	0	Log.debug(key + "=" + attributes.get(key));
58		}
59		}
60	674	parseStepAttributes(attributes);
61		}
62
63	1283	public Step(Resolver resolver, String description) {
64		// Kind of a hack; a Script is its own resolver
65	1283	if (resolver == null) {
66	617	if (!(this instanceof Resolver)) {
67	0	throw new Error("Resolver must be provided");
68		}
69	617	resolver = (Resolver)this;
70		}
71	666	else if (this instanceof Resolver) {
72	36	resolver = (Resolver)this;
73		}
74	1283	this.resolver = resolver;
75	1283	if ("".equals(description))
76	676	description = null;
77	1283	this.description = description;
78		}
79
80		/** Only exposed so that Script may invoke it on load from disk. */
81	689	protected final void parseStepAttributes(Map attributes) {
82	689	Log.debug("Parsing attributes for " + getClass());
83	689	description = (String)attributes.get(TAG_DESC);
84		}
85
86		/** Main run method. Should <b>never</b> be run on the event dispatch
87		* thread, although no check is explicitly done here.
88		*/
89	33	public final void run() throws Throwable {
90	33	if (invalidScriptError != null)
91	0	throw invalidScriptError;
92	33	Log.debug("Running " + toString());
93	33	runStep();
94		}
95
96		/** Implement the step's behavior here. */
97		protected abstract void runStep() throws Throwable;
98
99	1720	public String getDescription() {
100	1720	return description != null ? description : getDefaultDescription();
101		}
102	55	public void setDescription(String desc) {
103	55	description = desc;
104		}
105
106		/** Define the XML tag to use for this script step. */
107		public abstract String getXMLTag();
108
109		/** Provide a usage String for this step. */
110		public abstract String getUsage();
111
112		/** Return a reasonable default description for this script step.
113		This value is used in the absence of an explicit description.
114		*/
115		public abstract String getDefaultDescription();
116
117		/** For use by subclasses when an error is encountered during parsing.
118		* Should only be used by the XML parsing ctors.
119		*/
120	20	protected void setScriptError(Throwable thr) {
121	20	if (invalidScriptError == null) {
122	20	invalidScriptError = thr;
123		}
124		else {
125	0	Log.warn("More than one script error encountered: " + thr);
126	0	Log.warn("Already have: " + invalidScriptError);
127		}
128		}
129
130		/** Throw an invalid script exception describing the proper script
131		* usage. This should be used by derived classes whenever parsing
132		* indicates invalid input.
133		*/
134	0	protected void usage() {
135	0	usage(null);
136		}
137
138		/** Store an invalid script exception describing the proper script
139		* usage. This should be used by derived classes whenever parsing
140		* indicates invalid input.
141		*/
142	0	protected void usage(String details) {
143	0	String msg = getUsage();
144	0	if (details != null) {
145	0	msg = Strings.get("step.usage", new Object[] { msg, details });
146		}
147	0	setScriptError(new InvalidScriptException(msg));
148		}
149
150		/** Attributes to save in script. */
151	785	public Map getAttributes() {
152	785	Map map = new HashMap();
153	785	if (description != null
154		&& !description.equals(getDefaultDescription()))
155	56	map.put(TAG_DESC, description);
156	785	return map;
157		}
158
159	59063	public Resolver getResolver() { return resolver; }
160
161		/** Override if the step actually has some contents. In most cases, it
162		* won't.
163		*/
164	44	protected Element addContent(Element el) {
165	44	return el;
166		}
167
168		/** Add an attribute to the given XML Element. Attributes are kept in
169		alphabetical order. */
170	807	protected Element addAttributes(Element el) {
171		// Use a TreeMap to keep the attributes sorted on output
172	807	Map atts = new TreeMap(getAttributes());
173	807	Iterator iter = atts.keySet().iterator();
174	807	while (iter.hasNext()) {
175	218	String key = (String)iter.next();
176	218	String value = (String)atts.get(key);
177	218	if (value == null) {
178	0	Log.warn("Attribute '" + key + "' value was null in step "
179		+ getXMLTag());
180	0	value = "";
181		}
182	218	el.setAttribute(key, value);
183		}
184	807	return el;
185		}
186
187		/** Convert this Step into a String suitable for editing. The default is
188		the XML representation of the Step. */
189	0	public String toEditableString() {
190	0	return toXMLString(this);
191		}
192
193		/** Provide a one-line XML string representation. */
194	2837	public static String toXMLString(XMLifiable obj) {
195		// Comments are the only things that aren't actually elements...
196	2837	if (obj instanceof Comment) {
197	0	return "<!-- " + ((Comment)obj).getDescription() + " -->";
198		}
199	2837	Element el = obj.toXML();
200	2837	StringWriter writer = new StringWriter();
201	2837	try {
202	2837	XMLOutputter outputter = new XMLOutputter();
203	2837	outputter.output(el, writer);
204		}
205		catch(IOException io) {
206	0	Log.warn(io);
207		}
208	2837	return writer.toString();
209		}
210
211		/** Convert the object to XML. */
212	807	public Element toXML() {
213	807	return addAttributes(addContent(new Element(getXMLTag())));
214		}
215
216		/** Create a new step from an in-line XML string. */
217	2	public static Step createStep(Resolver resolver, String str)
218		throws InvalidScriptException, IOException {
219	2	StringReader reader = new StringReader(str);
220	2	try {
221	2	SAXBuilder builder = new SAXBuilder();
222	2	Document doc = builder.build(reader);
223	2	Element el = doc.getRootElement();
224	2	return createStep(resolver, el);
225		}
226		catch(JDOMException e) {
227	0	throw new InvalidScriptException(e.getMessage());
228		}
229		}
230
231		/** Convert the attributes in the given XML Element into a Map of
232		name/value pairs. */
233	38	protected static Map createAttributeMap(Element el) {
234	38	Log.debug("Creating attribute map for " + el);
235	38	Map attributes = new HashMap();
236	38	Iterator iter = el.getAttributes().iterator();
237	38	while (iter.hasNext()) {
238	26	Attribute att = (Attribute)iter.next();
239	26	attributes.put(att.getName(), att.getValue());
240		}
241	38	return attributes;
242		}
243
244		/**
245		* Factory method, equivalent to a "fromXML" for step creation. Looks for
246		* a class with the same name as the XML tag, with the first letter
247		* capitalized. For example, <call /> is abbot.script.Call.
248		*/
249	23	public static Step createStep(Resolver resolver, Element el)
250		throws InvalidScriptException {
251	23	String tag = el.getName();
252	23	Map attributes = createAttributeMap(el);
253	23	String name = tag.substring(0, 1).toUpperCase() + tag.substring(1);
254	23	if (tag.equals(TAG_WAIT)) {
255	0	attributes.put(TAG_WAIT, "true");
256	0	name = "Assert";
257		}
258	23	try {
259	23	name = "abbot.script." + name;
260	23	Log.debug("Instantiating " + name);
261	23	Class cls = Class.forName(name);
262	23	try {
263		// Steps with contents require access to the XML element
264	23	Class[] argTypes = new Class[] {
265		Resolver.class, Element.class, Map.class
266		};
267	23	Constructor ctor = cls.getConstructor(argTypes);
268	7	return (Step)ctor.newInstance(new Object[] {
269		resolver, el, attributes
270		});
271		}
272		catch(NoSuchMethodException nsm) {
273		// All steps must support this ctor
274	16	Class[] argTypes = new Class[] {
275		Resolver.class, Map.class
276		};
277	16	Constructor ctor = cls.getConstructor(argTypes);
278	16	return (Step)ctor.newInstance(new Object[] {
279		resolver, attributes
280		});
281		}
282		}
283		catch(ClassNotFoundException cnf) {
284	0	String msg = Strings.get("step.unknown_tag", new Object[] { tag });
285	0	throw new InvalidScriptException(msg);
286		}
287		catch(InvocationTargetException ite) {
288	0	Log.warn(ite);
289	0	throw new InvalidScriptException(ite.getTargetException().
290		getMessage());
291		}
292		catch(Exception exc) {
293	0	Log.warn(exc);
294	0	throw new InvalidScriptException(exc.getMessage());
295		}
296		}
297
298	96	protected String simpleClassName(Class cls) {
299	96	return ComponentTester.simpleClassName(cls);
300		}
301
302		/** Return a description of this script step. */
303	1270	public String toString() {
304	1270	return getDescription();
305		}
306
307		/** Returns the Class corresponding to the given class name. Provides
308		* just-in-time classname resolution to ensure loading by the proper class
309		* loader. <p>
310		*/
311	197	public Class resolveClass(String className) throws ClassNotFoundException {
312	197	ClassLoader cl = getResolver().getContextClassLoader();
313	197	return Class.forName(className, true, cl);
314		}
315
316		/** Look up an appropriate ComponentTester given an arbitrary
317		* Component-derived class.
318		* If the class is derived from abbot.tester.ComponentTester, instantiate
319		* one; if it is derived from java.awt.Component, return a matching Tester.
320		* Otherwise return abbot.tester.ComponentTester.<p>
321		* @throws ClassNotFoundException If the given class can't be found.
322		* @throws IllegalArgumentException If the tester cannot be instantiated.
323		*/
324	7	protected ComponentTester resolveTester(String className)
325		throws ClassNotFoundException {
326	7	Class testedClass = resolveClass(className);
327	7	if (Component.class.isAssignableFrom(testedClass))
328	7	return ComponentTester.getTester(testedClass);
329	0	else if (ComponentTester.class.isAssignableFrom(testedClass)) {
330	0	try {
331	0	return (ComponentTester)testedClass.newInstance();
332		}
333		catch(Exception e) {
334	0	String msg = "Custom ComponentTesters must provide "
335		+ "an accessible no-args Constructor: " + e.getMessage();
336	0	throw new IllegalArgumentException(msg);
337		}
338		}
339	0	String msg = "The given class '" + className
340		+ "' is neither a Component nor a ComponentTester";
341	0	throw new IllegalArgumentException(msg);
342		}
343
344	0	private void writeObject(ObjectOutputStream out) {
345		// NOTE: this is only to avoid drag/drop errors
346	0	out = null;
347		}
348
349	0	private void readObject(ObjectInputStream in) {
350		// NOTE: this is only to avoid drag/drop errors
351	0	in = null;
352		}
353		}
354