www.51testing.com - 查看同站点书签

查看同站点书签

资料下载
添加人:Spark.lee 时间:2007-01-09 11:57:10 已有 520 人点击, 0 人评论
暂无
51testing软件测试网
添加人:沉默风云时间:2007-02-05 14:22:28 已有 297 人点击, 0 人评论
暂无
软家测试面试三部曲
添加人:SOG 时间:2007-02-05 22:23:32 已有 1002 人点击, 0 人评论
暂无
黑盒测“外”不测“内”
添加人:鱼鳞时间:2007-02-27 17:41:14 已有 412 人点击, 0 人评论
软件测试有许多种方法，其中黑盒测试是广泛使用的两类测试方法之一。　　“黑盒”测的是功能 .......
黑盒测“外”不测“内”
添加人:annayin 时间:2007-02-28 16:46:01 已有 660 人点击, 0 人评论
51testing软件测试网（慧谷-博为峰软件测试工作室）
添加人:hhxwxg 时间:2007-03-15 22:27:58 已有 389 人点击, 0 人评论
暂无
软件测试专业网站
添加人:zzz_zhou 时间:2007-03-22 11:10:09 已有 207 人点击, 0 人评论
暂无
软件测试
添加人:WJB_IVAN 时间:2007-04-25 23:09:18 已有 415 人点击, 0 人评论
暂无
sendkeys的妙用
添加人:qixiafeng 时间:2007-04-27 14:30:31 已有 290 人点击, 0 人评论
sendkeys的妙用
性能测试计划
添加人:soswhp 时间:2007-04-30 08:56:40 已有 1154 人点击, 0 人评论
性能测试计划
性能测试经验分享
添加人:soswhp 时间:2007-04-30 09:07:20 已有 399 人点击, 0 人评论
性能测试经验分享
性能测试（并发负载压力）测试分析
添加人:soswhp 时间:2007-04-30 09:08:02 已有 359 人点击, 0 人评论
性能测试（并发负载压力）测试分析
《WEB性能测试实战》之WEB性能测试分析（一）
添加人:soswhp 时间:2007-04-30 09:13:12 已有 711 人点击, 0 人评论
—《WEB性能测试实战》之WEB性能测试分析（一）
叶帆小筑
添加人:zhoulihua 时间:2007-05-03 09:24:30 已有 358 人点击, 0 人评论
暂无
友情链接1
添加人:god 时间:2007-05-17 23:31:40 已有 367 人点击, 2 人评论
暂无
测试前辈的博客
添加人:guxingyun 时间:2007-05-18 09:04:25 已有 183 人点击, 1 人评论
来自风在吹的浏览标签 http://www.51testing.com/?68246/action_spacelist_type_link_view_track.html 其中有loadrunner教程、测试实战等内容学习后再做介绍
测试者家园
添加人:jfioe 时间:2007-05-21 00:55:42 已有 931 人点击, 0 人评论
关于自动化，性能测试
简介：使用automation object model进行QTP自动化编程
添加人:erics 时间:2007-05-22 13:32:36 已有 801 人点击, 0 人评论
暂无
惰性，职业生涯的无形杀手
添加人:guxingyun 时间:2007-05-24 09:57:25 已有 269 人点击, 0 人评论
惰性，身惰、思惰、心惰。
NUnit详细用法(转)
添加人:guxingyun 时间:2007-05-24 23:18:46 已有 207 人点击, 0 人评论
测试驱动开发看过一点点，不过那时没有涉猎，以为是心虚，现在看来是懒的缘故，2007年，向着新的目标前进。测试驱动开发，我会想着你，一步步地走近你。
幽默笑话--让你顿悟人生
添加人:guxingyun 时间:2007-05-28 18:33:51 已有 157 人点击, 0 人评论
读来幽默，想来智慧。
软件测试常见面试题
添加人:Raymondzfy 时间:2007-06-02 14:39:01 已有 1020 人点击, 1 人评论
暂无
新概念英语
添加人:Jair 时间:2007-06-13 09:43:28 已有 319 人点击, 0 人评论
暂无
软件测试专业网站51Testing软件测试网
添加人:believe 时间:2007-06-21 17:00:03 已有 344 人点击, 0 人评论
暂无
测试工程师10最
添加人:qiuxztz 时间:2007-07-20 16:46:30 已有 389 人点击, 0 人评论
暂无
软件测试十原则
添加人:qiuxztz 时间:2007-07-20 16:48:45 已有 166 人点击, 0 人评论
暂无
软件测试从零开始
添加人:guxingyun 时间:2007-07-22 08:08:17 已有 352 人点击, 0 人评论
【摘要】本文面向软件测试新手，从测试前的准备工作、测试需求收集、测试用例设计、测试用例执行、测试结果分析几个方面给出建议和方法。鉴于国内的软件开发、测试不规范的现状，本文为软件测试新手提供了若干个软件测试的关注点。【自我认识：阅读完本文后，审视自己测试的流程，发觉“利用已有的软件checklist”和“加强测试用例的评审”相关的内容在自己的测试过程中做的不够好或者有时根本就忽略了这个流程，仅管对于每一个测试人员所处的环境及其测试流程都有差异，但有些好的方法还是值得借鉴的。将本文《软件测试从零开始》作为书签记录在这里，每每读罢，总会有所收益。
测试用例
添加人:bluepeng 时间:2007-07-26 13:51:04 已有 284 人点击, 0 人评论
测试用例
面试十大必考题
添加人:lijiang816 时间:2007-07-27 20:34:25 已有 395 人点击, 0 人评论
暂无
数据驱动在QTP的运用
添加人:zhjd4839 时间:2007-07-30 17:35:52 已有 433 人点击, 0 人评论
暂无
小蚂蚁
添加人:ruanyongjie 时间:2007-08-01 15:47:25 已有 530 人点击, 0 人评论
小蚂蚁测试历程
无忧测试论坛精华帖
添加人:ruanyongjie 时间:2007-08-02 10:40:46 已有 397 人点击, 0 人评论
暂无
一个软件测试员的blog
添加人:hhxwxg 时间:2007-08-04 17:20:54 已有 232 人点击, 0 人评论
主要可以查看他里面总结的关于linux的东西。
TD与QTP连接
添加人:bluelightmm 时间:2007-08-16 10:14:57 已有 306 人点击, 0 人评论
TD与QTP连接
解决回放时浏览器乱码问题(转载)
添加人:bluelightmm 时间:2007-08-16 10:16:35 已有 239 人点击, 0 人评论
解决回放时浏览器乱码问题(转载)
实现完整测试的思路和方法
添加人:bluelightmm 时间:2007-08-16 10:23:07 已有 154 人点击, 0 人评论
实现完整测试的思路和方法
行百里路半九十 ERP项目的验收测试
添加人:bluelightmm 时间:2007-08-16 11:44:04 已有 161 人点击, 0 人评论
行百里路半九十 ERP项目的验收测试
性能测试的门槛
添加人:bluelightmm 时间:2007-08-17 10:11:35 已有 112 人点击, 0 人评论
性能测试的门槛
软件测试缺陷报告实用写作技术
添加人:bluelightmm 时间:2007-08-17 10:27:04 已有 231 人点击, 0 人评论
软件测试缺陷报告实用写作技术
从用户关心的角度对软件BUG进行分类
添加人:bluelightmm 时间:2007-08-20 17:08:51 已有 161 人点击, 0 人评论
从用户关心的角度对软件BUG进行分类
老徐BLOG
添加人:zengfanjin5588 时间:2007-09-03 08:59:51 已有 479 人点击, 0 人评论
暂无
测试小屋
添加人:zengfanjin5588 时间:2007-09-03 09:03:20 已有 402 人点击, 0 人评论
暂无
小谈手机测试中和网络相关的几个问题
添加人:孤星凌云时间:2009-08-05 09:34:32 已有 153 人点击, 0 人评论
Rational
添加人:ypeony 时间:2007-09-06 20:45:57 已有 282 人点击, 0 人评论
暂无
如何做好测试工作
添加人:bluelightmm 时间:2007-09-20 11:17:40 已有 246 人点击, 0 人评论
如何做好测试工作
性能测试
添加人:bluelightmm 时间:2007-09-20 11:21:24 已有 140 人点击, 0 人评论
性能测试
如何进行自动化测试
添加人:bluelightmm 时间:2007-09-20 11:29:42 已有 315 人点击, 0 人评论
如何进行自动化测试
cmm
添加人:onlymezyb 时间:2007-09-29 14:33:32 已有 331 人点击, 0 人评论
暂无
关于 JUnit 测试中某些测试方法的顺序信赖性有两种解决方法
添加人:slsunsl 时间:2007-10-24 11:30:54 已有 489 人点击, 0 人评论
关于 JUnit 测试中某些测试方法的顺序信赖性有两种解决方法发布时间: 2007-10-15 18:15 作者: breadest 来源: breadest的专栏字体: 小中大 | 上一篇下一篇 | 打印 | 我要投稿　　关于 JUnit 测试中某些测试方法的顺序信赖性有两种解决方法：（但是怎么结果并没有达到我要的效果，我希望如果前面的测试失败，则后面的所有有信赖于这个测试的测试都失败）（1）为每个测试类添中一个 suite() 方法 public static Test suite() { TestSuite suite = new TestSuite("edu.dhu.zkl.tools.FileSwithWithMemoryTest");
SIM卡
添加人:slsunsl 时间:2007-10-24 15:00:16 已有 193 人点击, 0 人评论
暂无
LoadRunner录制脚本中的中文乱码问题
添加人:slsunsl 时间:2007-10-26 16:55:55 已有 1924 人点击, 3 人评论
在使用LoadRunner 8.1 进行录制脚本，其脚本中中文信息存在乱码，其解决方法如下所示： 1、新建脚本--->选择协议（Http）-->选项-->高级-->选择“支持字符集”并点选“UTF-8”； 2、在回放脚本之前：Vuser-->运行时设置-->浏览器-->浏览器仿真-->更改-->使用浏览器-->语言下来选择 “中文（中国）”；进行如上设置以后即可。补充说明：主要看被测试应该程序的编码形式是什么。如果是UTF-8的形式则采用上述形式设置，如果是Gb2312则不进行步骤1、的操作。感觉步骤2、不是很重要，如果哪位有更确切跟合理的解释，请多赐教:）文章引用自：
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
解析软件测试职位五大优势
添加人:helen51 时间:2007-10-09 19:45:49 已有 356 人点击, 0 人评论
据前程无忧“无忧指数”显示，软件测试工程师已经成为2007年最紧缺的人才之一，该类职位的需求主要集中在沿海发达城市，其中北京和上海的需求量分别占去了33%和29%；而从企业分布来看，民企需求量最大，占了19%，外商独资欧美类企业需求排列第二，占了15%。30－40万的人才缺口使得越来越多的人开始关注这个职业，其五大优势更是吸引求职者的关键所在。
负载压力测试基础概念
添加人:bluelightmm 时间:2007-10-10 16:37:57 已有 157 人点击, 0 人评论
负载压力测试基础概念
敏捷与质量
添加人:bluelightmm 时间:2007-10-10 15:54:53 已有 142 人点击, 0 人评论
敏捷与质量
浅谈－易用性测试
添加人:bluelightmm 时间:2007-10-10 16:38:41 已有 688 人点击, 3 人评论
浅谈－易用性测试
Loadrunner学习笔记_内存相关
添加人:bluelightmm 时间:2007-10-10 17:18:54 已有 178 人点击, 0 人评论
Loadrunner学习笔记_内存相关
Loadrunner学习笔记_磁盘相关
添加人:bluelightmm 时间:2007-10-10 17:22:03 已有 114 人点击, 0 人评论
Loadrunner学习笔记_磁盘相关
(一)QTP关键技术
添加人:bluelightmm 时间:2007-10-10 17:57:27 已有 129 人点击, 0 人评论
(一)QTP关键技术
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
QTP识别和操作对象的原理[转]
添加人:slsunsl 时间:2007-10-26 17:07:45 已有 391 人点击, 2 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
添加人: 时间: 已有人点击, 人评论
、QTP识别对象的原理 QTP里的对象有两个概念，一个是Test Object（简称TO），一个是Runtime Object（简称RO）。这两个概念从字面上不大好理解，也容易混淆。但从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。 QTP识别对象，一般是要求先在对象仓库文件里定义仓库对象，里面存有实际对象的特征属性的值。然后在运行的时候，QTP会根据脚本里的对象名字，在对象仓库里找到对应的仓库对象，接着根据仓库对象的特征属性描述，在被测试软件里搜索找到相匹配的实际对象，最后就可以对实际对象进行操作了。仓库对象TO一般在录制/编写脚本时加入仓库文件，它不仅可以在录制编写时进行修改，也可以在运行过程中进行动态修改，以匹配实际对象。和TO、RO相关的几个函数有： GetTOProperty():取得仓库对象的某个属性的值 GetTOProperties():取得仓库对象的所有属性的值 SetTOProperty():设置仓库对象的某个属性的值 GetROProperty():取得实际对象的某个属性的值理解了TO的含义，你就可以自由的用SetTOProperty()定义TO，以灵活的操作RO 比如有个测试任务，窗口上有很多待检查的记录，每条记录右边都有一个Check按钮，用来检查各条记录。记录个数不定，所以Check按钮个数也就不定，只有一个Edit显示记录个数。我们要对每条记录进行检查，也就是要点击每个Check按钮。但是Check按钮个数不定，不好录制，而且个数可能也很多（上百个），即使能一一录制，那也很麻烦。那我有一个好办法，只录制一个按钮对象，它设有两个特征属性 label=OK, index=0 然后用下面的脚本，就可以完成测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("Check").SetTOProperty("index", buttonIndex) JavaWindow("Test").JavaButton("Check").Click Next 或者窗口上有New、Modify、Delete、Check等好几个按钮，要把这几个按钮一一按过去我在对象仓库里只设置一个按钮对象AnyButton，label特征属性值填任意值，然后用下面脚本执行测试 JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "New") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Modify") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Delete") JavaWindow("Test").JavaButton("AnyButton").Click JavaWindow("Test").JavaButton("AnyButton").SetTOProperty("label", "Check") JavaWindow("Test").JavaButton("AnyButton").Click 另外，QTP还支持脚本描述的方法来定义和访问对象，即不需要在仓库里定义，也能访问和操作实际对象如上面两个任务，可以如下实现 1. 不需要在仓库里定义Check按钮对象，直接用下面脚本来实现测试 buttonNum = CInt(JavaWindow("Test").JavaEdit("Record Num").GetROProperty("value")) For buttonIndex = 0 to buttonNum - 1 JavaWindow("Test").JavaButton("label:=Check", "index:="+CStr(buttonIndex)).Click Next 2. 不需要在仓库里定义New、Modify、Delete、Check按钮对象，直接用下面脚本来实现测试 JavaWindow("Test").JavaButton("label:=New").Click JavaWindow("Test").JavaButton("label:=Modify").Click JavaWindow("Test").JavaButton("label:=Delete").Click JavaWindow("Test").JavaButton("label:=Check").Click 二、QTP操作对象的原理 QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，只要做过软件开发，使用过控件的人应该很清楚。对象的封装接口是QTP为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属性名或方法名，封装接口就不用在对象名后面加object。具体格式如下：对实际对象的操作：对象.object.自身属性对象.object.自身方法() 对象.GetROProperty("封装属性") 对象.封装方法() 对仓库对象的操作：对象.GetTOProperty("封装属性") 对象.GetTOProperties() ’获取所有封装属性的值对象.SetTOProperty("封装属性", "封装属性值") 比如操作JavaEdit对象，通过QTP封装的封装接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").Set "NE1" 读取JavaEdit的内容： msgbox JavaDialog("Add NE").JavaEdit("NE Name").GetROProperty("value") 如果通过JavaEdit的自身接口，脚本如下：设置JavaEdit的内容： JavaDialog("Add NE").JavaEdit("NE Name").object.setText("NE1") 读取JavaEdit的内容： Msgbox JavaDialog("Add NE").JavaEdit("NE Name").object.getText() QTP执行JavaEdit().Set语句时，是通过执行JavaEdit().object.setText()来实现的。 QTP执行JavaEdit().GetROProperty("value"),是通过执行JavaEdit().object.getText()来实现的。 JavaEdit对象的封装接口Set()和GetROProperty("value")，是QTP封装JavaEdit对象的自身接口setText()和getText()而得来的。对象的封装接口是QTP使用的缺省接口，我们录制出来的脚本都是使用封装接口，大家用的也都是封装接口。但是封装接口不如自身接口丰富，因为QTP只是封装了部分常用的自身接口嘛。所以我们在需要时，可以绕过封装接口，直接调用对象的自身接口。不过有些自身接口不够稳定，在实践中偶尔会出现问题，但是概率很少。封装接口有相应功能的话，就尽量用封装接口吧！理解了封装接口和自身接口的原理，我们就可以更加灵活的操作对象了。但是我们怎么知道对象都有哪些封装接口和自身接口呢？其实很简单，用对象查看器（Object Spy）查看对象，在查看窗口里有列出这些接口，包括属性和方法。窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）（注意：GetROProperty访问的是实际对象的封装接口，GetTOProperty访问的是仓库对象的封装接口，两者访问的都是对象的封装接口，即Object Spy窗口里选Test Object时显示的属性。不要以为GetROProperty访问的是自身接口，即Object Spy窗口里选Run-time Object时显示的属性。 QTP里的Test Object/Run-time Object的概念太容易让人混淆了！它既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。）明白了这些，你还等什么呢？快拿起对象查看器，看看对象都有哪些封装接口和自身接口，肆意的操作它，玩弄它吧！比如执行 JavaDialog("Add NE").JavaEdit("NE Name").object.setVisible(false) 哈哈，你的JavaEdit对象就当场消失不见了！！！
Eclipse中Ant的配置与测试
添加人:sandybuster 时间:2007-11-06 09:53:11 已有 131 人点击, 0 人评论
暂无
用Ant自动测试JUnit
添加人:sandybuster 时间:2007-11-06 09:55:03 已有 282 人点击, 0 人评论
暂无
10大负面测试用例
添加人:sandybuster 时间:2007-11-06 10:03:34 已有 378 人点击, 0 人评论
暂无
白盒测试
添加人:lth009 时间:2007-11-14 16:05:57 已有 363 人点击, 0 人评论
白盒测试是软件测试体系中一个分支，测试关注对象是一行行可见代码，如果代码不可见就不是白盒，是黑盒测试了。
最火辣瘦腹呼吸法惊爆网络
添加人:lth009 时间:2007-11-14 17:35:10 已有 270 人点击, 0 人评论
暂无
性能监控之I/O篇
添加人:thefirstred 时间:2007-11-29 17:05:21 已有 590 人点击, 0 人评论
暂无
QTP常见问题解答三
添加人:junlingliu 时间:2007-12-05 16:42:33 已有 374 人点击, 0 人评论
上下页翻,一二三都有了.
循序渐进学习QTP三步曲(转)
添加人:ztt8402 时间:2007-12-03 17:10:56 已有 450 人点击, 0 人评论
暂无
QTP日志实践的几点总结(转)
添加人:ztt8402 时间:2007-12-03 17:06:48 已有 358 人点击, 0 人评论
暂无
自动化实现的两个难点-功能分解和对象识别
添加人:xiong226434 时间:2007-12-17 18:26:29 已有 508 人点击, 0 人评论
暂无
脚本语言
添加人:xiong226434 时间:2007-12-17 18:29:50 已有 464 人点击, 0 人评论
暂无
QTP
添加人:xiong226434 时间:2007-12-17 18:43:15 已有 430 人点击, 0 人评论
暂无
自动化
添加人:xiong226434 时间:2007-12-17 18:34:19 已有 123 人点击, 0 人评论
暂无
数据驱动
添加人:xiong226434 时间:2007-12-17 18:45:49 已有 422 人点击, 0 人评论
暂无
QC
添加人:xiong226434 时间:2007-12-17 18:47:10 已有 729 人点击, 0 人评论
暂无
自定义
添加人:xiong226434 时间:2007-12-17 18:48:10 已有 343 人点击, 0 人评论
暂无
WEB测试
添加人:happyzuozuo2008 时间:2007-12-19 13:55:15 已有 386 人点击, 0 人评论
暂无
模板
添加人:ypeony 时间:2007-12-20 09:24:53 已有 319 人点击, 0 人评论
暂无
SQL在线查询帮助手册
添加人:happyzuozuo2008 时间:2007-12-20 13:42:46 已有 291 人点击, 0 人评论
暂无
深入研究LR监控原理----linux服务器监控基础1
添加人:thefirstred 时间:2007-12-24 08:53:18 已有 518 人点击, 0 人评论
暂无
深入研究LR监控原理----linux服务器监控基础
添加人:thefirstred 时间:2007-12-24 08:54:07 已有 397 人点击, 0 人评论
暂无
TestDirector项目数据迁移
添加人:elisly 时间:2007-12-25 15:27:39 已有 182 人点击, 0 人评论
TestDirector项目数据迁移
11种方法检测软件可靠性
添加人:xiaocuier 时间:2007-12-26 15:09:55 已有 296 人点击, 0 人评论
介绍测试软件安全性和可靠性的一些方法
李老师个人空间的链接！
添加人:xucz 时间:2007-12-27 17:45:03 已有 277 人点击, 0 人评论
51testing老师！
挪威森林的测试人生
添加人:傲然时间:2008-01-02 23:07:51 已有 585 人点击, 0 人评论
暂无
QTP基础代码交流
添加人:junlingliu 时间:2008-01-04 14:27:34 已有 568 人点击, 0 人评论
包含随机数,等待一窗口出现,获取对象属性名,创建log等等.
lwy 个人空间
添加人:ssy2010 时间:2008-01-08 14:52:22 已有 428 人点击, 0 人评论
暂无
一个典型的代码走查检查单
添加人:thefirstred 时间:2008-01-17 15:27:14 已有 411 人点击, 0 人评论
暂无
软件测试自动化框架
添加人:spanover 时间:2008-01-28 11:20:23 已有 286 人点击, 0 人评论
收藏文章
(原创)基于WATIR+RAILS+STAF的自动化测试框架(持续更新中...)
添加人:wzstar2008 时间:2008-02-02 14:05:32 已有 591 人点击, 0 人评论
暂无
WINDOWS常用命令集
添加人:guoqing423 时间:2008-02-13 20:24:26 已有 107 人点击, 0 人评论
www.51testing.com/?145083/action_viewspace_itemid_74512.html
测试计划描述了如何进行测试
添加人:elisly 时间:2008-02-29 15:41:08 已有 352 人点击, 0 人评论
http://www.51testing.com/?action_viewnews_itemid_74952.html
软件测试的流程规范
添加人:elisly 时间:2008-02-29 15:43:50 已有 652 人点击, 0 人评论
软件测试的流程规范
QTP中一些基础代码结构累积
添加人:junlingliu 时间:2008-03-06 11:21:55 已有 471 人点击, 0 人评论
可以学习下!
LoadRunner编程之文件的操作
添加人:yanmou626 时间:2008-03-06 18:32:29 已有 260 人点击, 0 人评论
暂无
测试过程中如何应对频繁的版本变更
添加人:cocayang 时间:2008-03-11 14:01:21 已有 486 人点击, 0 人评论
测试过程中如何应对频繁的版本变更
软件咨询师博客
添加人:兰兰时间:2008-03-13 16:46:58 已有 467 人点击, 0 人评论
暂无
testlink_1
添加人:joweywen23 时间:2008-03-17 10:13:56 已有 148 人点击, 0 人评论
暂无
testlink_2
添加人:joweywen23 时间:2008-03-17 10:14:57 已有 120 人点击, 0 人评论
暂无
Linux操作系统下内存泄漏的检查方法
添加人:thefirstred 时间:2008-03-20 16:22:51 已有 331 人点击, 0 人评论
暂无
SQL注入原理，值得一看！
添加人:breezeforever 时间:2008-03-26 17:33:08 已有 394 人点击, 0 人评论
暂无
界面测试软件测试专业网站:51Testing软件测试网 s Xh8XtS{q
添加人:breezeforever 时间:2008-03-27 13:41:20 已有 225 人点击, 0 人评论
暂无
界面规范
添加人:breezeforever 时间:2008-03-27 13:55:41 已有 377 人点击, 0 人评论
暂无
WEB测试中常用的链接测试工具
添加人:breezeforever 时间:2008-03-27 14:02:40 已有 330 人点击, 0 人评论
暂无
网站链接自动化测试原理及工具介绍
添加人:breezeforever 时间:2008-03-27 14:50:08 已有 149 人点击, 0 人评论
暂无
TD管理员手册
添加人:江南飞雪时间:2008-03-27 22:12:48 已有 407 人点击, 0 人评论
暂无
理解并选择测试[转]
添加人:mnrslyl 时间:2008-03-28 20:44:06 已有 228 人点击, 0 人评论
暂无
我来谈谈WinRunner和QTP的区别
添加人:breezeforever 时间:2008-03-31 13:40:22 已有 405 人点击, 0 人评论
暂无
《自动化测试工具介绍QTP篇》——新手必看
添加人:breezeforever 时间:2008-03-31 13:46:11 已有 770 人点击, 1 人评论
暂无
中国软件测试基地
添加人:zuojingqin 时间:2008-03-31 14:32:27 已有 140 人点击, 0 人评论
暂无
测试时代（网站）
添加人:zuojingqin 时间:2008-03-31 14:35:13 已有 114 人点击, 0 人评论
暂无
陈雷-jackei 的测试生活
添加人:zuojingqin 时间:2008-03-31 14:37:56 已有 287 人点击, 0 人评论
暂无
李丽君-小蚂蚁测试历程
添加人:zuojingqin 时间:2008-03-31 14:41:31 已有 134 人点击, 0 人评论
暂无
sql插入多条记录
添加人:江南飞雪时间:2008-04-01 11:34:35 已有 246 人点击, 0 人评论
declare @i int set @i=1 while @i<101 begin insert into 表名（）values() set @i=@i+1 end
QTP描述性编程
添加人:breezeforever 时间:2008-04-07 14:31:56 已有 385 人点击, 0 人评论
暂无
软件测试过程管理实践
添加人:breezeforever 时间:2008-04-08 09:46:44 已有 342 人点击, 0 人评论
暂无
一位软件工程师的6年总结
添加人:mnrslyl 时间:2008-04-08 17:07:40 已有 99 人点击, 0 人评论
1、分享第一条经验：“学历代表过去、能力代表现在、学习力代表未来。”其实这是一个来自国外教育领域的一个研究结果。相信工作过几年、十几年的朋友对这个道理有些体会吧。但我相信这一点也很重要：“重要的道理明白太晚将抱憾终生！”所以放在每一条，让刚刚毕业的朋友们早点看到哈！ 2、一定要确定自己的发展方向，并为此目的制定可行的计划。不要说什么，“我刚毕业，还不知道将来可能做什么？”，“跟着感觉走，先做做看”。因为，这样的观点会通过你的潜意识去暗示你的行为无所事事、碌碌无为。一直做技术，将来成为专家级人物？向管理方向走，成为职业经理人？先熟悉行业和领域，将来自立门户？还是先在行业里面混混，过几年转行做点别的？这很重要，它将决定你近几年、十年内“做什么事情才是在做正确的事情！”。 3、软件开发团队中，技术不是万能的，但没有技术是万万不能的！在技术型团队中，技术与人品同等重要，当然长相也比较重要哈，尤其在MM比较多的团队中。在软件项目团队中，技术水平是受人重视和尊重的重要砝码。无论你是做管理、系统分析、设计、编码，还是产品管理、测试、文档、实施、维护，多少你都要有技术基础。算我孤陋寡闻，我还真没有亲眼看到过一个外行带领一个软件开发团队成功地完成过软件开发项目，哪怕就一个，也没有看到。倒是曾经看到过一个“高学历的牛人”(非技术型)带一堆人做完过一个项目，项目交付的第二天，项目组成员扔下一句“再也受不了啦！”四分五裂、各奔东西。那个项目的“成功度”大家可想而知了。 4、详细制定自己软件开发专业知识学习计划，并注意及时修正和调整(软件开发技术变化实在太快)。请牢记：“如果一个软件开发人员在1、2年内都没有更新过自己的知识，那么，其实他已经不再属于这个行业了。”不要告诉自己没有时间。来自时间管理领域的著名的“三八原则”告诫我们：另外的那8小时如何使用将决定你的人生成败！本人自毕业以来，平均每天实际学习时间超过2小时。 5、书籍是人类进步的阶梯，对软件开发人员尤其如此。书籍是学习知识的最有效途径，不要过多地指望在工作中能遇到“世外高人”，并不厌其烦地教你。对于花钱买书，我个人经验是：千万别买国内那帮人出的书！我买的那些家伙出的书，!00%全部后悔了，无一本例外。更气愤的是，这些书在二手市场的地摊上都很难卖掉。“拥有书籍并不表示拥有知识；拥有知识并不表示拥有技能；拥有技能并不表示拥有文化；拥有文化并不表示拥有智慧。”只有将书本变成的自己智慧，才算是真正拥有了它。 ..............................................
利用正交表设计测试用例
添加人:breezeforever 时间:2008-04-21 10:03:25 已有 670 人点击, 0 人评论
暂无
浮躁的国内测试界—2006年测试人员招聘感悟
添加人:nove 时间:2008-04-21 20:37:57 已有 129 人点击, 0 人评论
本文是作者在2006年测试人员招聘会上的亲身经历。或许这个题目涉及范围太大，打击面太大，本可以加上一长串的修饰语，来缩小这个圈子，也完全可以保持沉默。但作者身为测试届中青年一代，认为自己有责任提出自己的观点，大家有则改之，无则加冕。从作者的亲身经历中我们可以看得出，国内的测试界确实还需努力。
软件测试浅悟妄语
添加人:瘦月清霜时间:2008-05-08 17:09:00 已有 235 人点击, 0 人评论
暂无
服务器稳定性测试
添加人:瘦月清霜时间:2008-05-09 14:13:16 已有 490 人点击, 0 人评论
暂无
论坛会员叶子的空间
添加人:jtiger 时间:2008-05-12 09:42:51 已有 121 人点击, 0 人评论
暂无
论坛会员Architecturer的个人空间
添加人:jtiger 时间:2008-05-12 10:37:28 已有 68 人点击, 0 人评论
暂无
图片验证码性能测试解决方案
添加人:jfioe 时间:2008-05-12 14:31:29 已有 302 人点击, 0 人评论
暂无
BOLG
添加人:nickzx 时间:2008-05-17 16:28:36 已有 302 人点击, 0 人评论
暂无
测试英语汇总
添加人:cybchen 时间:2008-05-20 16:01:15 已有 399 人点击, 0 人评论
暂无
软件测试工程师如何规划自己的职业生涯？
添加人:ztt8402 时间:2008-05-30 11:23:38 已有 392 人点击, 0 人评论
暂无
人月神话的BLOG
添加人:rainbow66 时间:2008-06-01 12:31:50 已有 90 人点击, 0 人评论
暂无
人月神话的BLOG
添加人:rainbow06 时间:2008-06-01 12:33:43 已有 192 人点击, 0 人评论
暂无
软件测试的配置管理：多个敏捷团队之间的版本控制
添加人:mnrslyl 时间:2008-06-03 15:36:19 已有 184 人点击, 0 人评论
暂无
配置管理工具比较（一）
添加人:mnrslyl 时间:2008-06-03 16:33:36 已有 173 人点击, 0 人评论
暂无
配置管理工具比较（二）
添加人:mnrslyl 时间:2008-06-03 16:34:27 已有 87 人点击, 0 人评论
暂无
软件测试配置项变更控制报告
添加人:mnrslyl 时间:2008-06-03 17:09:03 已有 310 人点击, 0 人评论
暂无
Rational产品配置案例
添加人:mnrslyl 时间:2008-06-03 17:17:25 已有 191 人点击, 0 人评论
暂无
软件质量保证（SQA
添加人:mnrslyl 时间:2008-06-03 18:00:01 已有 163 人点击, 0 人评论
暂无
浅谈QA所应该具备的知识
添加人:mnrslyl 时间:2008-06-03 21:50:01 已有 342 人点击, 0 人评论
暂无
測試者
添加人:xmeagle 时间:2008-06-12 12:14:44 已有 166 人点击, 0 人评论
暂无
51testing 软件测试网
添加人:Apple.Liu 时间:2008-06-13 16:03:21 已有 303 人点击, 0 人评论
暂无
IP欺骗
添加人:ench033 时间:2008-06-18 18:59:50 已有 419 人点击, 0 人评论
暂无
测试工程师如何规划自己的职业生涯？
添加人:mnrslyl 时间:2008-06-19 13:29:58 已有 381 人点击, 0 人评论
暂无
黑盒测“外”
添加人:Salanganezhou 时间:2008-07-07 15:42:52 已有 401 人点击, 0 人评论
暂无
界面测试
添加人:Salanganezhou 时间:2008-07-10 11:49:26 已有 468 人点击, 0 人评论
暂无
转载：Rational Robot 的自动化功能测试框架
添加人:baby123322 时间:2008-07-11 16:22:35 已有 432 人点击, 0 人评论
暂无
测试
添加人:catvivi 时间:2008-07-14 11:15:10 已有 99 人点击, 0 人评论
暂无
一步一脚印
添加人:liu_alina 时间:2008-07-14 18:06:53 已有 263 人点击, 0 人评论
暂无
阿里巴巴QA架构组成长空间
添加人:msnshow 时间:2008-07-22 09:33:50 已有 1047 人点击, 0 人评论
录阿里巴巴QA架构组成长点滴。2008年关键词为效率，技术，影响力！QA/测试架构师定义:开发和设计测试框架测试库；纵横全局的考虑产品的功能，设计复杂的测试系统；负责研发某一项特定的测试技术；为公司考虑如何提高测试效率。领导公司测试技术的发展和测试策略上的方向,关注整个公司的测试部门的问题,前瞻性的考虑未来的版本的测试策略和技术。测试架构师计划/设计测试平台，关注着产品的测试过程，提供咨询服务，影响到公司内的测试机构测试社区，以及开发机构等，对产品各个方面施加深远而正确的影响，最终提高整体软件质量。
牛人博客
添加人:s154098121 时间:2008-07-22 15:04:34 已有 177 人点击, 0 人评论
暂无
学习（阿里巴巴）
添加人:lovsnow 时间:2008-07-23 16:23:13 已有 288 人点击, 0 人评论
阿里巴巴做测试的前辈。学习的榜样
云层
添加人:wnc0309 时间:2008-08-17 18:23:04 已有 146 人点击, 0 人评论
暂无
<loadrunner没有告诉你的>和《Jmeter从入门到精通》
添加人:zishuijing 时间:2008-08-27 10:37:09 已有 355 人点击, 0 人评论
收藏blog
zee的个人空间
添加人:zishuijing 时间:2008-08-27 10:41:51 已有 179 人点击, 0 人评论
zee测试blog收藏
如何成为优秀的软件测试人员
添加人:breezeforever 时间:2008-08-29 09:03:31 已有 220 人点击, 0 人评论
暂无
“文档”不误“测试”功
添加人:thefirstred 时间:2008-09-03 10:25:30 已有 344 人点击, 0 人评论
关于测试文档的一篇文章
尘埃落定的空间
添加人:renf 时间:2008-09-17 14:54:26 已有 82 人点击, 0 人评论
暂无
极力推荐这位姐姐的空间
添加人:jiaozhigang1984 时间:2008-09-21 23:17:35 已有 86 人点击, 0 人评论
http://www.51testing.com/?34866
taotao的个人空间
添加人:zishuijing 时间:2008-09-28 09:30:53 已有 163 人点击, 0 人评论
暂无
胡瑞海的个人空间
添加人:renf 时间:2008-10-07 16:32:52 已有 331 人点击, 0 人评论
暂无
Parasoft C++test视频演示
添加人:52zhuzhu 时间:2008-10-10 14:06:19 已有 307 人点击, 0 人评论
暂无
C++Test的使用说明
添加人:52zhuzhu 时间:2008-10-10 15:01:20 已有 260 人点击, 0 人评论
暂无
C++TEST基本概述
添加人:52zhuzhu 时间:2008-10-10 15:02:37 已有 307 人点击, 0 人评论
暂无
软件名称：Parasoft C++test视频演示
添加人:52zhuzhu 时间:2008-10-10 15:06:50 已有 388 人点击, 1 人评论
暂无
翻页功能测用例设计
添加人:wangpl4092 时间:2008-10-20 15:14:17 已有 336 人点击, 0 人评论
暂无
51Testing丛书连载：(一)性能测试从零开始
添加人:testlike 时间:2008-10-21 10:30:04 已有 227 人点击, 0 人评论
暂无
IP欺骗的经验和教训
添加人:如果弯弯时间:2013-01-09 15:59:33 已有 197 人点击, 0 人评论
使用QALoad做性能测试简要介绍
添加人:zishuijing 时间:2008-10-22 11:11:10 已有 503 人点击, 0 人评论
暂无
QTP中常用的VBS函数
添加人:jhui008 时间:2008-11-05 13:26:37 已有 308 人点击, 0 人评论
暂无
some books
添加人:suntomoon 时间:2008-11-17 22:22:15 已有 287 人点击, 0 人评论
暂无
微软的测试方法
添加人:wangz 时间:2008-11-21 18:35:42 已有 264 人点击, 0 人评论
暂无
WinRunner and QuickTest Pro 的适用领域
添加人:suntomoon 时间:2008-11-24 22:37:11 已有 400 人点击, 0 人评论
暂无
51testing网址
添加人:zfh1005 时间:2008-11-29 17:22:21 已有 196 人点击, 0 人评论
全国做大的专门介绍软件测试技术，发展及提供培训的网络站点！
测试用例设计白皮书
添加人:GYBHBY 时间:2008-12-12 18:57:32 已有 154 人点击, 0 人评论
暂无
小刀刀blog_列表_51Testing软件测试网 - powered by X-Space
添加人:GYBHBY 时间:2008-12-14 23:21:32 已有 300 人点击, 0 人评论
web安全薄弱点
添加人:GYBHBY 时间:2008-12-14 23:21:32 已有 283 人点击, 0 人评论
web应用系统易出问题的原因和测试要点
添加人:GYBHBY 时间:2008-12-14 23:21:32 已有 134 人点击, 0 人评论
WEB测试_文章精选
添加人:GYBHBY 时间:2008-12-14 23:21:32 已有 122 人点击, 0 人评论
web测试容易遗漏的地方
添加人:GYBHBY 时间:2008-12-14 23:21:32 已有 120 人点击, 0 人评论
[Web测试]输入框的测试
添加人:GYBHBY 时间:2008-12-14 23:21:32 已有 156 人点击, 0 人评论
一个安全测试的checklist
添加人:GYBHBY 时间:2008-12-14 23:21:32 已有 239 人点击, 0 人评论
关于用户名密码的测试方法
添加人:GYBHBY 时间:2008-12-14 23:21:32 已有 92 人点击, 0 人评论
如何对web系统进行全面测试
添加人:GYBHBY 时间:2008-12-14 23:21:32 已有 87 人点击, 0 人评论
对网站安全性测试的个人见解
添加人:GYBHBY 时间:2008-12-14 23:21:32 已有 124 人点击, 0 人评论
假装不在
添加人:shuishixingyu 时间:2008-12-22 23:10:28 已有 503 人点击, 0 人评论
暂无
蓝天伟
添加人:shuishixingyu 时间:2008-12-23 16:53:04 已有 512 人点击, 0 人评论
暂无
rcpp
添加人:shuishixingyu 时间:2008-12-23 23:33:57 已有 650 人点击, 0 人评论
暂无
风过无息
添加人:shuishixingyu 时间:2008-12-24 11:56:03 已有 280 人点击, 0 人评论
暂无
小孩
添加人:shuishixingyu 时间:2008-12-24 11:59:10 已有 347 人点击, 0 人评论
暂无
罗耀秋质量管理专栏
添加人:bananarlily 时间:2008-12-24 12:09:38 已有 169 人点击, 0 人评论
暂无
风流§狂傲
添加人:shuishixingyu 时间:2008-12-24 13:19:50 已有 278 人点击, 0 人评论
暂无
xiaonan
添加人:shuishixingyu 时间:2008-12-25 13:25:24 已有 281 人点击, 0 人评论
暂无
陈能技
添加人:shuishixingyu 时间:2008-12-26 16:09:38 已有 497 人点击, 0 人评论
暂无
楷子狐
添加人:shuishixingyu 时间:2008-12-28 16:14:54 已有 144 人点击, 0 人评论
暂无
songfun
添加人:shuishixingyu 时间:2008-12-28 19:48:53 已有 301 人点击, 0 人评论
暂无
pcl
添加人:shuishixingyu 时间:2008-12-29 14:00:36 已有 301 人点击, 0 人评论
暂无
FLY000
添加人:shuishixingyu 时间:2008-12-29 14:35:17 已有 311 人点击, 0 人评论
暂无
kernzhang
添加人:shuishixingyu 时间:2008-12-31 10:57:56 已有 286 人点击, 0 人评论
暂无
flyfly310
添加人:shuishixingyu 时间:2009-01-09 10:34:48 已有 279 人点击, 0 人评论
暂无
蓝宇伊人
添加人:shuishixingyu 时间:2009-01-12 15:41:34 已有 403 人点击, 0 人评论
暂无
zibeike
添加人:shuishixingyu 时间:2009-01-17 15:47:33 已有 248 人点击, 0 人评论
暂无
有用的测试网站收集
添加人:zhjd4839 时间:2009-01-19 14:01:15 已有 270 人点击, 0 人评论
暂无
qiguojie
添加人:shuishixingyu 时间:2009-01-19 16:32:27 已有 384 人点击, 0 人评论
暂无
david208
添加人:shuishixingyu 时间:2009-01-21 21:32:13 已有 118 人点击, 0 人评论
暂无
huruihai
添加人:shuishixingyu 时间:2009-01-21 21:34:12 已有 112 人点击, 0 人评论
暂无
Unix/Linux中Cron的用法
添加人:zm51testing 时间:2014-09-23 12:43:32 已有 296 人点击, 0 人评论
Unix/Linux中Cron的用法
TestComplete测试计算器实例
添加人:ruben78 时间:2009-02-02 13:58:17 已有 267 人点击, 0 人评论
暂无
TestComplete 内主要六种回放
添加人:ruben78 时间:2009-02-02 14:01:46 已有 405 人点击, 0 人评论
TestComplete 内主要六种回放
TestComplete从Excel取值实例
添加人:ruben78 时间:2009-02-02 16:35:04 已有 294 人点击, 1 人评论
TestComplete从Excel取值实例
软件测试经典网站
添加人:孤星凌云时间:2009-08-08 10:49:59 已有 283 人点击, 0 人评论
测试工程师，成长需要加速度
添加人:孤星凌云时间:2009-08-08 10:53:18 已有 295 人点击, 0 人评论
Rational系列产品大概的介绍
添加人:孤星凌云时间:2009-08-14 09:18:45 已有 283 人点击, 0 人评论
Rational Robot 的自动化功能测试框架
添加人:孤星凌云时间:2009-08-14 11:54:20 已有 313 人点击, 0 人评论
测试工具培训的一些建议
添加人:孤星凌云时间:2009-08-14 11:58:43 已有 95 人点击, 0 人评论
LoadRunner函数中文翻译系列之一--Action_文章精选_51Testing...
添加人:wxxhxy 时间:2009-07-27 12:13:42 已有 254 人点击, 0 人评论
关于web_reg_save_param　Ord=ALL的解决_紫水晶的个人空间_51...
添加人:wxxhxy 时间:2009-07-27 12:13:42 已有 357 人点击, 0 人评论
技术讲座多媒体信息MMS
添加人:孤星凌云时间:2009-07-31 15:08:31 已有 347 人点击, 0 人评论
丰富的内容，直观的视觉效果，短信将从此突破文本的限制。彩色图片、声音、动画等多媒体的应用，将使短信进入一个多彩的世界。
svn版本库的建立 - 51Testing软件测试网-中国软件测试人的精神...
添加人:wxxhxy 时间:2009-07-27 12:13:42 已有 133 人点击, 0 人评论
Test
添加人:ainux 时间:2009-06-29 22:13:21 已有 229 人点击, 0 人评论
breezeforever的个人空间
添加人:kasad 时间:2009-07-09 08:29:45 已有 1 人点击, 0 人评论
性能测试方案
添加人:kasad 时间:2009-07-09 08:56:10 已有 1 人点击, 0 人评论
关于新员工导师制－－听微软培训心得
添加人:candy3990 时间:2010-02-11 15:40:35 已有 155 人点击, 0 人评论
qiguojie
添加人:shuishixingyu 时间:2009-06-15 20:02:49 已有 249 人点击, 0 人评论
逍遥客
添加人:shuishixingyu 时间:2009-06-17 19:54:03 已有 140 人点击, 0 人评论
利用交叉测试提升软件测试效率
添加人:dingzhiyi 时间:2010-03-01 11:46:30 已有 215 人点击, 0 人评论
本人发表于51testing<<51测试天地>>第十六期的文章利用交叉测试提升软件测试效率摘要：软件测试员长期重复测试同一功能或项目，会出现审丑疲劳，工作效率下降。而交叉测试是提高测试效率，更早更多发现软件缺陷的手段之一。本文就交叉测试意义、如何设计交叉测试、交叉测试使用时点以及交叉测试效果等展开论述，数据表明在正确阶段引入交叉测试可提升软件测试效率，提高软件发版质量。关键词：交叉测试软件测试效率本文详细地址:http://www.51testing.com/html/23/n-205923.html <<51测试天地>>第十六期下载地址: http://www.51testing.com/html/28/n-205128.html
linux
添加人:汗血宝马时间:2010-03-07 19:03:22 已有 283 人点击, 0 人评论
系统学习Linux的十一点建议
静澜
添加人:shuishixingyu 时间:2009-06-12 19:31:13 已有 273 人点击, 0 人评论
阅微草人
添加人:shuishixingyu 时间:2009-06-13 16:26:49 已有 204 人点击, 0 人评论
qicyt1812
添加人:shuishixingyu 时间:2009-06-15 18:49:28 已有 361 人点击, 0 人评论
davidwang_2004
添加人:shuishixingyu 时间:2009-05-27 22:12:06 已有 242 人点击, 0 人评论
wonew1228
添加人:shuishixingyu 时间:2009-05-27 23:09:15 已有 252 人点击, 0 人评论
一位微软软件测试开发工程师的成长体验
添加人:yangmei1985 时间:2009-05-27 16:21:48 已有 128 人点击, 0 人评论
(二)性能测试从零开始
添加人:wuchunying 时间:2009-05-25 17:12:28 已有 275 人点击, 0 人评论
charmer
添加人:shuishixingyu 时间:2009-05-26 00:19:17 已有 314 人点击, 0 人评论
ljonathan
添加人:shuishixingyu 时间:2009-05-26 00:22:27 已有 211 人点击, 0 人评论
fei.ge
添加人:shuishixingyu 时间:2009-05-26 11:18:00 已有 381 人点击, 0 人评论
LoadRunner监控Linux与Windows方法
添加人:lanytang 时间:2009-05-14 22:40:01 已有 92 人点击, 0 人评论
如何衡量测试效率，如何提高测试效率
添加人:jerrymy 时间:2009-05-15 13:33:38 已有 354 人点击, 0 人评论
测试工具下载地址
添加人:wangpl4092 时间:2009-05-20 08:57:59 已有 127 人点击, 0 人评论
测试工具下载地址
fangfangfei
添加人:shuishixingyu 时间:2009-05-08 10:01:25 已有 336 人点击, 0 人评论
LINUX系统下telnet服务器配置
添加人:yangmei1985 时间:2009-05-11 14:09:50 已有 132 人点击, 0 人评论
阿里巴巴一个测试架构师
添加人:傲然时间:2009-05-04 16:00:12 已有 507 人点击, 0 人评论
liangjz
添加人:eyre209 时间:2009-10-11 00:05:07 已有 2 人点击, 0 人评论
alibaba QA
转载的一个朋友的
添加人:hyfreefly 时间:2009-04-21 10:50:29 已有 2 人点击, 0 人评论
一个软件质量经理的工作日记
添加人:junlingliu 时间:2009-04-16 15:11:45 已有 264 人点击, 0 人评论
宣战（ 200x 年 x 月 Z 日，晴）　　连续两天，看着公司高层领导们闭门会议，就知道有重大决定。果不其然，第三天，技术总监召集所有的项目经理和开发人员，宣布公司向 CMM 三级冲击，本人有幸被任命为 SQA （软件质量保证）经理和 SEPG （软件工程过程组）成员（成员仅有 3 人，真有象当选为“**局常委”）。　　感觉真是不错，走出每天呆着的写字楼，看看大街上来来往往的人，爽啊！　　下班回家，郑重向“老婆”宣布，决定下馆子小辍一顿，一时间，踌躇满志，感觉飘然，好像公司的软件产品质量将获得重大提升，震撼业界。回想多年走过的历程，两年的程序员，三年的项目经理，终于熬出头了，上司发现了我这块“可造之材”，并委以重任。经过这么多年的风风雨雨磨练，终于有机会向上司展示才能，我当然要“涌泉相报”。　　赋职（ 200x 年 x 月 Y 日，多云）　　一早 6：10 就醒来，再也睡不着了，算了，还是起床吧。兴奋了一晚上，精神居然还挺好。　　8：00 就到公司了，时间太早，一个同事都没来，真想找个人侃侃自己的志向，毕竟“老婆”不是这一行的，有些东西还不能完全理解。上网溜达了一会儿， QQ 也没有好友在线，毕竟还没上班呢，只能看看 CMM 的最新动态和国内软件企业的新闻。没多久，同事们也陆续到了，上班时间到了。　　好不容易等到公司高层经理们开完了碰头会，我想，迟早我也会有机会挤进去参与的。 10：30 ，研发部经理向我们传达，经过领导们的一致同意，决定选择 XX 公司作为我们的 CMM 咨询顾问，鼓吹一通 XX 公司的业绩，（这不是有点象给他们做广告？）然后又宣布了参与培训的人员，都是一些公司的“栋梁之材”和“老马”。榜上无名的以极其羡慕的眼神看着这些幸运儿，榜上有名的“唯技术论”者则以不屑之表情，并不时发出 “项目太紧，没时间”的抗议。经理则非常明确，“高层决定，没商量，要么找老总协商”，试问有哪位有这等胆量。唉，朽木不可雕也，这些人也只能一辈子做技术了。　　完事后，经理又把我单独叫到他的办公室，问我打算如何组建 SQA ，说公司以后过 CMM 主要就靠我努力了，心头一阵激动。不过，经理接下来的话让我凉了半截，建议我 SQA 组下暂时只设一人，考虑一下小崔。不是吧？我的心有点凉了，公司里水平最差最笨的人就给我？这个人，不是仗着与老总有点不太近的远亲，估计早就给开了。我刚准备抗议，经理立马安慰，“所以才要你领导，有你在， CMM 应该不成问题，我们才放心。” 　　培训学习（ 200x 年 x 月 X 日，晴）　　经过将近一个月的培训，今天总算毕业了，感觉就像脱胎换骨，到底 CMM 是面向软件行业，就是比 ISO 更专业。因为是由鬼佬上课，好像自己的英文水平也提高了不少，而且还挺正规的，发了“毕业证”。真是获益良多啊！给我印象最深的还是那个北大的计算机硕士翻译，水平挺高，人也长得漂亮。　　课程结束后，顾问公司的咨询人员还特地给了我这个新上任的 SQA 一些建议：要熟读 CMM “兵书”，在项目组成员对执行情况有异议时，才能够据理力争，以理服人；在实际的软件项目开发过程中，要多与项目经理和项目组成员沟通，注意处理好人际关系问题，不要轻易上报，否则很容易引起抵触情绪。　　虽然很感激他的意见，不过我更相信我的能力。　　实战（ 200x 年 y 月 W 日，多云）　　新项目从立项开始已经三个礼拜过去了，还挺顺利的。　　首先，立项时给项目组成员作了一次培训。让全体的开发人员感受一下 “ 软件质量保证 ” 的功效。 SQA 的一个职能就是对项目组成员进行必要的软件的过程培训，理论和实际相结合，而不只是用于纸上谈兵。美中不足的是，培训会议室的优雅环境给一些人提供了一个比较理想的休息场所。　　在项目经理拟定计划时，提供必要的规范给项目经理参考，参与项目估算，组织召开项目计划评审会，邀请公司技术专家、用户以及项目组小组成员一起讨论项目计划的可行性。　　紧接着又是组织需求评审，并邀请用户参与，对其用户的意见进行跟踪检查是否纳入需求规格说明书，同时与用户签字确认。　　在此过程中，对项目的配置管理工作的作了一次比较细致的评审，发现了配置管理中存在的问题并提出了一些建议，使项目的配置管理工作更有效率。　　我在项目组中的工作如此繁忙，大家也逐渐接受了。同时，公司高层似乎也感到“ SQA 工作确实很有成效”。　　挫折（ 200x 年 z 月 V 日，多云）　　经过三个月的摸爬滚打，项目开发任务总算进入尾声，剩下的就是测试了。不过， SQA 工作却不尽人意，好像没什么突出的贡献，倒是经常和项目经理和部门经理争执不休，今天下午又和项目经理争了一把“开发已经接近完成，关键模块是不是需要评审一下”，没想到居然给“羞辱”了——你又不懂，尽是找一些鸡毛蒜皮小错误，不要老是制造麻烦。而且，居然还告到经理那“项目组有了 SQA ，可是设计和代码的质量还是不高”。　　想起 CMM 培训结束时，我们搞了一个模拟小项目热身，好像有模有样的，当时老总和技术经理还特别予以召见， SEPG 组和项目经理几个向“组织”表决心的情形还历历在目。然而，事情发展到今天这个样子，我这个 SQA 当然是难辞其咎的。　　经历了这么一段时间，多少对顾问公司的一番临别赠言有了更深的体会。　　SQA 的主要任务是项目过程监控，是间谍，所以 SQA 的地位是很微妙，也很尴尬的：在开展项目以前，高层非常希望有一个耳目来监控项目的开发情况，项目组也希望有一个角色协助使开发和管理更加规范有序。当一个项目启动后，又是另一种局面：不管你对项目开发管理有多大帮助，只要你打了项目组的“小报告”，受到项目组成员排挤是很正常的事。只要你存在，对项目组成员就是一种压力。对于组织而言，报告的不符合项、建议多了，高层会嫌你啰嗦，还会质问 SQA 为什么没有能力协调解决，那要 SQA 干吗？漏报了（这是在所难免的），又会说你不够尽职尽责，总之两头不讨好。当你看到一堆问题时只能干着急，却没有权力去纠正，所能做的只是：报告、建议、协调，虽然向管理层报告了，也不一定会马上处理（高层管理者自然有他的道理，如果是老板的小舅子那就更没辙了），你会是什么感想？上级又有什么想法？　　下班前，还特地找了部门经理诉苦，公司既然制订了制度，实际上就相当于公司的法律，如果有法不依，执法不严，违法不究，久而久之这套制度就只是一纸空文了，以后还会有用处么？　　吃饭时都感到郁闷，喝了一瓶啤酒，郁闷的是经理所说的“ SQA 工作更需要的是人际关系技能”。人际关系技能，那找个销售不就得了，还要我们这些技术人才干吗？无奈（ 200x 年 y 月 U 日，阴）　　每天准点上班，准点下班，默默地无休止地折腾那该死的软件。今天也不例外。　　从上礼拜二开始，经理就让我主要担任这个项目软件的测试，美其名曰“软件质量保证”，就要保证软件的质量，测试当然是保证质量的方式之一。我没有争辩，心知争辩也是徒然，而且高层不希望我成天找项目经理的茬，影响进度。资本运作当然不是我所能左右的！　　每天我机械地运行程序，检查结果，检查数据库，截图，填写缺陷报告，跟踪缺陷修复。虽然做得规范，无可挑剔，我成了孤独的斗士。　　实际上，测试是事后检验产品的质量，保证产品符合客户的需求；而 SQA 的职责是审计过程的质量，保证 CMM 中各个 KPA 过程被正确执行。因为 SQA 人员同样要检查测试的工作是否也遵循了开发过程要求，也是要被审计的，由 SQA 同时担任测试，那么谁来保证测试工作的过程质量呢？这些道理经理其实都明白，只不过项目经理完成的工作其价值是可见的，谁又能说出 SQA 产出了什么呢？　　中午休息时上了一个 CMM 的论坛蹓达，其中有一个帖子比喻得就极其形象：项目组就像是一家餐馆，项目经理是当班经理，他决定做什么，有多少人多少资源来做多大，有多大的风险；系统架构设计师就是主厨，他设计具体做法；程序员就是厨师，配置管理员、系统集成人员、数据库管理员等角色是厨房里面的服务人员。而 SQA 和测试工程师更像是第三方的检查人员， SQA 检查的是制作流程是否正确，材料是否使用正确，卫生是否做好了，他检查所有人的工作，包括项目经理。 SQA 虽然没有决定权，但是他有建议权，他向餐馆老板负责。测试工程师则更像是试菜的，看看炒出来的菜有没有合不合口味，有没有按照客人的意思多放点辣椒，如果口味不对，他们要告诉厨房就可以了。　　唉，算了，就当混口饭吃，知足吧。　　出局（ 200x 年 s 月 T 日，雨）　　又是一个阴雨天。　　上班了，像往常一样，上网看看新闻。　　项目已经做完了，不过心里极其不爽。我，虽然挂名 SQA 经理，实际成了一个打杂的，真正 SQA 工作早就抛在一边。比如协助完成测试、配置管理，研究实用的测试工具，改进一下开发环境和工作过程，甚至帮助项目经理汇总文档、总结实施经验、协助客户培训 …… 　　10：00 ，经理找我，觉得我更适合担任测试组长一职，但待遇要低一级，问我是否接受。这是公司对待“鸡肋”的一贯策略，我明白，上级对我的 SQA 工作予以否定。这一天终于来了，当时的我居然平静的谢绝了经理的好意，感谢公司在这段时间给我提供了这么多的锻炼机会。然后就说，那我收拾东西去了，经理还愣在那。　　没什么可埋怨的，可能是上级对 SQA 的期望太高。实际上，根据现代软件工程项目的调查研究，项目管理是项目失败的主要原因。问题是，这个事实说明了“要保证项目不失败，我们应当更加关注管理 ”，但是并没有推论“良好的管理一定可以保证项目的成功”。质量保证的最终目的是希望能保证质量，但质量是过程、人、技术三者缺一不可。除了过程外，还与人员、技术有关，而人员素质和技术水平的提高并不是依赖 SQA 就能保证的，所以 SQA 虽名为质量保证，实际上也就成了项目失败的直接责任人。　　难怪现在网上有一种说法“在中国做不了编程的人去做测试，做不了测试的人去做 SQA 。”实际上，这从就反映了 SQA 的作用并没有得到大家的认同，在大家的眼里， SQA 做的都是文档功夫。　　呜呼唉哉！　　感觉真是一种解脱。吃饭时喝了一瓶啤酒，深圳的秋老虎仍然厉害，体验着啤酒冰爽的感觉，幸福啊 ∶ ）　　下周又要开始投简历了，找工作是一个漫长的过程。希望下次我能够找个好婆家，理解这些。还是要思量一下是不是继续干 SQA 。　　下过雨后，凌晨两点的城市空气清新，望着远处霓虹闪烁，好美。　　后记：　　据了解，我的前任婆家在我离开公司的五个月之后通过了 CMM3 的正式评估。小崔，我的继任者，编程虽然极差，文档却是可以按要求完成的，不过，听说所有的项目文档都是由他执笔的。唉，怎么还是变得跟 ISO 一样了呢？只是名称改了一下。到了中国，任何的标准都有点变味了。
QTP 学习视频汇总
添加人:Jay-Yang84 时间:2009-04-12 23:27:34 已有 110 人点击, 0 人评论
如何做报表测试
添加人:souchy 时间:2009-04-13 08:59:26 已有 489 人点击, 0 人评论
留着看
进销存系统中的报表测试
添加人:souchy 时间:2009-04-13 09:17:19 已有 336 人点击, 0 人评论
留着看
报表测试的注意事项
添加人:souchy 时间:2009-04-13 09:20:20 已有 417 人点击, 0 人评论
报表测试的注意事项
报表测试小结
添加人:souchy 时间:2009-04-13 09:22:11 已有 230 人点击, 0 人评论
从圈复杂度谈谈代码质量
添加人:wangpl4092 时间:2009-03-24 13:36:11 已有 492 人点击, 0 人评论
从圈复杂度谈谈代码质量
六个建议防止SQL注入式攻击
添加人:wangpl4092 时间:2009-03-27 09:32:46 已有 295 人点击, 0 人评论
huior
添加人:shuishixingyu 时间:2009-03-28 17:08:58 已有 323 人点击, 0 人评论
紫梦
添加人:shuishixingyu 时间:2009-03-28 17:25:52 已有 353 人点击, 0 人评论
qaarchitech
添加人:shuishixingyu 时间:2009-03-29 15:51:33 已有 263 人点击, 0 人评论
wonew1228
添加人:shuishixingyu 时间:2009-03-19 17:43:23 已有 233 人点击, 0 人评论
kellyxie
添加人:shuishixingyu 时间:2009-03-21 16:33:20 已有 252 人点击, 0 人评论
Zee
添加人:shuishixingyu 时间:2009-03-21 16:42:37 已有 343 人点击, 0 人评论
Jon
添加人:shuishixingyu 时间:2009-03-21 16:43:15 已有 450 人点击, 0 人评论
Robel.Yi
添加人:shuishixingyu 时间:2009-03-13 10:10:10 已有 208 人点击, 0 人评论
gzj_06
添加人:shuishixingyu 时间:2009-03-12 16:26:41 已有 233 人点击, 0 人评论
英文简历精品
添加人:pp1984829 时间:2009-03-06 09:59:55 已有 549 人点击, 0 人评论
功能点测试用例
添加人:spring 时间:2009-02-28 09:38:55 已有 425 人点击, 0 人评论
功能点测试用例
asoqa
添加人:shuishixingyu 时间:2009-02-17 14:30:33 已有 293 人点击, 0 人评论
常用的功能测试方法
添加人:spring 时间:2009-02-28 09:18:02 已有 356 人点击, 0 人评论
常用的功能测试方法功能测试就是对产品的各功能进行验证，根据功能测试用例，逐项测试，检查产品是否达到用户要求的功能。常用的测试方法如下：　　 1. 页面链接检查：每一个链接是否都有对应的页面，并且页面之间切换正确。　　 2. 相关性检查：删除/增加一项会不会对其他项产生影响，如果产生影响，这些影响是否都正确。　　 3. 检查按钮的功能是否正确：如update, cancel, delete, save等功能是否正确。　　 4. 字符串长度检查: 输入超出需求所说明的字符串长度的内容, 看系统是否检查字符串长度,会不会出错. 　　 5. 字符类型检查: 在应该输入指定类型的内容的地方输入其他类型的内容(如在应该输入整型的地方输入其他字符类型),看系统是否检查字符类型,会否报错. 　　 6. 标点符号检查: 输入内容包括各种标点符号,特别是空格,各种引号,回车键.看系统处理是否正确. 　　 7. 中文字符处理: 在可以输入中文的系统输入中文,看会否出现乱码或出错. 　　 8. 检查带出信息的完整性: 在查看信息和update信息时,查看所填写的信息是不是全部带出.,带出信息和添加的是否一致　　 9. 信息重复: 在一些需要命名,且名字应该唯一的信息输入重复的名字或ID,看系统有没有处理,会否报错,重名包括是否区分大小写,以及在输入内容的前后输入空格,系统是否作出正确处理. 　　 10. 检查删除功能:在一些可以一次删除多个信息的地方,不选择任何信息,按”delete”,看系统如何处理,会否出错;然后选择一个和多个信息,进行删除,看是否正确处理. 　　 11. 检查添加和修改是否一致: 检查添加和修改信息的要求是否一致,例如添加要求必填的项,修改也应该必填;添加规定为整型的项,修改也必须为整型. 　　 12. 检查修改重名:修改时把不能重名的项改为已存在的内容,看会否处理,报错.同时,也要注意,会不会报和自己重名的错. 　　 13. 重复提交表单：一条已经成功提交的纪录，back后再提交，看看系统是否做了处理。　　 14. 检查多次使用back键的情况: 在有back的地方,back,回到原来页面,再back,重复多次,看会否出错. 　　 15. search检查: 在有search功能的地方输入系统存在和不存在的内容,看search结果是否正确.如果可以输入多个search条件,可以同时添加合理和不合理的条件,看系统处理是否正确. 　　 16. 输入信息位置: 注意在光标停留的地方输入信息时,光标和所输入的信息会否跳到别的地方. 　　 17. 上传下载文件检查：上传下载文件的功能是否实现，上传文件是否能打开。对上传文件的格式有何规定，系统是否有解释信息，并检查系统是否能够做到。　　 18. 必填项检查：应该填写的项没有填写时系统是否都做了处理，对必填项是否有提示信息，如在必填项前加* 　　 19. 快捷键检查：是否支持常用快捷键，如Ctrl+C Ctrl+V Backspace等，对一些不允许输入信息的字段，如选人，选日期对快捷方式是否也做了限制。　　 20. 回车键检查: 在输入结束后直接按回车键,看系统处理如何,会否报错.
利用Web Application Stress Tool(WAS)做性能测试
添加人:breezeforever 时间:2009-02-09 09:27:30 已有 457 人点击, 0 人评论
暂无
测试用例设计方法
添加人:yangmei1985 时间:2009-02-10 17:44:25 已有 164 人点击, 0 人评论
测试用例设计
zbk
添加人:chenjinlin 时间:2009-08-19 16:49:58 已有 438 人点击, 0 人评论
zbk 测试前辈
软件测试技术基础学习之系统测试
添加人:花怡蝶时间:2009-08-21 14:49:49 已有 291 人点击, 0 人评论
阶段产出概念目的对象常用类型：功能测试性能测试压力测试容量测试 ……
系统测试过程中应注意的问题
添加人:花怡蝶时间:2009-08-21 15:02:21 已有 110 人点击, 0 人评论
一些显而易见的、容易被开发者忽略的错误，这些错误一般很容易避免和修改，但会给用户造成使用上的困难： 1）易用性问题：用户无法使用或不方便使用 2）稳定性问题：影响用户正常工作 3）其他问题
面向对象的系统测试
添加人:花怡蝶时间:2009-08-21 15:12:17 已有 149 人点击, 0 人评论
系统测试应该尽量搭建与用户实际使用环境相同的测试平台，应该保证被测系统的完整性，对临时没有的系统设备部件，也应有相应的模拟手段。具体测试内容包括：功能测试强度测试（压力测试）性能测试安全测试恢复测试可用性测试安装/卸载测试
系统测试方法之功能测试
添加人:花怡蝶时间:2009-08-21 15:16:42 已有 96 人点击, 0 人评论
功能测试又称正确性测试，它检查软件的功能是否符合规格说明。等价类边界值测试分别就两种测试方法简单举例
系统测试设计的层次
添加人:花怡蝶时间:2009-08-21 15:20:12 已有 279 人点击, 0 人评论
作者从事系统测试工作中的一些体会 1、系统测试的定义 2、系统测试的对象 3、系统测试的设计（重点放在了这里，主要是层次划分）
Rational系统测试解决方案
添加人:花怡蝶时间:2009-08-21 16:14:12 已有 243 人点击, 0 人评论
OA办公自动化系统测试方案
添加人:花怡蝶时间:2009-08-21 16:14:33 已有 459 人点击, 0 人评论
从用例角度来分析系统测试（横向）
添加人:花怡蝶时间:2009-08-21 16:17:07 已有 85 人点击, 0 人评论
针对ST用例，使用横向思考方式进行计划、方案、设计、执行活动。横向思考方式得到的结果是测试项、测试子项、测试用例。
对目前系统测试的几个看法
添加人:花怡蝶时间:2009-08-21 16:29:59 已有 107 人点击, 0 人评论
1．测试计划：细化测试计划，使测试时间可以量化个人建议：建立测试用例模板。 2．测试工具：自动化 3．测试方法和测试类型 ……
基于V模型的单元测试，集成测试，系统测试
添加人:花怡蝶时间:2009-08-21 16:32:41 已有 100 人点击, 0 人评论
基于系统测试层面的个人经验总结：（一）用例设计、执行、管理、沟通：（二）性能测试过程：
orcale系统架构概念
添加人:anitalaw 时间:2009-08-24 21:16:41 已有 241 人点击, 0 人评论
基于V模型的单元测试，集成测试，系统测试
添加人:hujevons 时间:2009-08-26 15:30:57 已有 485 人点击, 0 人评论
银行自动化测试解决方案
添加人:283017152 时间:2010-10-03 21:11:05 已有 582 人点击, 0 人评论
其一，如何产生有效的、高覆盖率的测试用例，来满足测试需求，其二，手工测试的效率问题，手工测试执行需要投入很多测试人员，人力资源紧张，无暇他顾，业务人员繁忙的工作之余还需在每次测试时组织二十几人工时的测试，给业务人员也增加了不少的工作量，其三，如何使测试标准化，管理测试文档、测试数据，规范bug的处理流程。显然仅靠传统的质量方法、测试方法、临时的测试人员调配，已经无法完全解决总分行改造情况下的复杂系统的质量保障问题。　　在以上诸多背景下，我们提出了泽众软件的自动化测试解决方案，同时引进了高效协作的自动化测试工具和测试管理工具。以下简略介绍解决方案的构成，包括：
谈软件项目的测试管理
添加人:283017152 时间:2010-10-03 21:07:11 已有 89 人点击, 0 人评论
软件测试一方面是业务需求检查、验证的一种手段，也是检查软件功能是否按照系统需求进行设计，是否符合客户的需要；另一方面也是通过有限的测试数据案例检查发现程序中存在的Bug，是保证软件质量至关重要的一步。
一套比较完整的软件测试人员面试题
添加人:283017152 时间:2010-10-03 21:04:23 已有 163 人点击, 0 人评论
技术和人力资源方面
第四维空间testing
添加人:danae22 时间:2009-09-10 19:13:22 已有 91 人点击, 0 人评论
性能测试 SqlServer
界面规范
添加人:chen001 时间:2009-09-10 18:58:25 已有 69 人点击, 0 人评论
性能测试基础学习
添加人:wangpl4092 时间:2009-09-10 11:19:36 已有 517 人点击, 0 人评论
转载：一次有内存泄漏的性能测试
添加人:anitalaw 时间:2009-09-07 21:09:05 已有 271 人点击, 0 人评论
软件测试遇到的问题
添加人:千余同时间:2013-09-24 14:08:15 已有 105 人点击, 0 人评论
QTP错误处理机制介绍
添加人:葫芦时间:2013-10-11 19:44:50 已有 1 人点击, 0 人评论
QTP四种处理机制
cookies技术
添加人:likaihon 时间:2013-08-07 14:17:50 已有 114 人点击, 0 人评论
cookies介绍、作用
如何进行单元测试
添加人:wangpl4092 时间:2009-09-20 23:36:05 已有 305 人点击, 0 人评论
如何进行单元测试单元测试计划模板http://www.docin.com/p-19011817.html
如何进行单元测试
添加人:wangpl4092 时间:2009-09-21 17:59:29 已有 343 人点击, 1 人评论
如何进行单元测试
Web测试方法
添加人:beryl_lin 时间:2009-09-27 16:32:13 已有 302 人点击, 0 人评论
提高测试意识，关注测试方法，沉淀测试经验-共勉
添加人:jyh0738 时间:2009-09-28 18:55:20 已有 89 人点击, 0 人评论
测试的职业生涯有多长
添加人:jyh0738 时间:2009-09-28 18:56:59 已有 100 人点击, 0 人评论
性能测试的目的是检查软件的平均响应时间或者吞吐量是否符合指定的标准
添加人:elisly 时间:2009-09-29 11:08:58 已有 324 人点击, 0 人评论
转自bian的个人空间
测试架构师
添加人:eyre209 时间:2009-10-16 00:20:41 已有 88 人点击, 0 人评论
API 测试（一）
添加人:色彩时间:2009-10-16 00:29:51 已有 440 人点击, 0 人评论
浅谈如何通过测试知识管理来提高测试队伍能力
添加人:gigicat99 时间:2009-10-16 16:44:51 已有 359 人点击, 0 人评论
我的测试经历
添加人:gigicat99 时间:2009-10-16 16:46:52 已有 128 人点击, 0 人评论
twf
添加人:shuishixingyu 时间:2009-10-19 09:12:38 已有 275 人点击, 0 人评论
阳光扫去灰尘noapple
添加人:slsaisai 时间:2009-10-20 09:56:56 已有 114 人点击, 0 人评论
Bug分析总结
添加人:wangpl4092 时间:2009-10-22 14:20:00 已有 602 人点击, 0 人评论
Bug分析总结
LoadRunner性能测试的几种业务模型设计
添加人:wangpl4092 时间:2009-10-22 15:04:23 已有 312 人点击, 0 人评论
一个访问量达到百万级别的门户网站及奥运会订票系统等这中用户数较多的系统，进行性能测试是必须的。要不就和产品演示会上出现的笑话一样，风险投资商提出的问题是这个网站能支持多少用户同时上线，项目经理居然说没有进行这方面的测试。全场哗然。。。。　　对于性能测试的第一步是怎么去根据业务的实际模型分析出具体的测试场景及性能测试的指标。　　一、性能测试业务逻辑理解的一些基本概念　　1、负载测试和压力测试的区别：负载测试在于确定最终满足系统指标的前提下，系统所能承受的最大负载测试，压力测试的目标则在确定什么条件下系统性能处于失效状态。　　2、吞吐量（Throughput）：指单位时间内处理的客户段请求数量，直接体现软件系统的性能承载能力。
（一）性能测试从零开始——LoadRunner入门
添加人:283017152 时间:2009-11-24 12:52:24 已有 182 人点击, 0 人评论
linux目录架构
添加人:gigicat99 时间:2009-12-01 18:04:12 已有 72 人点击, 0 人评论
关于web测试
添加人:gigicat99 时间:2009-12-01 18:07:38 已有 103 人点击, 0 人评论
软件测试框架介绍
添加人:zbsczh 时间:2009-12-05 11:39:34 已有 122 人点击, 0 人评论
QTP识别对象和操作原理
添加人:yuxgu 时间:2009-12-09 15:16:36 已有 305 人点击, 0 人评论
内存泄露,内存溢出和死锁
添加人:yuxgu 时间:2009-12-09 15:18:42 已有 214 人点击, 0 人评论
<我要告诉测试新手的>(经典）
添加人:candy3990 时间:2010-02-23 13:03:55 已有 152 人点击, 0 人评论
QA值得一读
LR脚本的调试详细介绍
添加人:xtha21 时间:2009-12-25 09:38:45 已有 246 人点击, 0 人评论
(转)Loadrunner message函数详细分析
添加人:xtha21 时间:2009-12-25 09:41:28 已有 95 人点击, 0 人评论
zee的blog
添加人:over_skying 时间:2009-12-28 13:42:54 已有 207 人点击, 0 人评论
qtp
添加人:dimple 时间:2009-12-30 11:29:38 已有 1 人点击, 0 人评论
编写测试用例的一点体会
添加人:283017152 时间:2010-09-27 10:30:09 已有 246 人点击, 0 人评论
测试团队之如何找到合适的人员
添加人:283017152 时间:2010-09-27 11:06:22 已有 101 人点击, 0 人评论
业务流程
添加人:shanshan33 时间:2010-01-12 09:36:10 已有 373 人点击, 0 人评论
小小叶
添加人:baby.forward 时间:2010-01-13 11:34:38 已有 134 人点击, 0 人评论
小叶子
页面功能测试点小结
添加人:shanshan33 时间:2010-01-15 07:50:57 已有 378 人点击, 0 人评论
Web界面测试小结
添加人:shanshan33 时间:2010-01-15 07:51:51 已有 87 人点击, 0 人评论
内存泄露的有关知识
添加人:hanmingxiu 时间:2010-01-18 18:25:23 已有 91 人点击, 0 人评论
Statspack安装配置使用说明
添加人:yuxgu 时间:2010-01-20 16:30:57 已有 227 人点击, 0 人评论
使用Statspack的几个误区 (转)
添加人:yuxgu 时间:2010-01-20 16:49:00 已有 113 人点击, 0 人评论
虚拟机改变分辨率问题
添加人:283017152 时间:2010-01-21 15:17:32 已有 169 人点击, 0 人评论
用vmware装redhat ，初始分辨率是800×600的，看着窗口太小了，鼠标还需要切换，不舒服。于是找到此书签内容，按此操作，ok了。哇，世界和谐了！嘿嘿
测试职业生涯探讨
添加人:汗血宝马时间:2010-03-07 19:32:29 已有 107 人点击, 0 人评论
软件测试工程师职业生涯发展与规划
添加人:ftdtest 时间:2013-10-14 21:07:38 已有 135 人点击, 0 人评论
3.7.6 关联函数的高级使用
添加人:yuxgu 时间:2010-03-12 11:17:35 已有 97 人点击, 0 人评论
lr6.1_3.7.6 性能测试实战.pdf
添加人:yuxgu 时间:2010-03-12 11:42:55 已有 226 人点击, 0 人评论
事务(事务定义\集合点)
添加人:yuxgu 时间:2010-03-12 14:53:59 已有 174 人点击, 0 人评论
测试工具相关
添加人:bluepeng 时间:2010-03-15 16:23:26 已有 109 人点击, 0 人评论
简述QTP自动化测试框架
添加人:wangpl4092 时间:2010-03-17 09:15:08 已有 414 人点击, 0 人评论
qtp 测试框架
软件质量保证
添加人:wangpl4092 时间:2010-03-17 09:41:20 已有 314 人点击, 0 人评论
软件质量保证
如何对Web应用程序进行负载测试
添加人:wangpl4092 时间:2010-03-18 09:41:32 已有 233 人点击, 0 人评论
测试工作量统计方法
添加人:wangpl4092 时间:2010-03-19 09:37:13 已有 328 人点击, 0 人评论
http://www.51testing.com/html/09/n-20109.html
妙用测试管理工具，巧解测试混乱难题
添加人:283017152 时间:2010-03-22 10:04:55 已有 184 人点击, 0 人评论
软件测试的痼疾之一是人们并不清楚究竟该做什么，但却一直忙碌不停地测试，这种情况往往会使测试半途而废，或返工重来，造成很大的损失。一般来说，测试管理应要严格遵循项目活动的内在规律才有可能避免不必要的损失，少走弯路。但常常有许多因素导致项目测试管理出现失控，如何做好测试管理是目前大部分项目团队面临的主要问题之一。
Weblogic服务器性能调优(转载自中国源码网)
添加人:yuxgu 时间:2010-03-24 14:23:24 已有 114 人点击, 0 人评论
Weblogic服务器性能调优(转载自中国源码网)
BEA WebLogic平台下J2EE调优攻略
添加人:yuxgu 时间:2010-03-24 14:50:44 已有 261 人点击, 0 人评论
Web性能测试资料及工具
添加人:yuxgu 时间:2010-03-24 15:14:36 已有 122 人点击, 0 人评论
ruby系列教材
添加人:gaoyuanfeng 时间:2010-03-28 19:26:05 已有 5 人点击, 0 人评论
ruby系列教材
学习ruby
添加人:gaoyuanfeng 时间:2010-03-28 19:27:53 已有 2 人点击, 0 人评论
学习ruby
C/S架构的性能测试
添加人:283017152 时间:2010-03-30 10:00:10 已有 329 人点击, 0 人评论
如何对一个U盘存储设备进行测试
添加人:283017152 时间:2010-04-04 22:44:45 已有 117 人点击, 0 人评论
单元测试过程定义研究(图)
添加人:wangpl4092 时间:2010-04-07 09:39:19 已有 242 人点击, 0 人评论
单元测试过程定义研究
缺陷描述是这样提高的
添加人:jerrygu625 时间:2010-04-07 16:33:13 已有 255 人点击, 0 人评论
作为一名测试人员，提交缺陷是我们必须做的功课。不知各位是否考虑过，缺陷描述也是一门“艺术”，它影射了一个人的测试经验，测试深度。缺陷描述能否做好，直接影响了我们的测试效率，更确切的说是影响了开发人员修改缺陷的效率。一份高质量的缺陷描述让开发人员看的时候是一种享受，可以提高他们的工作效率；而一份让人费解的缺陷描述，不仅会让开发感到无从下手，还会降低对测试人员的信任度。因此说，一份好的缺陷描述，体现了一个测试人员的基本素质。　　傻哥博客中一篇文章《如何编写高质量的缺陷描述》让我对如何提高缺陷描述，有了点自己的一点想法，赶紧拿出来和大家分享一下。下面是傻哥文章中举的例子，一个关于资产财务月报折旧数据不对的缺陷，各个测试人员提交的内容。人员缺陷描述测试员1 资产财务月报折旧数据不对。测试员2 资产财务月报折旧数据跟资产台账明细的折旧数据之和不等，差287.53元。测试员3 资产财务月报折旧数据不对，zc_zjjl（资产折旧记录）和zc_yjjl（资产月结记录）折旧额不等。测试员4 只要出现资产重置，资产财务月报折旧数据跟资产台账明细的折旧数据之和就不等。测试员5 资产财务月报折旧数据不对，经查发现资产重置以后，资产月结的时候和zc_yjjl（资产月结记录）的重置金额未更新，折旧金额还是按照重置前的金额计算，造成资产月报数据不对。月结处理算法不对，请修改。　　从上面的例子可以看出，一个缺陷竟然出现5种说法，如果你是开发人员你想看哪位测试人员的缺陷，肯定是第5位了。不仅清晰的描述出了系统存在的缺陷，还直接帮开发人员找到的缺陷的根源。可能你还会想，不管在怎样，我已经把系统中存在的问题描述出来了，开发总会找到原因的，下面，我们再来看一下，开发对于这5个缺陷的回复。人员开发人员回复测试员1 我这里测了一下，折旧数据是对的，不是缺陷。测试员2 我这里测了一下，折旧数据是对的，不是缺陷。测试员3 我开发库里的这两张表数据是对，请再确认一下。测试员4 晕，我查了两个小时，我的财务报表是对，是张三的月结处理的算法是错的，请提交给张三。测试员5 张三回复：兄弟辛苦了，中午一起吃饭。　　可能有些调侃，不过我想这些情况在大家的工作中一定都遇到过。对于一些，描述不清或不准确的缺陷，往往都被开发拒绝掉。对于这些，我总结了几点自己的经验：　　一、追根溯源。缺陷也存在表面现象和真正原因，我们不仅仅应该看到它在系统中表现出的表面现象，还应该通过一步步的分析，找出缺陷产生的真正原因。有时可能通过多个测试用例才能发现，有时可能还要在多个表中查找才能查出。作为一名测试员，我们应该本着认真负责的态度，去发现任何细小缺陷的真正根源。　　二、面面俱到。详细的描述缺陷产生的真实情况。作为测试人员，我们对于业务要比开发人员熟悉太多。有时候，对于一个缺陷的产生过程，总以为简单描述就可以，殊不知开发人员对你”跳跃性“的步骤，往往是一头雾水。因此，我们在描述时，要尽可能的详细。　　三、简明扼要。可能听起来和第二点有些矛盾，可这确实是我们应该注意的地方。开发的周期都是相当紧凑的。我们应该用最简单的语言描述缺陷，可多用短句，保证逻辑上的清晰。
全面性能测试模型
添加人:jerrygu625 时间:2010-04-07 16:35:56 已有 113 人点击, 0 人评论
【原创】Windows系统内存计数器理解解析
添加人:ia_victory 时间:2010-04-08 16:30:47 已有 470 人点击, 0 人评论
常见的缺陷提交错误分析
添加人:jerrygu625 时间:2010-04-09 09:09:45 已有 144 人点击, 0 人评论
关于常见的缺陷提交错误分析。希望能给大家在日常工作中提个醒
B2C电子商务网站用户UE和用户UI测试重点
添加人:色彩时间:2010-04-13 12:38:38 已有 176 人点击, 0 人评论
ui测试
添加人:色彩时间:2010-04-14 01:33:54 已有 219 人点击, 0 人评论
UI测试和测试规则
添加人:色彩时间:2010-04-15 16:59:12 已有 235 人点击, 0 人评论
防电脑辐射小贴士
添加人:283017152 时间:2010-04-23 15:07:29 已有 149 人点击, 0 人评论
1、上午一杯绿茶 2、.下午一杯菊花茶； 3、疲劳了一杯枸杞茶； 4、晚间一杯决明茶；
shuishixingyu的个人空间
添加人:lxs647 时间:2010-05-20 17:57:52 已有 105 人点击, 0 人评论
子木清风博
添加人:lanytang 时间:2010-06-23 23:13:05 已有 104 人点击, 0 人评论
蓝宇伊人的博
添加人:lanytang 时间:2010-07-01 17:41:42 已有 78 人点击, 0 人评论
pcl的博
添加人:lanytang 时间:2010-07-01 18:34:27 已有 95 人点击, 0 人评论
执行性能测试起步-VS 2010自带功能强大的性能测试工具—Performance Wizard
添加人:fengzhulin 时间:2010-07-19 16:59:12 已有 1700 人点击, 0 人评论
入门
测试思维
添加人:wangpl4092 时间:2010-07-20 09:25:50 已有 417 人点击, 0 人评论
没有需求文档的时候怎样来设计测试用例
添加人:wangpl4092 时间:2010-07-20 09:32:42 已有 227 人点击, 0 人评论
安全测试总结
添加人:wangpl4092 时间:2010-07-21 09:29:14 已有 289 人点击, 0 人评论
安全测试总结
测试行业
添加人:john66889 时间:2010-07-22 17:13:06 已有 234 人点击, 0 人评论
测试行业的知识库
单元测试详述
添加人:wangpl4092 时间:2010-07-26 09:16:26 已有 282 人点击, 0 人评论
单元测试详述
软件测试的完整分类
添加人:wangpl4092 时间:2010-07-26 09:18:36 已有 74 人点击, 0 人评论
软件测试的完整分类
软件测试面试题分享
添加人:wangpl4092 时间:2010-07-26 09:24:09 已有 316 人点击, 0 人评论
测试人员需要养成的若干好习惯
添加人:wangpl4092 时间:2010-07-27 12:54:36 已有 255 人点击, 0 人评论
测试人员需要养成的若干好习惯
软件测试过程模型
添加人:wangpl4092 时间:2010-07-28 09:09:47 已有 310 人点击, 0 人评论
面试70经典问答
添加人:283017152 时间:2010-07-28 12:10:38 已有 253 人点击, 0 人评论
如何写测试策略
添加人:wangpl4092 时间:2010-08-05 09:25:50 已有 358 人点击, 0 人评论
情景测试的16种方法
添加人:wangpl4092 时间:2010-08-05 13:36:03 已有 315 人点击, 0 人评论
关于场景测试
添加人:wangpl4092 时间:2010-08-17 09:29:57 已有 293 人点击, 0 人评论
网站压力测试
添加人:wangpl4092 时间:2010-08-25 09:43:10 已有 294 人点击, 0 人评论
如何执行代码走查活动才会有效呢
添加人:wangpl4092 时间:2010-08-25 09:44:39 已有 110 人点击, 0 人评论
如何设计一个完整的测试用例
添加人:wangpl4092 时间:2010-08-25 09:45:27 已有 445 人点击, 0 人评论
如何编写有效测试用例
添加人:wangpl4092 时间:2010-08-27 09:46:42 已有 128 人点击, 0 人评论
如何编写有效测试用例
测试用例编写方法
添加人:wangpl4092 时间:2010-09-06 09:57:50 已有 2233 人点击, 11 人评论
根据需求规格说明书和设计说明书，详细理解用户的真正需求，并且对软件所实现的功能已经准确理解，然后着手制订测试用例. 测试用例要包括欲测试的功能、应输入的数据和预期的输出结果。测试数据应该选用少量、高效的测试数据进行尽可能完备的测试；基本目标是：设计一组发现某个错误或某类错误的测试数据，测试用例应覆盖方面：
如何编写有效的Bug报告
添加人:wangpl4092 时间:2010-09-06 10:00:56 已有 124 人点击, 0 人评论
LoadRunner性能测试
添加人:wangpl4092 时间:2010-09-06 10:01:45 已有 281 人点击, 0 人评论
测试流程总结
添加人:wangpl4092 时间:2010-09-06 10:05:09 已有 139 人点击, 0 人评论
test工具
添加人:Jean_ylq 时间:2010-09-09 12:10:15 已有 297 人点击, 0 人评论
很好的一个测试工具博客文章，推荐！！
一套比较完整的软件测试人员面试题（包括技术和人力资源方面）
添加人:大乘小乘时间:2010-09-15 12:19:03 已有 286 人点击, 0 人评论
架构师Jack
添加人:SmallAnt 时间:2010-09-17 10:02:24 已有 342 人点击, 0 人评论
我的目标
测试用例大集会
添加人:jerrygu625 时间:2010-09-21 17:19:39 已有 156 人点击, 0 人评论
相关测试工具下载
添加人:Jean_ylq 时间:2010-09-24 19:50:18 已有 137 人点击, 0 人评论
测试用例
添加人:Jean_ylq 时间:2010-09-24 20:14:53 已有 338 人点击, 0 人评论
OO测试用例
添加人:Jean_ylq 时间:2010-09-24 20:22:25 已有 341 人点击, 0 人评论
功能测试用例
添加人:Jean_ylq 时间:2010-09-24 20:23:15 已有 258 人点击, 0 人评论
关于评价测试用例的好坏
添加人:jerrygu625 时间:2010-10-13 15:02:23 已有 206 人点击, 0 人评论
Web功能测试的注意事项
添加人:jerrygu625 时间:2010-10-14 10:46:14 已有 217 人点击, 0 人评论
Web功能测试的注意事项
容量测试
添加人:jerrygu625 时间:2010-10-14 10:48:02 已有 279 人点击, 0 人评论
目的　　○通过大量的数据容量来发现问题。　　○系统性能、可用性常常会在系统查找或排序大量数据的时候被降低。　　测试步骤：　　●系统在最大数据量下运行。
Error code 10053，Software caused connection abort.--转
添加人:zishuijing 时间:2010-10-21 08:48:50 已有 497 人点击, 0 人评论
lr-socket连接
门牌号1
添加人:mcfnhm 时间:2010-10-21 16:24:51 已有 433 人点击, 0 人评论
自动化测试框架资料
添加人:fly_away 时间:2010-10-30 09:13:19 已有 346 人点击, 0 人评论
自动化测试框架学习中...
软件测试面试题、面试技巧全攻略
添加人:schorevy 时间:2010-11-01 16:04:59 已有 214 人点击, 0 人评论
MySQL数据库的基础架构
添加人:jerrygu625 时间:2010-11-02 14:40:28 已有 301 人点击, 0 人评论
慢慢体会到这么一个道理，基础决定你的深度，深度将会反应你未来的方向。学习技术我们应该按照这么一个思路，开始我们尽可能多的对它的原理做一定程度的了解，这样我们在实际应用中会有更多的体会，同时我们操作的目的性也会更加明确，查找问题的时候而不是单凭经验去做，更多的时候我们会根据对它结构原理的理解程度去判断分析从而得到最终的解决。　　不要在学一个新东西的时候，还是很“本能”地去试图，通过安装它来开始我们的第一步；磨刀不误砍柴功。言归正传，开始我们MySQL体验。
Linux 进程间通信(IPC)简介
添加人:suly 时间:2010-11-16 15:25:31 已有 57 人点击, 0 人评论
Linux IPC资源清理
添加人:suly 时间:2010-11-16 16:08:50 已有 97 人点击, 0 人评论
明明白白你的Linux服务器——网络篇
添加人:suly 时间:2010-11-16 16:18:18 已有 216 人点击, 0 人评论
明明白白你的Linux服务器——故障篇
添加人:suly 时间:2010-11-16 16:25:36 已有 290 人点击, 0 人评论
linux-利用sar进行性能监控-yc
添加人:suly 时间:2010-11-16 16:28:44 已有 324 人点击, 0 人评论
Linux下系统时间设置及date命令使用
添加人:suly 时间:2010-11-16 16:29:36 已有 114 人点击, 0 人评论
Linux僵尸进程产生及如何避免
添加人:suly 时间:2010-11-16 16:35:41 已有 263 人点击, 0 人评论
Linux configure参数解释
添加人:suly 时间:2010-11-16 16:37:15 已有 64 人点击, 0 人评论
Linux sudo不用密码的方法
添加人:suly 时间:2010-11-16 16:44:04 已有 173 人点击, 0 人评论
shell的初始化文件:/etc/profile和/etc/bashrc(bash.bashrc)
添加人:suly 时间:2010-11-16 17:02:26 已有 90 人点击, 0 人评论
Linux性能调优命令精华
添加人:suly 时间:2010-11-16 17:03:47 已有 168 人点击, 0 人评论
查看Apache并发请求数及其TCP连接状态
添加人:suly 时间:2010-11-16 17:05:25 已有 87 人点击, 0 人评论
如何在Linux系统下添加硬盘
添加人:suly 时间:2010-11-16 17:08:21 已有 242 人点击, 0 人评论
Linux下查看磁盘剩余空间和文件夹大小
添加人:suly 时间:2010-11-16 17:14:48 已有 65 人点击, 0 人评论
linux命令之awk
添加人:suly 时间:2010-11-16 17:19:19 已有 124 人点击, 0 人评论
linux命令之grep
添加人:suly 时间:2010-11-16 17:19:57 已有 269 人点击, 0 人评论
Linux命令之 top 使用技巧
添加人:suly 时间:2010-11-16 17:20:36 已有 76 人点击, 0 人评论
Linux中du命令参数的用法
添加人:suly 时间:2010-11-16 17:21:41 已有 104 人点击, 0 人评论
关于Linux性能监控的详细介绍
添加人:suly 时间:2010-11-16 17:23:50 已有 284 人点击, 0 人评论
linux top命令详解-zt
添加人:suly 时间:2010-11-16 17:24:31 已有 119 人点击, 0 人评论
挂接（mount）命令的使用方法
添加人:suly 时间:2010-11-16 17:25:47 已有 90 人点击, 0 人评论
Linux入侵检查命令详解
添加人:suly 时间:2010-11-16 17:26:50 已有 80 人点击, 0 人评论
Linux中的终端、控制台、tty、pty等概念
添加人:suly 时间:2010-11-16 17:30:18 已有 348 人点击, 0 人评论
Linux查看CPU信息、机器型号等硬件信息
添加人:suly 时间:2010-11-16 17:31:40 已有 77 人点击, 0 人评论
Linux僵尸进程详解
添加人:suly 时间:2010-11-16 17:35:10 已有 76 人点击, 0 人评论
详细解析Linux进程状态
添加人:suly 时间:2010-11-16 17:35:38 已有 228 人点击, 0 人评论
Linux环境变量总结
添加人:suly 时间:2010-11-16 17:37:32 已有 118 人点击, 0 人评论
Linux VI编辑命令使用剖析
添加人:suly 时间:2010-11-16 17:38:23 已有 72 人点击, 0 人评论
linux meminfo详解
添加人:suly 时间:2010-11-16 17:39:27 已有 205 人点击, 0 人评论
SQL Server数据库查询速度慢的原因有很多
添加人:shally09 时间:2010-11-16 17:39:40 已有 83 人点击, 0 人评论
云层
添加人:shally09 时间:2010-11-16 17:40:38 已有 157 人点击, 0 人评论
在Linux下编写一个集群自动化测试框架
添加人:suly 时间:2010-11-16 17:48:22 已有 294 人点击, 0 人评论
Linux应用程序安装与管理
添加人:suly 时间:2010-11-16 17:50:46 已有 207 人点击, 0 人评论
Linux 定时执行crontab
添加人:suly 时间:2010-11-16 17:52:24 已有 55 人点击, 0 人评论
如何判断是否需要对一个软件进行性能测试？
添加人:suly 时间:2010-11-22 11:15:54 已有 69 人点击, 0 人评论
找出软件开发过程中的BUG，你需要火眼金睛
添加人:suly 时间:2010-11-22 11:19:48 已有 61 人点击, 0 人评论
使用Selenium进行Web测试项目框架
添加人:suly 时间:2010-11-25 11:10:38 已有 151 人点击, 0 人评论
使用开源工具SeleniumRC进行功能测试
添加人:suly 时间:2010-11-25 11:14:49 已有 121 人点击, 0 人评论
QTP视屏
添加人:77xuewen 时间:2010-11-29 15:48:56 已有 164 人点击, 0 人评论
Mercury SiteScope 使用手册--转
添加人:zishuijing 时间:2010-12-02 09:25:24 已有 411 人点击, 0 人评论
快速诊断Linux服务器故障的三大法宝
添加人:suly 时间:2010-12-06 17:33:19 已有 131 人点击, 0 人评论
基于WATIR+RAILS+STAF的自动化测试框架
添加人:suly 时间:2010-12-07 14:47:25 已有 123 人点击, 0 人评论
21天突破QTP
添加人:MGM 时间:2011-04-14 18:49:55 已有 273 人点击, 0 人评论
qtp 对象库
添加人:色彩时间:2010-12-09 14:26:10 已有 336 人点击, 0 人评论
一种支持自动化测试的测试管理工具的实现
添加人:suly 时间:2010-12-13 21:36:17 已有 190 人点击, 0 人评论
面试技巧
添加人:jerrygu625 时间:2010-12-14 19:37:56 已有 139 人点击, 0 人评论
值得看的空间
添加人:xiaoyouer 时间:2010-12-22 09:56:52 已有 92 人点击, 0 人评论
Selenium UI Element学习笔记（一）
添加人:suly 时间:2010-12-22 16:45:16 已有 185 人点击, 0 人评论
软件测试需求分析之六大原则
添加人:283017152 时间:2010-12-27 14:16:21 已有 190 人点击, 0 人评论
永远不要显得比客户更聪明；尊重用户的现实选择；第三方也是我们的客户；客户和用户要区别对待；用最简单的文字工具记录需求；天下没有免费的午餐。
谈谈用例模型的那些事儿之用例说明
添加人:jerrygu625 时间:2010-12-27 18:09:10 已有 389 人点击, 0 人评论
前面我们讨论了如何绘制用例图，我们再看看如何编写用例说明：
JSP技术实现动态页面到静态页面的方案
添加人:jerrygu625 时间:2011-01-04 17:31:46 已有 200 人点击, 0 人评论
控件
添加人:hyn0120 时间:2011-01-06 10:44:03 已有 275 人点击, 0 人评论
非功能需求的6种类型
添加人:283017152 时间:2011-01-29 10:55:16 已有 257 人点击, 0 人评论
软件产品的需求可以分为功能性需求和非功能性需求，其中非功能性需求是常常被轻视，甚至被忽视的一个重要方面。其实，软件产品非功能性定义不仅决定产品的质量，还在很大程度上影响产品的功能需求定义。如果事先缺乏很好的非功能性需求定义，结果往往是使产品在非功能性需求面前捉襟见肘，甚至淹没功能性需求给用户带来的价值。
非功能需求的6种类型
添加人:283017152 时间:2011-01-29 10:55:18 已有 144 人点击, 0 人评论
软件产品的需求可以分为功能性需求和非功能性需求，其中非功能性需求是常常被轻视，甚至被忽视的一个重要方面。其实，软件产品非功能性定义不仅决定产品的质量，还在很大程度上影响产品的功能需求定义。如果事先缺乏很好的非功能性需求定义，结果往往是使产品在非功能性需求面前捉襟见肘，甚至淹没功能性需求给用户带来的价值。
非功能需求的6种类型
添加人:283017152 时间:2011-01-29 10:55:21 已有 341 人点击, 0 人评论
软件产品的需求可以分为功能性需求和非功能性需求，其中非功能性需求是常常被轻视，甚至被忽视的一个重要方面。其实，软件产品非功能性定义不仅决定产品的质量，还在很大程度上影响产品的功能需求定义。如果事先缺乏很好的非功能性需求定义，结果往往是使产品在非功能性需求面前捉襟见肘，甚至淹没功能性需求给用户带来的价值。
12个小技巧，让你高效使用Eclipse
添加人:qiaoj2007 时间:2011-02-04 11:34:29 已有 97 人点击, 0 人评论
Eclipse
论软件项目需求文档的撰写
添加人:jerrygu625 时间:2011-02-11 17:56:45 已有 280 人点击, 0 人评论
大多数工程师在撰写需求文档的时候，主要考虑的是如何把逻辑讲清楚。这实际上是从自身出发的一种思维模式。所谓的讲清楚，是自己认为讲清楚了，因为自己本身已经有一定的认识，所以只要写下来的是对的，那都属于讲清楚了的范畴。但自己认为得讲清楚未必等于读者的讲清楚了，读者由于原来对该事物没有认识，或者虽有认识但有些偏差，因而，当读者通过文档收获的东西不完全等于写者想表达的所有内容时，就不能定义为讲清楚了。笔者建议，在撰写需求文档时，要用目标读者的角度去衡量怎样把事情交代清楚，怎样能够让目标读者方便阅读、方便理解。做到心中有读者，就能使得软件项目需求文档的质量不断有提高。
性能测试指标的基本概念 (网络摘抄)
添加人:zishuijing 时间:2011-02-14 09:26:54 已有 109 人点击, 0 人评论
性能测试指标的基本概念 (网络摘抄)
写出高性能SQL语句的十三条法则
添加人:jerrygu625 时间:2011-02-14 17:12:52 已有 251 人点击, 0 人评论
1、首先要搞明白什么叫执行计划？　　执行计划是数据库根据SQL语句和相关表的统计信息作出的一个查询方案，这个方案是由查询优化器自动分析产生的，比如一条SQL语句如果用来从一个10万条记录的表中查1条记录，那查询优化器会选择“索引查找”方式，如果该表进行了归档，当前只剩下5000条记录了，那查询优化器就会改变方案，采用“全表扫描”方式。　　可见，执行计划并不是固定的，它是“个性化的”。产生一个正确的“执行计划”有两点很重要：　　（1）SQL语句是否清晰地告诉查询优化器它想干什么？　　（2）查询优化器得到的数据库统计信息是否是最新的、正确的？
测试知识网站
添加人:mynamezy 时间:2011-02-21 09:40:36 已有 61 人点击, 0 人评论
huior的测试烩
添加人:ashelywen 时间:2011-02-21 12:12:15 已有 101 人点击, 0 人评论
功能测试点
添加人:MGM 时间:2011-02-21 20:10:30 已有 76 人点击, 0 人评论
测试计划
添加人:MGM 时间:2011-02-22 18:50:05 已有 248 人点击, 0 人评论
DB2
添加人:MGM 时间:2011-02-22 18:51:15 已有 257 人点击, 0 人评论
c++易学
添加人:MGM 时间:2011-02-24 13:11:14 已有 298 人点击, 0 人评论
web测试用例设计大全
添加人:285448784 时间:2011-02-28 14:22:06 已有 300 人点击, 1 人评论
手机测试用例大全
添加人:285448784 时间:2011-02-28 14:33:12 已有 644 人点击, 3 人评论
测试报告样例
添加人:285448784 时间:2011-02-28 14:36:17 已有 340 人点击, 0 人评论
测试用例（很详细的文章）
添加人:285448784 时间:2011-02-28 14:42:29 已有 318 人点击, 0 人评论
测试计划
添加人:285448784 时间:2011-02-28 14:48:25 已有 305 人点击, 0 人评论
LoadRunner8.0下WebService测试总结
添加人:285448784 时间:2011-02-28 14:50:21 已有 283 人点击, 0 人评论
软件测试（原书中文第二版）PDF版
添加人:285448784 时间:2011-02-28 14:51:12 已有 419 人点击, 0 人评论
性能测试合集
添加人:285448784 时间:2011-02-28 14:52:14 已有 89 人点击, 0 人评论
如何撰写有效的测试报告？
添加人:285448784 时间:2011-02-28 14:56:49 已有 101 人点击, 0 人评论
白盒测试及其用例的设计
添加人:285448784 时间:2011-02-28 14:59:10 已有 197 人点击, 0 人评论
SoapUI接口测试指南
添加人:285448784 时间:2011-02-28 15:01:34 已有 811 人点击, 1 人评论
测试模板大结合
添加人:285448784 时间:2011-02-28 15:03:09 已有 350 人点击, 0 人评论
几年测试工作的总结
添加人:285448784 时间:2011-02-28 15:05:35 已有 60 人点击, 0 人评论
LoadRunner自带飞机订票系统订票功能性能测试代码
添加人:285448784 时间:2011-02-28 15:07:55 已有 2086 人点击, 0 人评论
淘宝测试团队《接口测试白皮书》
添加人:285448784 时间:2011-02-28 15:09:39 已有 677 人点击, 3 人评论
LoadRunner常见227个问题及回答集锦
添加人:285448784 时间:2011-02-28 15:15:34 已有 79 人点击, 0 人评论
LoadRunner8.0操作手册
添加人:285448784 时间:2011-02-28 15:17:00 已有 193 人点击, 0 人评论
项目过程管理
添加人:285448784 时间:2011-02-28 15:17:46 已有 80 人点击, 0 人评论
《软件性能测试过程详解与案例剖析》PDF电子版
添加人:285448784 时间:2011-02-28 15:18:49 已有 2611 人点击, 0 人评论
软件测试QTP实用例子集合
添加人:285448784 时间:2011-02-28 15:20:11 已有 101 人点击, 0 人评论
《软件测试自动化》电子书下载
添加人:285448784 时间:2011-02-28 15:23:48 已有 188 人点击, 0 人评论
QTP教程
添加人:285448784 时间:2011-02-28 15:24:58 已有 599 人点击, 0 人评论
LoadRunner权威指南（快速入门）
添加人:285448784 时间:2011-02-28 15:32:20 已有 226 人点击, 0 人评论
http://topic.csdn.net/u/20100712/16/936572a7-7c01-4488-8c5f-75f58b852431.html
《有效软件测试——提高测试水平的50条建议》
添加人:285448784 时间:2011-02-28 15:34:59 已有 457 人点击, 0 人评论
接口测试的应用与实践
添加人:suly 时间:2011-03-04 17:54:01 已有 407 人点击, 0 人评论
Watir － Ruby的开源Web自动化测试框架
添加人:suly 时间:2011-03-05 14:27:37 已有 99 人点击, 0 人评论
软件功能性测试的21种故障模型
添加人:yuanping 时间:2011-03-22 16:02:40 已有 244 人点击, 0 人评论
软件缺陷揭秘
添加人:MGM 时间:2011-03-23 10:14:26 已有 349 人点击, 0 人评论
33
添加人:xinqingmoli 时间:2011-03-23 10:18:48 已有 88 人点击, 0 人评论
WEB网站安全测试
添加人:MGM 时间:2011-03-23 10:43:28 已有 305 人点击, 0 人评论
阿里巴巴一个测试架构师
添加人:ldf326 时间:2011-03-23 22:40:59 已有 231 人点击, 0 人评论
探讨：测试人员究竟应该知道多少开发的东西？
添加人:wxy1208 时间:2011-03-24 01:10:55 已有 2 人点击, 0 人评论
测试用例编写规范
添加人:yujielove1212 时间:2011-03-24 16:24:04 已有 84 人点击, 0 人评论
登录增加删除查询修改的测试用例怎么写
huior的测试烩
添加人:mcfnhm 时间:2011-03-29 14:52:01 已有 78 人点击, 0 人评论
如何成为优秀的测试
添加人:dq_0413 时间:2011-04-02 10:12:17 已有 71 人点击, 0 人评论
素质
如何编写测试计划
添加人:yuxgu 时间:2013-09-05 11:52:25 已有 82 人点击, 0 人评论
QTP
添加人:MGM 时间:2011-04-14 18:53:28 已有 278 人点击, 0 人评论
测试用例设计方法1——等价类边界值
添加人:suly 时间:2011-04-19 11:44:45 已有 135 人点击, 0 人评论
软件项目测试流程
添加人:suly 时间:2011-04-19 11:48:50 已有 76 人点击, 0 人评论
浅谈测试用例分析和设计
添加人:suly 时间:2011-04-19 11:52:46 已有 95 人点击, 0 人评论
软件测试理论：目的、周期、流程
添加人:suly 时间:2011-04-19 11:53:21 已有 231 人点击, 0 人评论
如何组建学习型测试团队
添加人:suly 时间:2011-04-19 13:50:03 已有 234 人点击, 0 人评论
软件测试之系统测试
添加人:MissTan 时间:2011-04-19 16:59:18 已有 116 人点击, 0 人评论
包含：系统测试范围系统测试管理系统测试操作方法
lr ip欺骗
添加人:ttkk 时间:2011-04-19 17:57:25 已有 1381 人点击, 0 人评论
用过程中要注意的几个方面： 1、本地的IP不能设置为“自动获取”，必须指定一个静态IP；原因：如果设置为“自动获取”，在运行IP　Wizard时会弹出错误提示；　　　提示信息为：IP向导不支持启用DHCP的网卡。您的卡启用了DHCP或者配置了无效设置。请与系统管理员联系。 2、添加IP欺骗使用的IP后，会有提示框提示保存IP列表，确定，取消等按钮；建议保存IP列表后再确定完成；原因：保存IP列表后，下次使用时，可以直接导入IP列表；也可以直接修改保存的IP列表文件，再导入； 3、添加IP欺骗，和释放IP，都要重启机器后才会生效；原因：重启后，网络配置才会生效； 4、在controller中使用ip欺骗的注意事项； (1)勾选“场景”->“启用IP欺骗器”；备注：打开controller，在controller中，选择 Scenario-〉Enable IP Spoofer，此项设置允许使用IP欺骗 (2)勾选“工具”->“专家模式”；备注：Tools下的Expert mode， (3)“场景”->“选项”->“常规”->“多个IP地址模式”；备注：再点击Tools下的options在Genearl选项卡中设置已线程方式或进程方式进行性能测试也就是说使用本地虚拟IP测试时需要选中线程方式，使用负载生成器使用虚拟IP测试时需要选中进程方式这个选项一定要与当前场景的模式相匹配，也就是说使用本地虚拟IP测试时需要选中线程方式，使用负载生成器使用虚拟IP测试时需要选中进程方式 4）之后要释放ip 5、设置IP欺骗后，验证其是否生效；有两种方法查看： (1)可用如下代码段来查看： char *ip = lr_get_vuser_ip(); if (ip) lr_output_message("The IP address is %s", ip); else lr_output_message("IP spoofing disabled"); 注意：如果把上面这一段加入代码中间，第一句要修改下： char *ip;(这句放在函数起始部位，对变量ip进行声明) ip=lr_get_vuser_ip();(这个和后面的if-else语句一起放在要输出的地方) 另：这个在generator中是不生效的，所以在回放代码时看到的都是"IP spoofing disabled"，在contorller中设置了启用IP欺骗，日志中就可以看到； (2)controller的运行页，运行完场景后，在通过、失败的虚拟用户处，右键可显示VUser日志；
测试杂志下载
添加人:MissTan 时间:2011-04-20 10:40:44 已有 328 人点击, 0 人评论
囊括每期测试杂志
遇到不可重现软件缺陷的解决策略
添加人:MissTan 时间:2011-04-22 14:41:46 已有 0 人点击, 0 人评论
非必现bug出现的原因分析解决策略
浅谈数据库优化注意事项
添加人:MissTan 时间:2011-04-22 14:58:51 已有 0 人点击, 0 人评论
整个软件生命周期中，不同时期数据库优化方法不同
浅谈数据库优化注意事项
添加人:MissTan 时间:2011-04-22 15:15:09 已有 0 人点击, 0 人评论
整个软件生命周期中，不同时期数据库优化方法不同
浅谈数据库优化注意事项
添加人:MissTan 时间:2011-04-22 15:15:37 已有 0 人点击, 0 人评论
整个软件生命周期中，不同时期数据库优化方法不同
浅谈数据库优化注意事项
添加人:MissTan 时间:2011-04-22 15:19:13 已有 1 人点击, 0 人评论
整个软件生命周期中，不同时期数据库优化方法不同
浅谈测试意识
添加人:MissTan 时间:2011-04-25 11:58:37 已有 1 人点击, 0 人评论
培养测试意识的方法表意识-->潜意识
测试人01
添加人:xiangxuehai00 时间:2011-05-01 09:33:51 已有 76 人点击, 0 人评论
前辈的测试人生经历
添加人:ft8no1 时间:2011-05-06 15:01:55 已有 1 人点击, 0 人评论
记录了一个08年学员测试学习过程
成为测试主管第一步——制定测试流程
添加人:vivien.yu 时间:2011-05-09 13:50:52 已有 299 人点击, 0 人评论
敏捷测试了解
添加人:vivien.yu 时间:2011-05-10 12:03:58 已有 230 人点击, 0 人评论
让测试看起来更专业
添加人:vivien.yu 时间:2011-05-10 12:04:50 已有 299 人点击, 0 人评论
软件测试的核心价值
添加人:vivien.yu 时间:2011-05-10 15:49:08 已有 72 人点击, 0 人评论
注意行业
添加人:vivien.yu 时间:2011-05-12 11:56:26 已有 262 人点击, 0 人评论
lr视频
添加人:紫毓E 时间:2011-05-13 12:07:17 已有 387 人点击, 0 人评论
watin 接口
添加人:tocoya 时间:2011-05-20 13:30:28 已有 272 人点击, 0 人评论
接口描述
jackc的空间
添加人:laixp 时间:2011-05-23 17:38:50 已有 112 人点击, 0 人评论
QTP开发辅助框架PAFAWEB
添加人:linkxu 时间:2011-05-26 21:09:54 已有 215 人点击, 0 人评论
QTP开发相关知识！！
JMeter安装与简单操作
添加人:MissTan 时间:2011-05-27 15:47:46 已有 139 人点击, 0 人评论
C#
添加人:qwuter 时间:2011-05-31 18:51:14 已有 144 人点击, 0 人评论
测试
添加人:shally09 时间:2011-06-02 14:27:19 已有 115 人点击, 0 人评论
JIRA 4.x破解
添加人:nanjues 时间:2011-06-15 11:20:53 已有 112 人点击, 0 人评论
性能测试如何定位性能瓶颈
添加人:suly 时间:2011-06-30 16:32:27 已有 199 人点击, 0 人评论
(七)性能测试从零开始——LoadRunner入门与提升
添加人:suly 时间:2011-06-30 16:34:38 已有 310 人点击, 0 人评论
LoadRunner性能测试基础知识问答
添加人:suly 时间:2011-06-30 16:39:08 已有 77 人点击, 0 人评论
LoadRunner基础知识问答
添加人:suly 时间:2011-06-30 16:50:34 已有 71 人点击, 0 人评论
LoadRunner 检查点函数总结
添加人:suly 时间:2011-06-30 16:51:07 已有 274 人点击, 0 人评论
LoadRunner设置检查点的几种方法介绍
添加人:suly 时间:2011-06-30 16:52:34 已有 87 人点击, 0 人评论
测试工程师的分工
添加人:suly 时间:2011-07-02 10:19:27 已有 82 人点击, 0 人评论
实战 GUI 产品的自动化测试
添加人:suly 时间:2011-07-02 10:35:23 已有 72 人点击, 0 人评论
简述单元测试
添加人:suly 时间:2011-07-02 10:38:39 已有 93 人点击, 0 人评论
测试用例设计方法
添加人:suly 时间:2011-07-02 10:39:48 已有 61 人点击, 0 人评论
因果图法设计测试用例
添加人:suly 时间:2011-07-02 11:01:55 已有 148 人点击, 0 人评论
SQL问题
添加人:suly 时间:2011-07-02 11:07:13 已有 108 人点击, 0 人评论
Testlink介绍
添加人:suly 时间:2011-07-02 11:13:35 已有 117 人点击, 0 人评论
测试过程辅助设计与管理工具(转载)
添加人:suly 时间:2011-07-04 15:08:24 已有 71 人点击, 0 人评论
《软件测试基本功》系列教程
添加人:suly 时间:2011-07-04 15:13:44 已有 116 人点击, 0 人评论
系统性能调优经验分享--转载
添加人:suly 时间:2011-07-04 15:17:01 已有 114 人点击, 0 人评论
LoadRunner监控Linux与Windows方法
添加人:shm51testing 时间:2011-07-06 14:59:50 已有 67 人点击, 0 人评论
测试用例设计原则和模板
添加人:suly 时间:2011-07-12 10:40:06 已有 99 人点击, 0 人评论
软件测试行业理解
添加人:weiwenhp 时间:2015-11-16 18:07:28 已有 183 人点击, 0 人评论
移动游戏项目弱网测试策略
添加人:小赖清空时间:2016-03-11 10:45:54 已有 346 人点击, 0 人评论
利用无线路由器进行app(弱)网络测试
添加人:小赖清空时间:2016-03-11 11:14:15 已有 532 人点击, 0 人评论
性能测试综述--转
添加人:suly 时间:2011-07-13 11:42:06 已有 87 人点击, 0 人评论
导致QTP运行缓慢的常见原因
添加人:zhuruize 时间:2012-12-07 13:16:58 已有 296 人点击, 0 人评论
敏捷软件测试的七个关键成功要素-转
添加人:suly 时间:2011-07-15 15:36:51 已有 0 人点击, 0 人评论
51testing 敏捷测试专栏-转
添加人:suly 时间:2011-07-15 15:37:34 已有 0 人点击, 0 人评论
【转】软件测试方面的书籍
添加人:suly 时间:2011-07-18 15:23:24 已有 113 人点击, 0 人评论
Jmeter性能测试工具插件应用
添加人:tobecy 时间:2011-07-19 10:19:19 已有 340 人点击, 0 人评论
敏捷测试需注意的五种危险行为(转）
添加人:suly 时间:2011-07-19 18:39:52 已有 313 人点击, 0 人评论
ruby相关 -转互相学习
添加人:suly 时间:2011-07-21 17:06:01 已有 90 人点击, 0 人评论
11
添加人:wozai1945 时间:2011-07-22 11:47:48 已有 58 人点击, 0 人评论
http://www.51testing.com/?uid-88979-action-spacelist-type-blog
手机测试基础题
添加人:Anny_ 时间:2011-07-23 15:02:26 已有 118 人点击, 1 人评论
手机测试基础题
widget解释
添加人:Anny_ 时间:2011-07-23 15:34:39 已有 98 人点击, 0 人评论
测试碎碎念——测试只是一部分
添加人:hmtest 时间:2011-08-02 14:50:51 已有 90 人点击, 0 人评论
测试碎碎念
测试流程
添加人:zengyongheng22 时间:2011-08-07 17:43:08 已有 244 人点击, 0 人评论
测试流程
敏捷测试
添加人:tobecy 时间:2011-08-10 22:42:51 已有 366 人点击, 0 人评论
敏捷测试
软件测试工具LR场景设计、点击率和用户数的相互联系
添加人:PYbless2008 时间:2011-10-19 09:59:41 已有 297 人点击, 0 人评论
Web 测试实践 for .Net —WatiN
添加人:tobecy 时间:2011-08-11 23:18:46 已有 167 人点击, 0 人评论
经典软件测试工具学习http://www.51testing.com/?13997
添加人:zm51testing 时间:2013-09-10 11:53:32 已有 1129 人点击, 0 人评论
无意中看见http://www.51testing.com/?13997的博客空间，里面有很多值得学习的东东。故作收藏。
Web测试之基于实际测试的功能测试点总结
添加人:shmily_super 时间:2011-08-30 18:10:05 已有 100 人点击, 0 人评论
Web测试之基于实际测试的功能测试点总结
博文1
添加人:tianshi861 时间:2011-09-01 15:01:15 已有 238 人点击, 0 人评论
12款浏览器兼容性测试工具推荐
添加人:PYbless2008 时间:2011-09-09 14:50:23 已有 331 人点击, 0 人评论
12款浏览器兼容性测试工具推荐
Vim晋级
添加人:ShellyJor 时间:2011-09-14 09:39:09 已有 182 人点击, 0 人评论
Vim编辑器的使用
一位软件测试工程师六年的总结
添加人:ShellyJor 时间:2011-09-21 11:25:08 已有 76 人点击, 0 人评论
开发人员为什么拒绝修改我的缺陷
添加人:rainshiny 时间:2011-09-26 14:35:31 已有 268 人点击, 0 人评论
开发人员为什么拒绝修改我的缺陷
对于不可重现的缺陷如何处理？
添加人:rainshiny 时间:2011-09-26 14:36:29 已有 211 人点击, 0 人评论
对于不可重现的缺陷如何处理？
视频
添加人:xiongH 时间:2011-10-09 22:54:54 已有 383 人点击, 0 人评论
性能工具研究
添加人:xiongH 时间:2011-10-10 21:52:55 已有 103 人点击, 0 人评论
QTP视频教程系列汇总.
添加人:珂儿darling 时间:2011-10-26 14:52:02 已有 158879 人点击, 0 人评论
QTP - vbs脚本相关收集
添加人:珂儿darling 时间:2011-10-26 14:56:25 已有 120 人点击, 0 人评论
QTP中启动或请求程序的语句
添加人:珂儿darling 时间:2011-10-26 14:59:55 已有 98 人点击, 0 人评论
Qtp 连接数据库（My sql 方法）
添加人:珂儿darling 时间:2011-10-26 15:02:16 已有 87 人点击, 0 人评论
Qtp有用的网站记录
添加人:珂儿darling 时间:2011-10-26 15:04:45 已有 241 人点击, 0 人评论
软件测试：经验与教训
添加人:珂儿darling 时间:2011-10-26 15:33:49 已有 300 人点击, 0 人评论
QTP学习历程--从工具使用到框架思想
添加人:珂儿darling 时间:2011-10-28 15:59:10 已有 80 人点击, 0 人评论
基于Win32窗口的开源自动化测试工具White
添加人:龙飞时间:2011-11-04 16:36:12 已有 425 人点击, 0 人评论
基于Win32窗口的开源自动化测试工具White
典型测试用例设计题总结——小强作品
添加人:龙飞时间:2011-11-04 16:39:16 已有 411 人点击, 0 人评论
典型测试用例设计题
界面测试八条黄金规则
添加人:JUICY525 时间:2011-11-15 11:02:24 已有 93 人点击, 0 人评论
界面测试八条黄金规则
软件测试精要
添加人:会会时间:2011-11-17 23:24:13 已有 44 人点击, 0 人评论
软件质量管理
添加人:会会时间:2011-11-17 23:27:40 已有 44 人点击, 0 人评论
LoadRunner 脚本中做关联 (Correlation)
添加人:xinhai526 时间:2011-11-29 13:29:50 已有 96 人点击, 0 人评论
LoadRunner
添加人:houmin 时间:2011-12-05 10:43:21 已有 61 人点击, 0 人评论
loadrunner 基于socket
建高性能网站
添加人:JUICY525 时间:2011-12-07 18:32:44 已有 84 人点击, 0 人评论
抓包神器之--Charles配置和使用手册
添加人:huangjiajun622 时间:2022-11-07 10:49:41 已有 58 人点击, 0 人评论
缺陷管理有哪些流程
添加人:x9527 时间:2021-07-15 14:11:14 已有 106 人点击, 0 人评论
...
添加人:hjt0118 时间:2011-12-20 17:45:02 已有 91 人点击, 0 人评论
性能测试
添加人:vivi320 时间:2012-11-13 16:32:00 已有 79 人点击, 0 人评论
mysql学习
添加人:scott1012 时间:2012-02-15 16:22:42 已有 2 人点击, 0 人评论
精通qtp
添加人:Gaog1218 时间:2012-02-21 10:16:31 已有 258 人点击, 0 人评论
QTP自动化测试
添加人:oceanwell 时间:2012-02-24 16:55:20 已有 76 人点击, 0 人评论
QTP自动化测试的介绍，连载的，自学中，感觉挺好的，每天记得看点.
坚持天天学习
添加人:blue40131 时间:2012-02-25 17:12:37 已有 226 人点击, 0 人评论
控制流图｜圈复杂度｜基本复杂度
添加人:cold_wh01 时间:2012-09-29 15:52:56 已有 1196 人点击, 1 人评论
控制流图是McCabe复杂度计算的基础，McCabe度量标准是将软件的流程图转化为有向图，然后以图论的知识和计算方法来衡量软件的质量。McCabe复杂度包括圈复杂度（Cyclomatic complexity）、基本复杂度、模块涉及复杂度、设计复杂度和集成复杂度等。控制流程图分析是一个静态的分析过程，它提供静态的度量标准技术，一般主要运用在白盒测试的方法中。控制流图的一个重要性质是它的可规约性（reducibility）。如果程序中不存在从循环外跳到循环内的goto语句，那么这个程序对应的控制流图是可规约的（reducible），反之这个控制流图就是不可规约的（irreducible）。因此，模块符合结构化程序设计的准则是控制流图可规约的基础。程序环路复杂性也即为McCabe复杂性度量，它一般常用圈复杂度来描述，记录为V（G）。它用来衡量一个程序模块所包含的判定结构的复杂程度，数量上表现为独立路径的条数，即合理地预防错误所需测试的最少路径条数，圈复杂度大的程序，说明其代码可能质量低且难于测试和维护。经验表明，程序的可能存在的Bug数和圈复杂度有着很大的相关性。圈复杂度的计算方法很简单，计算公式为：V(G)=e-n+2。其中，e表示控制流图中边的数量，n表示控制流图中节点的数量。其实，圈复杂度的计算还有更直观的方法，因为圈复杂度所反映的是“判定条件”的数量，所以圈复杂度实际上就是等于判定节点的数量再加上1，也即控制流图的区域数，对应的计算公式为：V(G)=区域数=判定节点数+1。对于多分支的CASE结构或IF-ELSEIF-ELSE结构，统计判定节点的个数时需要特别注意一点，要求必须统计全部实际的判定节点数，也即每个ELSEIF语句，以及每个CASE语句，都应该算为一个判定节点。判定节点在模块的控制流图中很容易被识别出来，所以，针对程序的控制流图计算圈复杂度V(G)时，最好还是采用第一个公式，也即V(G)=e-n+2；而针对模块的控制流图时，可以直接统计判定节点数，这样更为简单。 Essential Complexity (ev(G))基本复杂度　　基本复杂度是用来衡量程序非结构化程度的，非结构成分降低了程序的质量，增加了代码的维护难度，使程序难于理解。因此，基本复杂度高意味着非结构化程度高，难以模块化和维护。实际上，消除了一个错误有时会引起其他的错误。计算方法　　将圈复杂度图中的结构化部分简化成一个点，计算简化以后流程图的圈复杂度就是基本复杂度。优点　　衡量非结构化程度；反映代码的质量；预测代码维护量，辅助模块划分；与所用的高级程序设计语言类型无关。应用　　当基本复杂度为1，这个模块是充分结构化的；当基本复杂度大于1而小于圈复杂度，这个模块是部分结构化的；当基本复杂度等于圈复杂度，这个模块是完全非结构化的。
专访性能架构师 - 贾江兵（转载）
添加人:tangxiaomei123 时间:2012-03-05 09:59:40 已有 75 人点击, 0 人评论
qtp
添加人:Gaog1218 时间:2012-03-05 16:34:18 已有 355 人点击, 0 人评论
软件攻击
添加人:Gaog1218 时间:2012-03-06 15:21:56 已有 250 人点击, 0 人评论
关于自动化软件测试用例设计的几点分析
添加人:JUICY525 时间:2012-03-14 11:23:44 已有 245 人点击, 0 人评论
<转>软件测试中不需要测试的八件事
添加人:JUICY525 时间:2012-03-14 11:54:10 已有 227 人点击, 0 人评论
QTP自动化测试实践
添加人:katherine_xiong 时间:2012-03-19 11:28:23 已有 336 人点击, 0 人评论
自动化软件测试前期准备工作
添加人:teresa3561 时间:2012-03-29 12:16:35 已有 47 人点击, 0 人评论
详细介绍了自动化测试的启动时间\适用项目\工具选择\测试计划设计\脚本开发规范\计划文档编排等信息,具有实用的指导意义.
小布--LR常见问题整理
添加人:大龙哥哥时间:2012-03-29 22:57:59 已有 111 人点击, 0 人评论
小布--LR常见问题解决
安全性测试总结
添加人:大龙哥哥时间:2012-03-29 23:00:45 已有 261 人点击, 0 人评论
网站性能测试31种（在线免费）
添加人:大龙哥哥时间:2012-03-29 23:05:36 已有 321 人点击, 0 人评论
web_submit_form与web_submit_data的区别
添加人:大龙哥哥时间:2012-03-29 23:12:41 已有 127 人点击, 0 人评论
网站性能测试指标
添加人:yangmei1985 时间:2012-06-06 16:16:24 已有 151 人点击, 0 人评论
测试丛书
添加人:jun_zxj4 时间:2012-06-21 16:10:39 已有 79 人点击, 0 人评论
软件测试转型之路
添加人:wangpl4092 时间:2012-05-15 11:24:25 已有 289 人点击, 0 人评论
TAG：测试报告
添加人:renee_ye 时间:2012-05-25 14:04:30 已有 107 人点击, 0 人评论
测试面试题（一）
添加人:JUICY525 时间:2012-04-20 09:50:33 已有 217 人点击, 0 人评论
测试面试题（二）
添加人:JUICY525 时间:2012-04-20 09:51:30 已有 64 人点击, 0 人评论
测试面试题（三）
添加人:JUICY525 时间:2012-04-20 09:52:10 已有 223 人点击, 0 人评论
(转)Web测试方法-1
添加人:JUICY525 时间:2012-04-23 18:14:39 已有 246 人点击, 0 人评论
(转)Web测试方法-2
添加人:JUICY525 时间:2012-04-23 18:15:24 已有 266 人点击, 0 人评论
(转)Web测试方法-3
添加人:JUICY525 时间:2012-04-23 18:16:05 已有 225 人点击, 0 人评论
(转)Web测试方法-4
添加人:JUICY525 时间:2012-04-23 18:17:02 已有 274 人点击, 0 人评论
(转)Web下的整体测试
添加人: