winrunner使用问题

mxin79747993

请问winrunner怎样使用事件触发？
比如，当一个对话框消失后插入一个时间记录点，对话框是自动消失的。有没有高人能不吝赐教啊。

liujinkui

回复 4# mxin79747993


    你这能用到WR里吗？

mxin79747993

package test;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class ContainerType extends BaseType {

        /**
         * 获取第一个最外层容器，如果没有则返回null
         *
         * @param text
         * @return
         */
        protected String getContainer(String text, String regex) {
                Pattern p = Pattern.compile(regex);
                Matcher m = p.matcher(text);
                if (m.find()) {
                        String temp = m.group();
                        int flag = 0;
                        int left = 0;
                        int right = 0;
                        char[] ca = temp.toCharArray();
                        for (int i = 0; i < ca.length; i++) {
                                if (ca[i] == '{') {
                                        left++;
                                } else if (ca[i] == '}') {
                                        right++;
                                }

                                if (left == right && left != 0) {
                                        flag = i + 2;
                                        break;
                                }
                        }
                        return temp.substring(0, flag);
                }
                return null;
        }
       
        /**
         * 获取容器类型
         * @param text
         * @return module or interface
         */
        protected String getContainerType(String text){
                Pattern p = Pattern.compile(Regex.REGEX_CONTAI_TYPE);
                Matcher m = p.matcher(text);
                if(m.find()){
                        String temp = m.group();
                        return temp.substring(0, temp.indexOf(" ")).trim();
                }
                return null;
        }
       
       
       
       
}

mxin79747993

package test.ctype;

import org.jdom.Element;

import test.ContainerType;
import test.Regex;

public class CModule extends ContainerType {

        public CModule() {
        }

        /**
         * 获取第一个最外层module，如果没有则返回null
         *
         * @param text
         * @return
         */
        public String getContainer(String text) {
                return super.getContainer(text, Regex.REGEX_M_OR_I);
        }

        /**
         * 获取第一个最外层module，从startIndex位置开始查找
         *
         * @param text
         * @param startIndex
         * @return
         */
        public String getContainer(String text, int startIndex) {
                text = text.substring(startIndex);
                return this.getContainer(text);
        }

        /**
         * 将module和interface转换成xml格式
         *
         * @param node
         *            将新节点加入此节点下
         * @param name
         */
        public void toXML(Element node, String text, int start) {
                String module = getContainer(text, start);
                Element e = null;
                String content = null;
                while (module != null) {
                        String name = getName(module); // module或interface名
                        String type = getContainerType(module); // 关键字module或interface
                        content = getContent(module); // 大括号里的内容
                        /**
                         * 根据类型创建节点
                         */
                        if (type.equals("module")) {
                                e = new Element("module");
                                e.setAttribute("name", name);
                        } else if (type.equals("interface")) {
                                e = new Element("interface");
                                e.setAttribute("name", name);
                                new CInterface().toXML(e, content);
                        }
                       
                        node.addContent(e);
                       
                        if (content == null || content.equals("")) {
                        } else {
                                toXML(e, content, 0);
                        }
//                        start += (module.length() + text.indexOf(module));
                        //标记从上一个module后开始查找module或interface
                        start = text.indexOf(module) + module.length() - 1;
                        //获取下一个module或interface
                        module = getContainer(text, start);
                }
        }

}

mxin79747993

public List<String[]> getMethods(String content) {
                List<String[]> list = new ArrayList<String[]>();
                Pattern p = Pattern.compile(Regex.REGEX_FUNC);
                Matcher m = p.matcher(content);
                while (m.find()) {
                        String temp = m.group().trim();
                        // 将一个函数每个部分拆分出来存入数组
                        String[] spOpr = new String[5];
                        // 第1个元素保存函数类型oneway|twoway
                        String field1 = temp.substring(0, temp.indexOf(" "));
                        if (field1.equals("oneway")) {
                                spOpr[0] = field1;
                                temp = temp.substring(temp.indexOf(" ")).trim();
                        } else {
                                spOpr[0] = "twoway";
                        }
                        // 第2个元素保存函数返回值类型
                        spOpr[1] = temp.substring(0, temp.indexOf(" "));
                        temp = temp.substring(temp.indexOf(" ")).trim();
                        // 第3个元素保存函数名
                        spOpr[2] = temp.substring(0, temp.indexOf("(")).trim();
                        String field4 = temp.substring(temp.indexOf("(") + 1,
                                        temp.indexOf(")")).trim();
                        // 第4个元素保存参数列表，如没有则置为空值
                        spOpr[3] = field4.equals("") ? null : field4;
                        String field5 = temp.substring(temp.lastIndexOf("(") + 1,
                                        temp.lastIndexOf(")")).trim();
                        // 第5个元素保存异常，如没有则置为空值
                        spOpr[4] = field5.equals(field4) ? null : field5;
                        list.add(spOpr);
                }
                return list;
        }

        /**
         * 将函数转换为XML格式
         *
         * @param optRoot
         * @param content
         */
        public void toXML(Element optRoot, String content) {
                if (content == null)
                        return;

                List<String[]> list = getMethods(content);
                for (int i = 0; i < list.size(); i++) {
                        String[] func = list.get(i);
                        // 生成operation节点，函数的根节点
                        Element operation = new Element("operation");
                        operation.setAttribute("name", func[2]);
                        operation.setAttribute("type", func[0]);
                        // 生成req节点，属operation下一级节点
                        Element req = new Element("req");
                        Element rsp = null;
                        /**
                         * 如果函数是twoway类型则生成rsp节点 rsp节点下第一个param为函数调用结果
                         */
                        if (func[0].equals("twoway")) {
                                rsp = new Element("rsp");
                                Element resultP = new Element("param");
                                Element resultN = new Element("node");
                                resultN.setAttribute("name", "call_result");
                                resultN.setAttribute("type", "oct");
                                resultN.setAttribute("value", "");
                                resultP.addContent(resultN);
                                rsp.addContent(resultP);
                        }

                        //函数返回值转换
                        retToXML(rsp, func[1]);
                        //函数参数转换
                        paramToXML(req, rsp, func[3]);

                        operation.addContent(req);
                        if (rsp != null) {
                                operation.addContent(rsp);
                        }
                        optRoot.addContent(operation);

                }