예제 #1
1
 /**
  * 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, <call /> 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());
   }
 }
예제 #2
0
 /**
  * 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);
   }
 }
예제 #3
0
 /** 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();
 }
예제 #4
0
 /** 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;
 }
예제 #5
0
 /** Return the semantic recorder for the given component class. */
 protected SemanticRecorder getSemanticRecorder(Class cls) {
   // 	System.out.println("getting recorder for: " + cls);
   if (!(Component.class.isAssignableFrom(cls))) {
     throw new IllegalArgumentException("Class (" + cls + ") must derive from " + "Component");
   }
   SemanticRecorder sr = (SemanticRecorder) semanticRecorders.get(cls);
   if (sr == null) {
     Class ccls = Robot.getCanonicalClass(cls);
     if (ccls != cls) {
       sr = getSemanticRecorder(ccls);
       // Additionally cache the mapping from the non-canonical class
       semanticRecorders.put(cls, sr);
       return sr;
     }
     String cname = Robot.simpleClassName(cls);
     try {
       // cname = "abbot.editor.recorder." + cname + "Recorder";
       cname = getRecoderName(cname);
       Class recorderClass = Class.forName(cname);
       Constructor ctor =
           recorderClass.getConstructor(
               new Class[] {
                 Resolver.class,
               });
       sr = (SemanticRecorder) ctor.newInstance(new Object[] {getResolver()});
       sr.addActionListener(getListener());
     } catch (InvocationTargetException e) {
       Log.warn(e);
     } catch (NoSuchMethodException e) {
       sr = getSemanticRecorder(cls.getSuperclass());
     } catch (InstantiationException e) {
       sr = getSemanticRecorder(cls.getSuperclass());
     } catch (IllegalAccessException iae) {
       sr = getSemanticRecorder(cls.getSuperclass());
     } catch (ClassNotFoundException cnf) {
       sr = getSemanticRecorder(cls.getSuperclass());
     }
     // Cache the results for future reference
     semanticRecorders.put(cls, sr);
   }
   return sr;
 }
예제 #6
0
  /** Capture the given event as a raw event. */
  private void captureRawEvent(AWTEvent event) {

    // FIXME maybe measure time delay between events and insert delay
    // events?
    int id = event.getID();
    boolean capture = false;
    switch (id) {
      case MouseEvent.MOUSE_PRESSED:
      case MouseEvent.MOUSE_RELEASED:
        capture = true;
        break;
      case KeyEvent.KEY_PRESSED:
      case KeyEvent.KEY_RELEASED:
        KeyEvent e = (KeyEvent) event;
        capture = e.getKeyCode() != KeyEvent.VK_UNDEFINED;
        if (!capture) {
          Log.warn(
              "VM bug: no valid keycode on key "
                  + (id == KeyEvent.KEY_PRESSED ? "press" : "release"));
        }
        break;
      case MouseEvent.MOUSE_ENTERED:
      case MouseEvent.MOUSE_EXITED:
        //     case MouseEvent.MOUSE_MOVED:
      case MouseEvent.MOUSE_DRAGGED:
        capture = captureMotion;
        break;
      default:
        break;
    }
    if (capture) {
      Event step = new Event(getResolver(), null, event);
      capturedEvent = event;
      insertStep(step);
      setStatus("Added event " + step);
    }
  }