LoadRunner中的Web 函数列表
Posted Jason Kwok
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了LoadRunner中的Web 函数列表相关的知识，希望对你有一定的参考价值。
LoadRunner中的Web 函数列表
web test LoadRunner fuction_list
D:\Program Files (x86)\Mercury Interactive\Mercury LoadRunner\bin>ls -l *.chm
-rw-rw-rw- 1 user group 25893 May 20 2004 FuncRef.chm
-rw-rw-rw- 1 user group 29443 May 20 2004 RPM_Configuration.chm
-rw-rw-rw- 1 user group 4164984 May 20 2004 Vugen.chm
-rw-rw-rw- 1 user group 2857600 May 20 2004 Wlrun.chm
-rw-rw-rw- 1 user group 2892037 May 20 2004 analysis.chm
-rw-rw-rw- 1 user group 504896 May 20 2004 automation.chm
-rw-rw-rw- 1 user group 177727 May 20 2004 baan_FuncRef.chm
-rw-rw-rw- 1 user group 151107 May 20 2004 citrix_FuncRef.chm
-rw-rw-rw- 1 user group 242481 May 20 2004 clanguage_FuncRef.chm
-rw-rw-rw- 1 user group 254214 May 20 2004 com_FuncRef.chm
-rw-rw-rw- 1 user group 3131206 May 20 2004 console.chm
-rw-rw-rw- 1 user group 368528 May 20 2004 database_FuncRef.chm
-rw-rw-rw- 1 user group 56387 May 20 2004 dns_FuncRef.chm
-rw-rw-rw- 1 user group 98573 May 20 2004 ftp_FuncRef.chm
-rw-rw-rw- 1 user group 105437 May 20 2004 imap_FuncRef.chm
-rw-rw-rw- 1 user group 32049 May 20 2004 launcher.chm
-rw-rw-rw- 1 user group 60751 May 20 2004 ldap_FuncRef.chm
-rw-rw-rw- 1 user group 48093 May 20 2004 mapi_FuncRef.chm
-rw-rw-rw- 1 user group 54822 May 20 2004 mms_FuncRef.chm
-rw-rw-rw- 1 user group 45442 May 20 2004 monitors.chm
-rw-rw-rw- 1 user group 1530155 May 20 2004 online.chm
-rw-rw-rw- 1 user group 235781 May 20 2004 oracle_nca_FuncRef.chm
-rw-rw-rw- 1 user group 77013 May 20 2004 pop3_FuncRef.chm
-rw-rw-rw- 1 user group 83761 May 20 2004 realplay_FuncRef.chm
-rw-rw-rw- 1 user group 107473 May 20 2004 rte_FuncRef.chm
-rw-rw-rw- 1 user group 336651 May 20 2004 sapgui_FuncRef.chm
-rw-rw-rw- 1 user group 80887 May 20 2004 smtp_FuncRef.chm
-rw-rw-rw- 1 user group 183065 May 20 2004 tuxedo_FuncRef.chm
-rw-rw-rw- 1 user group 432185 May 20 2004 vuser_utils_FuncRef.chm
-rw-rw-rw- 1 user group 155625 May 20 2004 wap_FuncRef.chm
-rw-rw-rw- 1 user group 379109 May 20 2004 web_FuncRef.chm
-rw-rw-rw- 1 user group 88243 May 20 2004 webgui_FuncRef.chm
-rw-rw-rw- 1 user group 174828 May 20 2004 winsocket_FuncRef.chm
-rw-rw-rw- 1 user group 110893 May 20 2004 xml_FuncRef.chm
LoadRunner中的Web 函数列表
http://tbaike.com/index.php?doc-view-116.html
D:\Program Files (x86)\Mercury Interactive\Mercury LoadRunner\bin\Vugen.chm
LoadRunner Function Reference > Web Vuser Functions > Web Vuser Functions: Java Language (web.)
HTTP-related functions have a web prefix.
See:
Action Functions
Authentication Functions
Check Functions
Connection Definition Functions
Concurrent Group Functions
Cookie Functions
Correlation Functions
Header Functions
Proxy Server Functions
Replay Functions
Miscellaneous Functions
Alphabetical Listing of Web Functions
- • 操作函数
- • 身份验证函数
- • 缓存函数
- • 检查函数
- • 连接定义函数
- • 并发组函数
- • Cookie 函数
- • 关联函数
- • 筛选器函数
- • 标头函数
- • 代理服务器函数
- • 回放函数
- • 其他函数
- • 控制类型函数
操作函数
在录制 Web Vuser 脚本时，VuGen 将生成下列操作函数，并且将它们插入到脚本中：
web_custom_request 允许您使用 HTTP 支持的任何方法来创建自定义 HTTP 请求
web_image 在定义的图像上模拟鼠标单击
web_link 在定义的文本链接上模拟鼠标单击
web_submit_data 执行“无条件”或“无上下文”的表单提交
web_submit_form 模拟表单的提交
web_url 加载由“URL”属性指定的 URL
身份验证函数
web_set_certificate 使 Vuser 使用在 Internet Explorer 注册表中列出的特定证书
web_set_certificate_ex 指定证书和密钥文件的位置和格式信息
web_set_user 指定 Web 服务器的登录字符串和密码，用于 Web 服务器上已验证用户身份的区域
缓存函数
web_cache_cleanup 清除缓存模拟程序的内容
web_dump_cache 将资源转储到浏览器缓存中
web_load_cache 加载缓存的内容
检查函数
web_find 在 html 页内搜索指定的文本字符串
web_global_verification 在所有后面的 HTTP 请求中搜索文本字符串
web_image_check 验证指定的图像是否存在于 HTML 页内
web_reg_find 在后面的 HTTP 请求中注册对 HTML 源或原始缓冲区中文本字符串的搜索
连接定义函数
web_disable_keep_alive 禁用 Keep-Alive HTTP 连接
web_enable_keep_alive 启用 Keep-Alive HTTP 连接
web_set_connections_limit 设置 Vuser 在运行脚本时可以同时打开连接的最大数目
并发组函数
web_concurrent_end 标记并发组的结束
web_concurrent_start 标记并发组的开始
cookie
web_add_cookie 添加新的 Cookie 或修改现有的 Cookie
web_cleanup_cookies 删除当前由 Vuser 存储的所有 Cookie
web_remove_cookie 删除指定的 Cookie
关联函数
web_create_html_param 将 HTML 页上的动态信息保存到参数中（LR 6.5 及更低版本）
web_create_html_param_ex 基于包含在 HTML 页内的动态信息创建参数（使用嵌入边界）（LR 6.5 及更低版本）
web_reg_save_param 基于包含在 HTML 页内的动态信息创建参数（不使用嵌入边界）
web_set_max_html_param_len 设置已检索的动态 HTML 信息的最大长度
筛选器函数
web_add_filter 设置在下载时包括或排除 URL 的条件
web_add_auto_filter 设置在下载时包括或排除 URL 的条件
web_remove_auto_filter 禁用对下载内容的筛选
标头函数
web_add_auto_header 向所有后面的 HTTP 请求中添加自定义标头
web_add_header 向下一个 HTTP 请求中添加自定义标头
web_cleanup_auto_headers 停止向后面的 HTTP 请求中添加自定义标头
web_remove_auto_header 停止向后面的 HTTP 请求中添加特定的标头
web_revert_auto_header 停止向后面的 HTTP 请求中添加特定的标头，但是生成隐性标头
web_save_header 将请求和响应标头保存到变量中
代理服务器函数
web_set_proxy 指定将所有后面的 HTTP 请求定向到指定的代理服务器
web_set_proxy_bypass 指定 Vuser 直接访问（即不通过指定的代理服务器访问）的服务器列表
web_set_proxy_bypass_local 指定 Vuser 对于本地 (Intranet) 地址是否应该避开代理服务器 web_set_secure_proxy 指定将所有后面的 HTTP 请求定向到服务器
回放函数
web_set_max_retries 设置操作步骤的最大重试次数
web_set_timeout 指定 Vuser 等待执行指定任务的最长时间
其他函数
web_convert_param 将 HTML 参数转换成 URL 或纯文本
web_get_int_property 返回有关上一个 HTTP 请求的特定信息
web_report_data_point 指定数据点并将其添加到测试结果中
web_set_option 在非 HTML 资源的编码、重定向和下载区域中设置 Web 选项
web_set_sockets_option 设置套接字的选项
控制类型函数
除了 Web Vuser 函数以外，下列控制函数也可能会出现在 Vuser 脚本中：
lr_start_transaction 标记事务的开始以用于性能分析或优化
lr_end_transaction 标记事务的结束以用于性能分析或优化
lr_rendezvous 在 Vuser 脚本中设置集合点
lr_think_time 暂停 Vuser 脚本中命令之间的执行
LoadRunner 信息函数列表
http://tbaike.com/index.php?doc-view-379.html
系统信息函数
|
lr_get_host_name () |
返回主机名 |
|
lr_get_master_host_name () |
返回运行controller主机的名称 |
|
lr_get_vuser_ip () |
返回虚拟用户的IP地址 |
|
lr_user_data_point () |
录制用户自定义的数据样例 |
信息函数
|
lr_debug_message () |
发送调试信息到日志文件 |
|
lr_error_message () |
发送错误信息到LR输入窗口或日志文件里 |
|
lr_get_debug_message () |
返回当前调试的信息 |
|
lr_log_message () |
发送信息到用户日志文件 |
|
lr_message () |
|
|
lr_output_message () |
发送信息到输出窗口或日志文件 |
|
lr_set_debug_message () |
|
|
lr_vuser_status_message () |
发送虚拟用户的状态到LR的Controller |
运行时函数
|
lr_abort （） |
终止执行的脚本 |
|
lr_continue_on_error （） |
当发生错误后运行的事件 |
|
lr_disable_ip_spoofing （） |
禁止IP欺骗 |
|
lr_enable_ip_spoofing （） |
允许IP欺骗 |
|
lr_exit （） |
从script action iteration中退出 |
|
lr_load_dll （） |
调用扩展的外部DLL |
|
lr_param_increment （） |
|
|
lr_peek_events （） |
|
|
|
|
|
lr_rendezvous_ex （） |
设置集合点 |
|
设置思考时间 |
LoadRunner 函数大全之中文解释
LoadRunner 函数大全之中文解释(1)
http://blog.sina.com.cn/s/blog_7b9284810100slaj.html
LoadRunner 函数大全之中文解释(2)
http://blog.sina.com.cn/s/blog_7b9284810100slap.html
LoadRunner 函数大全之中文解释(3)
http://blog.sina.com.cn/s/blog_7b9284810100slar.html
LoadRunner 函数大全之中文解释(4)
http://blog.sina.com.cn/s/blog_7b9284810100slax.html
LoadRunner 函数大全之中文解释 // button_press 函数激活指定的推按钮。
int button_press ( LPCSTR button );
// button_set 函数将按钮状态设置为 ON 或 OFF。 int button_set ( LPCSTR button, int state );
// close_session 函数关闭所有打开的窗口并结束 // 当前的 Baan 会话。在 Baan 模板中创建的此函数 // 出现在脚本的 vuser_end 部分中。 int close_session();
// edit_get_text 函数返回在指定 edit 对象中 // 找到的所有文本。若要从特定块中读取文本, // 请使用 edit_get_block。 int edit_get_text ( LPCSTR edit, char *out_string );
// edit_set 函数使用指定的字符串设置 edit 对象的 // 内容。该字符串将替换任何现有字符串。 int edit_set ( LPCSTR edit, LPCSTR text );
// edit_set_insert_pos 函数将光标放置 // 在 edit 对象内的指定位置。 int edit_set_insert_pos (LPCSTR edit, int row, int column );
// edit_set_selection 函数突出显示指定文本。 int edit_set_selection ( LPCSTR edit, int start_row, int start_column, int end_row, int end_column );
// edit_type 函数将文本字符串输入到 edit // 对象中。该文本字符串不会替换现有字符串; // 它替换的是位于当前光标位置的指定文本。 int edit_type ( LPCSTR edit, LPCSTR text );
// init_session 函数通过指定登录数据和配置 // 信息打开 Baan 连接。此函数向 Baan 服务器 // 呈现包含在 Baan Configuration 部分中 // 的信息。 int init_session ( char * host, char * user, char *password, char *BSE, * settings );
// list_activate_item 函数双击列表中的项目。
char *Bshell_name, char
1
// 项目可由其逻辑名称指定。 int list_activate_item ( LPCSTR list, LPCSTR item );
// list_collapse_item 函数隐藏展开的 TreeView // 列表中的子项,例如文件夹中的各个文件。 int list_collapse_item (LPCSTR list, LPCSTR item );
// list_expand_item 函数显示展开的 // TreeView 列表中所隐藏的子项,例如 // 文件夹中的各个文件。 int list_expand_item (LPCSTR list, LPCSTR item );
// list_get_selected 函数返回列表中的选定 // 项目。它既查找标准列表,也查找多选项列表。 int list_get_selected (LPCSTR list, LPCSTR out_item, LPCSTR out_num );
// list_select_item 函数从列表中选择项目 // (在项目上执行一次鼠标单击)。项目可由 // 其名称或数字索引指定。索引被指定为一个 // 字符串,并前置有字符 #。列表中的第一个 // 项目编号为 0。例如,列表中的第三个项目 // 将表示为 "#2"。 int list_select_item ( LPCSTR list, LPCSTR item );
// menu_select_item 函数根据菜单 // 的逻辑名称和项目名称从菜单中选择 // 项目。注意,菜单和项目表示为单个 // 字符串,并使用分号分隔。 int menu_select_item ( LPCSTR menu_item );
// obj_get_info 函数检索指定属性的值, // 并将其存储在 out_value 中。 int obj_get_info ( LPCSTR object, LPCSTR property, char *out_value );
// obj_get_text 函数从指定的对象 // 或对象区域中读取文本。 int obj_get_text (LPCSTR object, LPCSTR out_text );
// obj_mouse_click 函数在对象内的 // 指定坐标处单击鼠标。 int obj_mouse_click ( LPCSTR object, int x, int y, [mouse_button] );
// obj_mouse_dbl_click 函数在对象内的 // 指定坐标处双击鼠标。
2
int obj_mouse_dbl_click ( LPCSTR object, int x, int y, [mouse_button] );
// obj_mouse_drag 函数在 GUI // 对象中执行鼠标拖动操作。指定的 // 坐标是相对于 GUI 对象(而非 // 屏幕)的左上角。 int obj_mouse_drag (LPCSTR object, int start_x, int start_y, int end_x, int end_y, [ ButtonT mouse_button] );
// obj_type 函数指定将 keyboard_input // 发送到的目标对象。 int obj_type ( LPCSTR object, unsigned char keyboard_input, [unsigned char modifier ] );
// obj_wait_info 函数等待对象 // 属性达到指定值,然后继续 // 测试运行。如果未达到指定 // 值,则函数将一直等到时间 // 到期,然后再继续测试。 int obj_wait_info (LPCSTR object, LPCSTR property, LPCSTR value, UINT time );
// scroll_drag_from_min 函数将滚动屏 // 移动到与最小位置相距指定距离的位置。 int scroll_drag_from_min ( LPCSTR object, [int orientation], int position );
// scroll_line 函数滚动指定行数。 // 此函数可用于滚动栏和滑块对象。 int scroll_line ( LPCSTR scroll, [ScrollT orientation], int lines );
// scroll_page 函数将滚动屏移动指定页数。 int scroll_page ( LPCSTR scroll, [ScrollT orientation], int pages );
// set_default_timeout 函数设置回放 // 期间 Baan Vuser 函数的超时期间段。 // 例如,当脚本执行 set_window 函数 // 时,如果窗口在指定超时时间段内没有 // 出现,则会生成错误。 void set_default_timeout ( long time );
// set_exception 函数指定在发生异常时 // 应执行的操作。应指定要调用以处理异常 // 窗口的函数。 void set_exception ( LPCSTR title, long function );
// set_think_time 函数指定脚本执行
3
// 期间要使用的思考时间范围。运行脚本 // 时,LoadRunner 使用指定范围内的 // 随机思考时间,并在每个操作完成后 // 暂停该思考时间长度。
void set_think_time ( USHORT start_range, USHORT end_range );
// set_window 函数将输入定向到 // 当前应用程序窗口并在 GUI 图中 // 设置对象标识范围。 int set_window ( LPCSTR window [, int
// start_session 函数在 Baan // 服务器上开始指定的会话。 int start_session ( LPCSTR session );
timeout ] );
// static_get_text 函数返回在指定 // 静态 text 对象中找到的所有文本。 int static_get_text ( LPCSTR static_obj, LPCSTR out_string );
// tab_select_item 函数选择一个选项卡项目。 int tab_select_item ( LPCSTR tab, LPCSTR item );
// tbl_activate_cell 函数在指定表单元格中 // 按 Enter 键。如果指定了列名,LoadRunner // 将直接从数据库中获取该名称。 int tbl_activate_cell (LPCSTR table, LPCSTR row, LPCSTR column );
// tbl_get_cell_data 函数根据 // 单元格包含的数据类型获取表中 // 指定单元格的内容。如果指定了 // 列名,将从数据库自身(而非应用 // 程序)中获取该名称。 int tbl_get_cell_data (LPCSTR table, LPCSTR row, LPCSTR column, LPCSTR out_text );
// tbl_get_selected_cell 函数 // 检索焦点所在的表单元格的行号和 // 列名。注意,列名取自数据库自身, // 而非应用程序。 int tbl_get_selected_cell (LPCSTR table, char *out_row, char *out_column );
// tbl_press_zoom_button 函数 // 激活指定表单元格的缩放窗口。 int tbl_press_zoom_button ( LPCSTR table, LPCSTR row, LPCSTR column );
4
// tbl_set_cell_data 函数根据单元格 // 包含的数据类型使用指定数据设置单元格 // 的值。如果指定了列名,LoadRunner // 将直接从数据库中获取该名称。 int tbl_set_cell_data (LPCSTR table, LPCSTR row, LPCSTR column, LPCSTR data );
// tbl_set_selected_cell 函数将焦点 // 设置到表中的指定单元格上。指定列名时, // LoadRunner 将直接从数据库中获取该名称。 int tbl_set_selected_cell (LPCSTR table, LPCSTR row, LPCSTR column );
// tbl_set_selected_row 函数选择表中的指定行。 int tbl_set_selected_row (LPCSTR table, LPCSTR row );
// tbl_set_selected_rows 函数选择指定行范围。 int tbl_set_selected_rows(LPCSTR table, LPCSTR from_row , LPCSTR to_row );
// tbl_wait_selected_cell 函数等待 // 表单元格显示后,再继续脚本执行。 int tbl_wait_selected_cell (LPCSTR table, char *row, char *column, UINT time );
// toolbar_button_press 函数激活工具栏中的按钮。 int toolbar_button_press (LPCSTR toolbar, LPCSTR button );
// type 函数描述发送给用于测试 // 的应用程序的键盘输入。 int type (LPCSTR keyboard_input );
// win_activate 函数通过向指定窗口 // 授予焦点并将其升到显示器最上端, // 使其成为活动窗口(等价于单击窗口 // 标题栏)。所有后续输入都将提交给 // 此窗口。 int win_activate (LPCSTR window );
// win_close 函数关闭指定窗口。 int win_close ( LPCSTR window );
// win_get_info 函数检索指定属性的值 // 并将其存储在 out_value 中。 int win_get_info ( LPCSTR window, LPCSTR property, char *out_value );
// win_get_text 函数从指定窗口或 // 窗口区域读取文本。
5
int win_get_text ( LPCSTR window, LPCSTR out_text );
// win_max 函数将指定窗口 // 最大化以充满整个屏幕。 int win_max (LPCSTR window );
// win_min 函数将指定窗口最小化为图标。 int win_min (LPCSTR window );
// win_mouse_click 函数在选中窗口 // 的指定坐标处执行鼠标单击操作。 int win_mouse_click (LPCSTR window, int x, int y, ButtonT button );
// win_mouse_dbl_click 函数在选中窗口 // 的指定坐标处执行鼠标双击操作。 int win_mouse_dbl_click (LPCSTR window, int x, int y, ButtonT button );
// win_mouse_drag 函数在窗口内执行 // 鼠标拖动操作。注意,指定的坐标是 // 相对于窗口(而非屏幕)的左上角。 int win_mouse_drag (LPCSTR window, int start_x, int start_y, int end_x, int end_y, ButtonT button );
// win_move 函数将窗口移动到新的绝对位置。 int win_move ( LPCSTR window, int x, int y );
// win_resize 函数更改窗口的位置。 int win_resize ( LPCSTR window, int width, int height );
// win_restore 函数将窗口从图标化 // 或最大化状态还原为其原始大小。 int win_restore (LPCSTR window );
// win_wait_info 函数等待窗口 // 属性达到指定值,然后继续测试 // 运行。如果未达到指定值,则函数 // 将一直等到时间到期,然后再继 // 续测试。 int win_wait_info (LPCSTR window, LPCSTR property, LPCSTR value, UINT time );
// win_type 函数指定 keyboard_input // 将发送到的目标窗口。 int win_type (LPCSTR window, LPCSTR keyboard_input );
6
// ctrx_<obj>_get_info 函数系列将属性 // 的值分配给值缓冲区。ctrx_obj_get_info // 是一般函数,它可以适用于任何由录制器 // 所标识为对象的对象。 int ctrx_obj_get_info( const char * window_name, long xpos, long ypos, eObjAttribute attribute, char *value, CTRX_LAST );
// ctrx_<obj>_get_info 函数系列将属性的值 // 分配给值缓冲区。ctrx_button_get_info // 获取命令按钮的信息。 int ctrx_button_get_info( const char * window_name, long xpos, long ypos, eObjAttribute attribute, char *value, CTRX_LAST );
// ctrx_<obj>_get_info 函数系列将属性的值 // 分配给值缓冲区。ctrx_edit_get_info // 获取文本框的信息。 int ctrx_edit_get_info( const char * window_name, long xpos, long ypos, eObjAttribute attribute, char *value, CTRX_LAST );
// ctrx_<obj>_get_info 函数系列将属性的值 // 分配给值缓冲区。ctrx_list_get_info // 获取列表框的信息。 int ctrx_list_get_info( const char * window_name, long xpos, long ypos, eObjAttribute attribute, char *value, CTRX_LAST );
// ctrx_connect_server 将 Citrix 客户端连接到 Citrix 服务器。 int ctrx_connect_server (char * server_name, char * user_name, char * password, char * domain);
// ctrx_disconnect_server 断开客户端与 Citrix 服务器的连接。 int ctrx_disconnect_server (char * server_name);
// ctrx_nfuse_connect 使用 NFUSE 应用 // 程序门户建立与 Citrix 服务器的连接。在 // 定义 NFUSE 门户的个性化规范的 ICA 文件 // 中找到的规范将从服务器上下载,在此之后 // 建立连接。 int ctrx_nfuse_connect(char * url);
// 使用 ctrx_get_bitmap_value // 检索位图的哈希字符串值以用于您 // 的自定义同步函数中。位图坐标由 // 前四个参数指定。 int ctrx_get_bitmap_value (long x_start, long y_start, long width, long height, char * buffer);
7
// ctrx_get_text 将矩形中的文本分配到 text_buffer // 中。随后,文本可被用于关联。 int ctrx_get_text( char *window_name, long xpos, long ypos, long width, long height, char * filename, char * text_buffer, CTRX_LAST );
// ctrx_get_text_location 在 xpos、 // ypos、width 和 height 指定区域中 // 搜索指定文本。如果找到字符串,当函数 // 返回后,xpos 和 ypos 即为找到文本的 // 位置。如果未找到字符串,xpos 和 ypos // 则为零。 int ctrx_get_text_location( LPCSTR window_name, long *xpos, long *ypos, long *width, long *height, LPSTR text, long bMatchWholeWordOnly, LPCSTR filename, CTRX_LAST );
// ctrx_get_waiting_time 从运行时设置中获取当前等待 // 时间,或者通过 ctrx_set_waiting_time 设置的值。 int ctrx_get_waiting_time ( long * time );
// 使用 ctrx_get_window_name 检索 // 当前获得焦点的窗口的名称。 int ctrx_get_window_name (LPSTR buffer);
// 使用 ctrx_get_window_position // 检索名为 title 变量值的窗口的位置。 // 如果 title 为 NULL,则函数将检索 // 当前拥有焦点的窗口的位置。 int ctrx_get_window_position (LPSTR title, long *xpos, long *ypos, long *width, long *height);
// ctrx_list_select_item 函数从列表中选择项目。 // 它支持 ListBox 或 ComboBox 类的列表。 int ctrx_list_select_item(char * window_name, long xpos, long ypos, char * item, CTRX_LAST );
// ctrx_menu_select_item 突出显示 // 菜单中的项目,但不激活它。 int ctrx_menu_select_item ( char * window_name, char * menu_path, CTRX_LAST) ;
// ctrx_mouse_click 等待窗口 window_name // 出现,然后执行鼠标单击操作。 int ctrx_mouse_click (long x_pos, long y_pos, long mouse_button, long key_modifier, char * window_name);
// ctrx_obj_mouse_click 等待窗口 window_name // 出现,然后执行鼠标单击操作。 int ctrx_obj_mouse_click (const char * obj_desc, long x_pos, long y_pos, long mouse_button,
8
long key_modifier, char * window_name);
// ctrx_mouse_double_click 等待窗口 window_name // 出现,然后执行鼠标双击操作。 int ctrx_mouse_double_click (long x_pos, long y_pos, long mouse_button, long key_modifier, char * window_name);
// ctrx_obj_mouse_double_click 等待窗口 window_name // 出现,然后执行鼠标双击操作。 int ctrx_obj_mouse_double_click (const char * obj_desc, long x_pos, long y_pos, long mouse_button, long key_modifier, char * window_name);
// ctrx_mouse_down 等待窗口 window_name // 出现,然后执行按下鼠标按键操作。 int ctrx_mouse_down(long x_pos, long y_pos, long mouse_button, long key_modifier, char * window_name);
// ctrx_obj_mouse_down 等待窗口 window_name // 出现,然后执行按下鼠标按键操作。 int ctrx_obj_mouse_down(const char * obj_desc, long x_pos, long y_pos, long mouse_button, long key_modifier, char * window_name);
// ctrx_mouse_up 等待窗口 window_name // 出现,然后在指定位置执行释放鼠标按键操作。 int ctrx_mouse_up(long x_pos, long y_pos, long mouse_button, long key_modifier, char * window_name );
// ctrx_obj_mouse_up 等待窗口 window_name // 出现,然后在指定位置执行释放鼠标按键操作。 int ctrx_obj_mouse_up(const char * obj_desc, long x_pos, long y_pos, long mouse_button, long key_modifier, char * window_name );
// ctrx_set_window 是同步函数,它等待 // 窗口出现,然后 Vuser 才在该窗口中模拟 // 任何键盘或鼠标活动。 int ctrx_set_window (char * window_name);
// ctrx_set_window_ex 是同步函数,它至多 // 等待 time 秒,若窗口出现,Vuser 将在该 // 窗口中模拟任何键盘或鼠标活动。 int ctrx_set_window_ex (char * window_name, long time);
// ctrx_key 模拟用户在 Citrix 客户端中 // 按下非字母数字键。
9
int ctrx_key (char * key, long int key_modifier);
// 函数 ctrx_type 模拟用户键入字母数字字符。 int ctrx_type (char * data);
// ctrx_save_bitmap 将位图保存为文件。 // 该文件将保存在 Vuser 结果日志目录中。 int ctrx_save_bitmap( long x_start, long y_start, long width, long height, const char * file_name );
// ctrx_set_connect_opt 在建立 Citrix 客户端 // 与 Citrix 服务器的连接之前设置连接选项,然后 // 执行与服务器的连接。 int ctrx_set_connect_opt (eConnectionOption option, char * value);
// ctrx_set_exception 定义当不规则 // 事件发生时要执行的操作。此事件必须 // 与名为 window_title 的窗口(通常 // 为弹出式对话框)的外观相关联。当窗口 // 出现时,将调用 handler 函数。 void ctrx_set_exception ( char * window_title, long handler, [void *context]);
// ctrx_set_waiting_time 更改 // 同步函数默认 60 秒的等待时间。 int ctrx_set_waiting_time (long time);
// ctrx_sync_on_bitmap 是同步函数, // 它等待指定位图出现,然后再继续执行。 int ctrx_sync_on_bitmap (long x_start, long y_start, long width, long height, char * hash);
// ctrx_sync_on_bitmap_change 是同步 // 函数,它等待指定位图改变,然后再继续执行。 // 该函数通常用在窗口改变而窗口名称保持 // 不变的情况下。如果窗口名称改变, // 则 ctrx_set_window 将被自动 // 生成。 int ctrx_sync_on_bitmap_change (long x_start, long y_start, long width, long height, <extra_args>, CTRX_LAST);
// ctrx_sync_on_obj_info 被调用时,执行将暂停, // 直到指定对象的属性具有指定的值。 int ctrx_sync_on_obj_info ( char * window_name, long xpos, long ypos, eObjAttribute attribute, char * value, <CTRX_LAST> );
// ctrx_sync_on_window 是同步函数,
10
// 它等待窗口被创建或变为活动的。 int ctrx_sync_on_window (char * window_name, eWindowEvent event, long x_start, long y_start, long width, long height, char * filename, <CTRX_LAST>);
// ctrx_unset_window 是同步函数,它等待 // 窗口被关闭,然后脚本才继续执行。 int ctrx_unset_window (char * window_name);
// ctrx_wait_for_event 是同步函数, // 它等待事件发生。 int ctrx_wait_for_event (char * event);
// 如果窗口存在,ctrx_win_exist 返回 E_OK(零)。 // 在 window_name 中可以使用通配符 (*)。 int ctrx_win_exist (char * window_name, long waiting_time);
// 有关 memchr 的详细信息,请参考 C 语言文档。 void *memchr ( const void *s, int c, size_t n );
// 有关 memcmp 的详细信息,请参考 C 语言文档。 int memcmp ( const void *s1, const void *s2, size_t n );
// memcpy 函数从 src 缓冲区中将 n 个 // 字符复制到 dest 缓冲区。 void *memcpy ( void *dest, const void *src, size_t n );
// 函数 memmove(以及所有不返回 integer 类型 // 的函数)必须明确在 Vugen 脚本中声明。 void *memmove ( void *dest, const void *src, size_t n );
// 有关 memset 的详细信息,请参考 C 语言文档。 void *memset ( void *buffer, int c, size_t n );
// 有关 getenv 的详细信息,请参考 C 语言文档。 char *getenv ( const char *varname );
// 有关 putenv 的详细信息,请参考 C 语言文档。 int putenv ( const char *envstring );
// 有关 system 的详细信息,请参考 C 语言文档。 int system ( const char *string );
// 有关 calloc 的详细信息,请参考 C 语言文档。 void *calloc ( size_t num elems, size_t elem_size );
11
// 有关 free 的详细信息,请参考 C 语言文档。 void free ( void *mem_address );
// 有关 malloc 的详细信息,请参考 C 语言文档。 void *malloc ( size_t num_bytes );
// 有关 realloc 的详细信息,请参考 C 语言文档。 void *realloc ( void *mem_address, size_t size );
// 有关 abs 的详细信息,请参考 C 语言文档。 int abs ( int n );
// 限制:cos 函数在 AIX 平台中无法使用。 double cos ( double x );
// 函数 floor(以及所有不返回 int 值的函数) // 必须明确在 Vugen 脚本中声明。限制:此 // 函数在 AIX 平台中无法使用。 double floor ( double x );
// 在调用 rand 前,请调用 srand 以 // 播种伪随机数生成器 int rand ( void );
// 限制:sin 函数在 AIX 平台中无法使用。 double sin ( double x );
// 函数 sqrt(以及所有不返回 int 值的 // 函数)必须明确在 Vugen 脚本中声明。 // 限制:sqrt 函数在 AIX 平台中 // 无法使用。 double sqrt ( double x );
// 在调用 rand 前,请调用 srand 以 // 播种伪随机数生成器 int srand ( time );
// 有关 fclose 的详细信息,请参考 C 语言文档。 int fclose ( FILE *file_pointer );
// 请不要在脚本中包括操作系统头文件(例如,stdio.h)。 // 但是,这样将导致某些类型(包括 feof 使用的 FILE // 类型)未经定义。这时,请使用 long 替代 FILE
12
// 类型。 int feof ( FILE *file_pointer );
// 有关 ferror 的详细信息,请参考 C 语言文档。 int ferror ( FILE *file_pointer );
// 请不要在脚本中包括操作系统头文件(例如, // stdio.h)。但是,这样会导致某些类型 // (包括 fgetc 使用的 FILE 类型)未经定义。 // 这时,请使用 long 替代 FILE 类型。
int fgetc ( FILE *file_pointer );
// 请不要在脚本中包括操作系统头文件(例如, // stdio.h)。但是,这样会导致某些类型 // (包括 fgets 使用的 FILE 类型)未经定义。 // 这时,请使用 long 替代 FILE 类型。
char *fgets ( char *string, int maxchar, FILE *file_pointer );
// 通过将 t 或 b 字符添加到 fopen 的 access_mode // 参数,此访问模式字符串还将用于指定打开文件的方式 // (文本还是二进制)。 FILE *fopen ( const char *filename, const char *access_mode );
// 有关 fprintf 的详细信息,请参考 C 语言文档。 int fprintf ( FILE *file_pointer, const char *format_string [, args ] );
// 请不要在脚本中包括操作系统头文件(例如, // stdio.h)。但是,这样会导致某些类型 // (包括 fputc 使用的 FILE 类型)未经定义。 // 这时,请使用 long 替代 FILE 类型。
int fputc ( int c, FILE *file_pointer );
// 请不要在脚本中包括操作系统头文件(例如, // stdio.h)。但是,这样会导致某些类型 // (包括 fread 使用的 FILE 类型)未经定义。 // 这时,请使用 long 替代 FILE 类型。
size_t fread ( void *buffer, size_t size, size_t count, FILE *file_pointer );
// 有关 fscanf 的详细信息,请参考 C 语言文档。 int fscanf ( FILE *file_pointer, const char *format string [, args] );
// 有关 fseek 的详细信息,请参考 C 语言文档。 int fseek ( FILE *file_pointer, long offset, int origin );
13
// 请不要在脚本中包括操作系统头文件(例如, // stdio.h)。但是,这样会导致某些类型 // (包括 fwrite 使用的 FILE 类型)未经定义。 // 这时,请使用 long 替代 FILE 类型。
size_t fwrite ( const void *buffer, size_t size, size_t count, FILE *file_pointer );
// 有关 rewind 的详细信息,请参考 C 语言文档。 void rewind ( FILE *file_pointer );
// 有关 sprintf 的详细信息,请参考 C 语言文档。 int sprintf ( char *string, const char *format_string[, args] );
// 有关 sscanf 的详细信息,请参考 C 语言文档。 int sscanf ( const char *buffer, const char *format_string, args );
// 有关 chdir 的详细信息,请参考 C 语言文档。 int chdir ( const char *path );
// chdrive 将当前工作驱动器更改为 drive(表示新驱动器 // 的 integer 类型值)。例如,1 = A、2 = B,依此类推。 int chdrive ( int drive );
// 有关 getcwd 的详细信息,请参考 C 语言文档。 char *getcwd ( char *path, int numchars );
// getdrive 函数返回表示驱动器字母 // 的 integer 类型值:1 = A、2 = B,依此类推。 int getdrive ( void );
// 有关 mkdir 的详细信息,请参考 C 语言文档。 int mkdir ( const char *path );
// 有关 remove 的详细信息,请参考 C 语言文档。 int remove ( const char *path );
// 有关 rmdir 的详细信息,请参考 C 语言文档。 int rmdir ( const char *path );
// 根据系统时钟,time 函数返回从世界标准 // 时间 1970 年 1 月 1 日子夜 (00:00:00) // 作为开始所经过的秒数。返回值存储在 timeptr // 所给出的位置。如果 timeptr 为 NULL,则 // 该值不会被存储。 time_t time ( time_t *timeptr );
14
// 在 Unix 下,ctime 不是线程级安全函数。所以,请使用 ctime_r。 // 有关详细信息,请参阅平台相关文档。 char *ctime ( const time_t *time );
// 有关 ftime 的详细信息,请参考 C 语言文档。 void ftime ( struct _timeb *time1 );
// 在 Unix 下,localtime 不是线程级安全函数。 // 所以,请使用 localtime_r。有关详细信息,请 // 参阅平台相关文档。 struct tm *localtime ( const time_t *time );
// 在 Unix 下,gmtime 不是线程级安全函数。所以,请使用 gmtime_r。 // 有关详细信息,请参阅平台相关文档。 struct tm *gmtime ( const time_t *time );
// 在 Unix 下,asctime 不是线程级安全函数。所以,请使用 asctime_r。 // 有关详细信息,请参阅平台相关文档。 char *asctime ( const struct tm *time );
// 通过停止在第一个非数字字符上,atof 只 // 读取字符串的初始位置。函数 atof(以及 // 所有不返回 integer 类型值的函数) // 必须明确在 Vugen 脚本中声明。
double atof ( const char *string );
// 通过停止在第一个非数字字符上,atoi 只 // 读取字符串的初始位置。 int atoi ( const char *string );
// 通过停止在第一个非数字字符上,atol 只 // 读取字符串的初始位置。函数 atol(以及 // 所有不返回 integer 类型值的函数)必须 // 明确在 Vugen 脚本中声明。
long atol ( const char *string );
// itoa 将 value 的数字转换为以 radix 作为 // 基数的字符串 str。通常,radix 是 10。 int itoa ( int value, char *str, int radix );
// 通过停止在第一个非数字字符上,strtol // 只扫描字符串的初始位置。所有前置空格 // 都将被去除。endptr 指向停止扫描的字符。
15
// 函数 strtol(以及所有不返回 integer // 类型值的函数)必须明确在 Vugen 脚本中 // 声明。 long strtol ( const char *string, char **endptr, int radix );
// 有关 tolower 的详细信息,请参考 C 语言文档。 int tolower (int c);
// 有关 toupper 的详细信息,请参考 C 语言文档。 int toupper ( int c );
// 有关 isdigit 的详细信息,请参考 C 语言文档。 int isdigit ( int c );
// 函数 isalpha 检查 c 的值是否 // 处于 A-Z 或 a-z 的范围之内。 int isalpha ( int c );
// strcat 连接两个字符串。 char *strcat ( char *to, const char *from );
// strchr 返回指向字符串中 // 第一个匹配字符的指针。 char *strchr ( const char *string, int c );
// strcmp 比较 string1 和 string2 以确定字母排序的次序。 int strcmp ( const char *string1, const char *string2 );
// strcpy 将一个字符串复制给另一个。 char *strcpy ( char *dest, const char *source );
// strdup 复制字符串的副本。 char *strdup ( const char *string );
// stricmp 对两个字符串进行不区分大小写的比较。 int stricmp ( const char *string1, const char *string2 );
// strlen 返回字符串的长度(以字节为单位)。 size_t strlen ( const char *string );
// strlwr 将字符串转换为小写。 char *strlwr ( char *string );
// strncat 将一个字符串的 n 个字符连接到另一字符串。
16
char *strncat ( char *to_string, const char *from_string, size_t n );
// strncmp 比较两个字符串的前 n 个字符。 int strncmp ( const char *string1, const char *string2, size_t n );
// strncpy 将一个字符串的前 n 个字符复制到另一字符串。 char *strncpy ( char *dest, const char *source, size_t n );
// strnicmp 对两个字符串的 n 个 // 字符进行不区分大小写的比较,以 // 确定其字母排序的次序。 int strnicmp ( const char *string1, const char *string2, size_t num);
// strrchr 查找一个字符串中的最后一个匹配字符。 char *strrchr ( const char *string, int c );
// strset 使用指定字符填充字符串。 char *strset( char *string1, int character );
// strspn 返回指定字符串中包含另一 // 字符串起始字符的长度。 size_t *strspn ( const char *string, const char *skipset );
// strstr 返回一个字符串在另一字符串中第一次发生匹配的指针。 char *strstr ( const char *string1, const char *string2 );
// strtok 从由指定的字符分隔的字符串中返回标记。 // 注意,在 Vugen 文件中,需要明确声明不返回 // integer 类型值的 C 函数。 char *strtok ( char *string, const char *delimiters );
// strupr 将字符串转换为大写。 char *strupr ( char *string );
// lrc_CoCreateInstance 函数在本地系统或为特定 // 对象创建的默认主机中创建该对象的单个未初始化实例 // 并返回未知接口,该接口可用于获取其他接口。创建 // 该实例后,VuGen 调用 lrc_CoGetClassObject // 以检索接口。如果 COM 对象位于远程计算机中, // 将使用 lrc_CreateInstanceEx 取代 // lrc_CoCreateInstance。 HRESULT lrc_CoCreateInstance(GUID * pClsid, IUnknown * pUnkOuter, unsigned long dwClsContext, GUID * riid, LPVOID * ppv, BOOL __CheckResult);
17
// lrc_CreateInstanceEx 函数在指定的 // 远程计算机上创建未初始化的对象,并且 // 可以返回任意数量的请求接口。 HRESULT lrc_CreateInstanceEx(char *clsidStr, Iunknown *pUnk, DWORD dwClsCtx, ...);
// lrc_CoGetClassObject 函数提取 // 指定类的类工厂。 void lrc_CoGetClassObject( REFCLSID rclsid, Long dwClsContext, COSERVERINFO * pServerInfo, REFIID riid, LPVOID * ppv);
// lrc_GUID 函数返回命名对象(例如 // COM 接口)的 GUID。VuGen 使用它 // 检索标识符,该标识符用于检索接口 // 标识符和用于 COM 通信的 COM 对象 // 的 PROGID。 GUID lrc_GUID(const char *str);
// lrc_GUID_by_ref 函数返回指向命名对象 // (例如 COM 接口)的 GUID 的指针。VuGen // 使用它检索标识符,该标识符用于检索接口 // 标识符和用于 COM 通信的 COM 对象的 // PROGID。 GUID* lrc_GUID_by_ref(const char *str);
// lrc_DispMethod 函数使用 IDispatch:Invoke // 方法调用接口的方法。lrc_DispMethod 调用 // 将 wflags 设置为 DISPATCH_METHOD。 VARIANT lrc_DispMethod(IDispatch * pDispatch, char *idName, unsigned long locale, ...);
// lrc_DispMethod1 使用 IDispatch 接口调用 // (或获取)同名的方法(或属性)。lrc_DispMethod1 // 调用将 wflags 设置为 DISPATCH_METHOD 和 // DISPATCH_PROPERTYGET。它可以用在方法与属性 // 具有同一名称的情况下。 VARIANT lrc_DispMethod1(IDispatch * pDispatch, char *idName, unsigned long locale, ...);
// lrc_DispPropertyGet 调用使用 IDispatch 接口 // 获取属性并将 wflags 设置为 DISPATCH_PROPERTYGET。 VARIANT lrc_DispPropertyGet(IDispatch * pDispatch, char *idName, unsigned long locale, ...);
// lrc_DispPropertyPut 使用 IDispatch 接口设置属性。 // 该调用将设置 DISPATCH_PROPERTYPUT 标志。 void lrc_DispPropertyPut(IDispatch * pDispatch, char *idName, unsigned long locale, ...);
18
// lrc_DispPropertyPutRef 使用 IDispatch 接口根据 // 引用设置属性,并设置 DISPATCH_PROPERTYPUTREF 标志。 void lrc_DispPropertyPutRef(IDispatch * pDispatch, char *idName, unsigned long locale, ...);
// lrc_CreateVBCollection 函数创建填充安全 // 数组值的 Visual Basic (VB) Collection 对象, // 并将集合接口指针返回到 pCollection 中。 // VB 集合是由 COM 实现为接口的变量 // SafeArray。 HRESULT lrc_CreateVBCollection(SAFEARRAY *items, _Collection** pCollection);
// lrc_CoObject_from_variant 函数从变量中 // 提取 IUnknown 接口类型指针。 IUnknown* lrc_CoObject_from_variant(VARIANT var);
// lrc_DispObject_from_variant 函数从变量中 // 提取 IDispatch 接口类型指针。 IDispatch* lrc_DispObject_from_variant(VARIANT var);
// lrc_CoObject_by_ref_from_variant 函数从指向 // 变量的指针中提取 IUnknown 接口类型指针。 IUnknown* lrc_CoObject_by_ref_from_variant(VARIANT var);
// lrc_DispObject_by_ref_from_variant 函数从指向 // 变量的指针中提取 IDispatch 接口类型指针。 IDispatch* lrc_DispObject_by_ref_from_variant(VARIANT var);
// 输入表示整数的字符串时,lrc_int 函数返回 // integer 类型值。此参数可以是文字字符串、 // 变量或参数。 int lrc_int(const char* str);
// 输入表示整数的字符串时,lrc_int_by_ref // 函数返回指向 integer 类型值的指针。此参数 // 可以是文字字符串、变量或 // 参数。 int* lrc_int_by_ref(const char* str);
// lrc_save_int 函数将 integer 值 // 保存在指定变量 name 下的字符串中,以便 // 您将其用于参数化。VuGen 将此函数生成 // 为注释掉的调用。如果要将此值用作参数, // 可以更改 name 参数并取消调用的 // 注释。
19
int lrc_save_int(const char* name, int val);
// lrc_save_int_by_ref 函数将 integer 值 // 保存在字符串中,并将 val 设置为指向该字符串。 // VuGen 将此函数生成为注释掉的调用。如果要 // 将此值用作参数,可以更改 name 并取消调用 // 的注释。 int lrc_save_int_by_ref(const char* name, int *val);
// lrc_get_bstr_length 返回 BSTR 类型字符 // 串的长度。BSTR 字符串可以包括 null。 int lrc_get_bstr_length(BSTR str);
// lrc_get_bstr_sub 从输入字符串 str 的开始处 // 返回 size 个字符的子集。 BSTR lrc_get_bstr_sub(BSTR str, int size);
// lrc_print_bstr 将 BSTR 字符串输出到 // 用于调试目的的标准输出上。 int lrc_print_bstr(BSTR str);
// lrc_BSTR1 创建长度为 len 的 BSTR 字符串,它可以包括 null。 BSTR lrc_BSTR1 (const char* str, long len);
// lrc_save_BSTR1 函数将 BSTR str 保 // 存到字符串 name 中。 int lrc_save_BSTR1 (const char* name, BSTR str);
// 输入表示无符号整数的字符串时,lrc_uint 函数 // 返回无符号 integer 类型值。 unsigned int lrc_uint(const char* str);
// 输入表示无符号整数的字符串时,lrc_uint_by_ref // 函数返回指向无符号 integer 类型值的 // 指针。 unsigned int* lrc_uint_by_ref(const char* str);
// lrc_save_uint 函数将无符号 integer 值 // 保存在指定变量 name 下的字符串中,以便 // 您将其用于参数化。VuGen 将此函数生 // 成为注释掉的调用。如果要将此值用作 // 参数,可以更改 name 参数并取消调用的 // 注释。 int lrc_save_uint(const char* name, unsigned int val);
20
// lrc_save_uint_by_ref 函数将 // 无符号 integer 类型值保存在字符串中, // 并将 val 设置为指向该字符串。VuGen 将此 // 函数生成为注释掉的调用。如果要将此值 // 用作参数,可以更改 name 并取消调用的注释。 int lrc_save_uint_by_ref(const char* name, unsigned int *val);
// 输入表示 long 类型的字符串时,lrc_long 函数 // 返回长整型值。 long lrc_long(const char* str);
// 输入表示 long 类型的字符串时,lrc_long_by_ref 函数 // 返回指向长整型值的指针。 long* lrc_long_by_ref(const char* str);
// lrc_save_long 函数将长整型值 // 保存在指定变量 name 下的字符串中, // 以便您可以将其用于参数化。VuGen // 将此函数生成为注释掉的调用。如果 // 要将此值用作参数,可以更改 name // 并取消调用的注释。 int lrc_save_long(const char* name, long val);
// lrc_save_long_by_ref 函数将长整型值保存在字符串中, // 并将 val 设置为指向该字符串。 int lrc_save_long_by_ref(const char* name, long *val);
// 输入表示无符号 long 类型值的字符串时, // lrc_ulong 函数返回无符号长整型值。 unsigned long lrc_ulong(const char* str);
// 输入表示无符号 long 类型值的字符串时, // lrc_ulong_by_ref 函数返回指向无符号长整型值 // 的指针。 unsigned long* lrc_ulong_by_ref(const char* str);
// lrc_save_ulong 函数将无符号 // 长整型值保存在指定变量 name 下 // 的字符串中,以便您可以将其用于参数化。 // VuGen 将此函数生成为注释掉的调用。 // 如果要将此值用作参数,可以更改 name // 并取消调用的注释。 int lrc_save_ulong(const char* name, unsigned long val);
21
// lrc_save_ulong_by_ref 函数将无符号长整型值保存为字符串, // 并将 val 设置为指向该字符串。 int lrc_save_ulong_by_ref(const char* name, unsigned long *val);
// 输入表示短整型值的字符串时,lrc_short 函数 // 返回短整型值。 short lrc_short(const char* str);
// 输入表示短整型值的字符串时,lrc_short_by_ref 函数 // 返回指向短整型值的 // 指针。 short* lrc_short_by_ref(const char* str);
// lrc_save_short 函数将短整型值保存 // 在指定变量 name 下的字符串中,以便 // 您可以将其用于参数化。VuGen 将此 // 函数生成为注释掉的调用。如果要将此值 // 用作参数,可以更改 name 并取消调用的 // 注释。 int lrc_save_short(const char* name, short val);
// lrc_save_short_by_ref 函数将短整型值保存在字符串中, // 并将 val 设置为指向该字符串。 int lrc_save_short_by_ref(const char* name, short *val);
// 输入表示货币值的字符串时,lrc_currency 函 // 数返回货币值。 CY lrc_currency(const char* str);
// 输入表示货币值的字符串时, // lrc_currency_by_ref 函数返回指向 // 货币结构的指针。 CY* lrc_currency_by_ref(const char* str);
// lrc_save_currency 函数将货币 (CY) 值 // 保存在指定变量 name 下的字符串中,以便您 // 可以将其用于参数化。VuGen 将此函数 // 生成为注释掉的调用。如果要将此值 // 用作参数,可以更改 name 并取消调用的 // 注释。 int lrc_save_currency(const char* name, CY val);
// lrc_save_currency_by_ref 函数将由“val”
22
// 指针引用的货币值保存到字符串参数中。 int lrc_save_currency_by_ref(const char* name, CY *val);
// 输入表示 date 类型值的字符串时, // lrc_date 函数返回 DATE 类型值。 DATE lrc_date(const char* str);
// 输入表示 date 类型值的字符串时,lrc_date_by_ref 函数 // 返回指向 DATE 的指针。 DATE* lrc_date_by_ref(const char* str);
// lrc_save_date 函数将 date 类型值保存 // 为字符串。VuGen 将此函数生成为注释掉的调用。 // 如果要将此值用作参数,可以更改 name 并取消 // 调用的注释。 int lrc_save_date(const char* name, DATE val);
// lrc_save_date_by_ref 函数将 date 类型值保存为字符串。 int lrc_save_date_by_ref(const char* name, DATE *val);
// 输入包含“true”或“false”的字符串时, // lrc_bool 函数返回 Boolean 类型值。 VARIANT_BOOL lrc_bool(const char* str);
// 输入包含“true”或“false”的字符串时, // lrc_bool_by_ref 函数返回指向 Boolean // 类型值的指针。 VARIANT_BOOL* lrc_bool_by_ref(const char* str);
// lrc_save_bool 函数将 Boolean 类型值 // 保存为字符串参数。VuGen 将此函数生成为 // 注释掉的调用。如果要将此值用作参数,可以 // 更改 name 并取消调用的注释。 int lrc_save_bool(const char* name, VARIANT_BOOL val);
// lrc_save_bool_by_ref 函数将 Boolean 类型值 // 保存到字符串参数中。 int lrc_save_bool_by_ref(const char* name, VARIANT_BOOL *val);
// 输入表示无符号短整型值的字符串时, // lrc_ushort 函数返回无符号 // 短整型值。 unsigned short lrc_ushort(const char* str);
23
// 输入表示无符号短整型值的字符串时, // lrc_ushort_by_ref 函数返回指向无符号短整型值 // 的指针。 unsigned short* lrc_ushort_by_ref(const char* str);
// lrc_save_ushort 函数将无符号 // 短整型值保存在参数中。 int lrc_save_ushort(const char* name, unsigned short val);
// lrc_save_ushort_by_ref 函数将无符号短整型值 // 保存到参数中。 int lrc_save_ushort_by_ref(const char* name, unsigned short *val);
// 输入包含浮点数的字符串时, // lrc_float 函数返回浮点数。 float lrc_float(const char* str);
// 输入包含浮点数的字符串时, // lrc_float_by_ref 函数返回指向浮点数 // 的指针。 float* lrc_float_by_ref(const char* str);
// lrc_save_float 函数将浮点类型 // 浮点值保存在字符串参数中。VuGen 将此 // 函数生成为注释掉的调用。如果要使用 // 该参数,可以更改 name 并取消调用的 // 注释。 int lrc_save_float(const char* name, float val);
// lrc_save_float_by_ref 函数将浮点 // 类型浮点值保存在字符串参数中。 int lrc_save_float_by_ref(const char* name, float *val);
// 输入包含 double 类型值的字符串时, // lrc_double 函数返回 double 类型值。 double lrc_double(const char* str);
// 输入包含 double 类型值的字符串时,lrc_double_by_ref // 函数返回指向 double 类型值的指针。 double* lrc_double_by_ref(const char* str);
// lrc_save_double 函数将双精度浮点 // 类型值保存在字符串参数中。VuGen 将 // 此函数生成为注释掉的调用。如果要将
24
// 此值用作参数,可以更改 name 并取消 // 调用的注释。 int lrc_save_double(const char* name, double val);
// lrc_save_double_by_ref 函数将双精度浮点 // 类型值保存在字符串参数中。 int lrc_save_double_by_ref(const char* name, double *val);
// 输入包含 dword 类型值的字符串时,lrc_dword 函数 // 返回双字类型值。 DWORD lrc_dword(const char* str);
// lrc_save_dword 函数将双字类型值 // 保存在字符串参数中。VuGen 将此函数 // 生成为注释掉的调用。如果要将此值用作 // 参数,可以更改 name 并取消调用的注释。 int lrc_save_dword(const char* name, DWORD val);
// lrc_BSTR 函数将任何字符串转换为 BSTR。 BSTR lrc_BSTR(const char* str);
// lrc_save_BSTR 函数将 BSTR 值保存 // 为字符串参数。VuGen 将此函数生成为 // 注释掉的调用。如果要将此值用作参数, // 可以更改 name 并取消调用的注释。 int lrc_save_BSTR(const char* name, BSTR val);
// lrc_ascii_BSTR 函数将字符串 // 转换为 ascii_BSTR。 BSTR lrc_ascii_BSTR(const char* str);
// lrc_ascii_BSTR_by_ref 函数将字符串转换 // 为 ascii_BSTR,并返回指向该 BSTR 的指针。 BSTR* lrc_ascii_BSTR_by_ref(const char* str);
// 当不再使用 COM 对象时, // lrc_Release_Object 函数释放该对象。 // 释放对象后,对象的引用计数将减 1 // (例如,IUnknown_1 到 IUnknown_0)。 // int lrc_Release_Object(const char* interface);
// lrc_save_ascii_BSTR 函数将 ascii BSTR 保存 // 到字符串参数中。VuGen 将此函数生成为注释掉的调用。
25
// 如果要将此值用作参数,可以更改 name 并取消调用的 // 注释。 int lrc_save_ascii_BSTR(const char* name, BSTR val);
// lrc_save_ascii_BSTR_by_ref 函数将 ascii BSTR 保 // 存到字符串参数中。 int lrc_save_ascii_BSTR_by_ref(const char* name, BSTR *val);
// lrc_save_VARIANT 函数将任何数据类型的值 // 保存到字符串参数中。 int lrc_save_VARIANT(const char* name, VARIANT val);
// lrc_save_variant_<Type-Name> 函数系列 // 由 VuGen 生成,用于将指定的 <Type-Name> // 变量保存为字符串参数。VuGen 将这些代码行 // 生成为注释掉的调用。如果要将此值用作参数, // 可以更改 name 并取消调用的 // 注释。 int lrc_save_variant_<Type-Name>(const char* name, VARIANT val);
// lrc_save_variant_short 将 short 变量类型值保存到字符串参数中。 int lrc_save_variant_short(const char* name, VARIANT val);
// lrc_save_variant_ushort 将 short 变量类型值保存到字符串参数中。 int lrc_save_variant_ushort(const char* name, VARIANT val);
// lrc_save_variant_char 将 short 变量类型值保存到字符串参数中。 int lrc_save_variant_char(const char* name, VARIANT val);
// lrc_save_variant_int 将 int 变量类型值保存到字符串参数中。 int lrc_save_variant_int(const char* name, VARIANT val);
// lrc_save_variant_uint 将无符号 integer 变量 // 类型值到字符串参数中。 int lrc_save_variant_uint(const char* name, VARIANT val);
// lrc_save_variant_ulong 将无符号 long 变量 // 类型值保存到字符串参数中。 int lrc_save_variant_ulong(const char* name, VARIANT val);
// lrc_save_variant_BYTE 将 BYTE 变量类型值保存到字符串参数中。 int lrc_save_variant_BYTE(const char* name, VARIANT val);
// lrc_save_variant_long 将 long 变量类型值保存到字符串参数中。
26
int lrc_save_variant_long(const char* name, VARIANT val);
// lrc_save_variant_float 将 float 变量类型值保存到字符串参数中。 int lrc_save_variant_float(const char* name, VARIANT val);
// lrc_save_variant_double 将 double 变量 // 类型值保存到字符串参数中。 int lrc_save_variant_double(const char* name, VARIANT val);
// lrc_save_variant_bool 将 boolean 变量类型值保存到字符串参数中。 int lrc_save_variant_bool(const char* name, VARIANT val);
// lrc_save_variant_scode 将 scode 变量类型值保存到字符串参数中。 int lrc_save_variant_scode(const char* name, VARIANT val);
// lrc_save_variant_currency 将 currency 变量 // 类型值保存到字符串参数中。 int lrc_save_variant_currency(const char* name, VARIANT val);
// lrc_save_variant_date 将 DATE 变量类型值保存到字符串参数中。 int lrc_save_variant_date(const char* name, VARIANT val);
// lrc_save_variant_BSTR 将 BSTR 变量类型值保存到字符串参数中。 int lrc_save_variant_BSTR(const char* name, VARIANT val);
// lrc_save_variant_<Type-Name>_by_ref 函数 // 系列由 VuGen 生成,以便将通过变量中的引用方式 // 存储的、指定了 <Type-Name> 的变量保存为字符串 // 参数。VuGen 将这些代码行生成为注释掉的调用。 // 如果要将此值用作参数,可以更改 name 并取消调用的 // 注释。 // int lrc_save_variant_<Type-Name>_by_ref(const char* name, VARIANT val);
// lrc_save_variant_short_by_ref 将通过变量中 // 的引用方式存储的值保存为参数。 int lrc_save_variant_short_by_ref(const char* name, VARIANT val);
// lrc_save_variant_ushort_by_ref 将 // 通过变量中的引用方式存储的值保存为参数。 int lrc_save_variant_ushort_by_ref(const char* name, VARIANT val);
// lrc_save_variant_char_by_ref 将通过 // 变量中的引用方式存储的值保存为参数。
27
int lrc_save_variant_char_by_ref(const char* name, VARIANT val);
// lrc_save_variant_int_by_ref 将通过 // 变量中的引用方式存储的值保存为参数。 int lrc_save_variant_int_by_ref(const char* name, VARIANT val);
// lrc_save_variant_uint_by_ref 将通过 // 变量中的引用方式存储的值保存为参数。 int lrc_save_variant_uint_by_ref(const char* name, VARIANT val);
// lrc_save_variant_ulong_by_ref 将通过 // 变量中的引用方式存储的值保存为参数。 int lrc_save_variant_ulong_by_ref(const char* name, VARIANT val);
// lrc_save_variant_BYTE_by_ref 将通过 // 变量中的引用方式存储的值保存为参数。 int lrc_save_variant_BYTE_by_ref(const char* name, VARIANT val);
// lrc_save_variant_long_by_ref 将 // 变量中的引用方式存储的值保存为参数。 int lrc_save_variant_long_by_ref(const char* name, VARIANT val);
// lrc_save_variant_float_by_ref 将通过 // 变量中的引用方式存储的值保存为参数。 int lrc_save_variant_float_by_ref(const char* name, VARIANT val);
// lrc_save_variant_double_by_ref 将通过 // 变量中的引用方式存储的值保存为参数。 int lrc_save_variant_double_by_ref(const char* name, VARIANT val);
// lrc_save_variant_bool_by_ref 将通过 // 变量中的引用方式存储的值保存为参数。 int lrc_save_variant_bool_by_ref(const char* name, VARIANT val);
// lrc_save_variant_scode_by_ref 将通过 // 变量中的引用方式存储的值保存为参数。 int lrc_save_variant_scode_by_ref(const char* name, VARIANT val);
// lrc_save_variant_currency_by_ref 将通过 // 变量中的引用方式存储的值保存为参数。 int lrc_save_variant_currency_by_ref(const char* name, VARIANT val);
// lrc_save_variant_date_by_ref 将通过 // 变量中的引用方式存储的值保存为参数。
28
int lrc_save_variant_date_by_ref(const char* name, VARIANT val);
// lrc_save_variant_BSTR_by_ref 将通过 // 变量中的引用方式存储的值保存为参数。 int lrc_save_variant_BSTR_by_ref(const char* name, VARIANT val);
// lrc_BYTE 函数将字符串转换 // 为无符号字符(字节)数值。 BYTE lrc_BYTE(const char* str);
// lrc_BYTE_by_ref 函数将字符串转换 // 为无符号字符(字节)数值,并返回指向该字节 // 的指针。 char * lrc_BYTE_by_ref(const char* str);
// lrc_save_BYTE 函数将 byte 类型值保存为参数。 // VuGen 将此函数生成为注释掉的调用。如果要将此值 // 用作参数,可以更改 param_name 并取消调用的 // 注释。 int lrc_save_BYTE(const char* param_name, BYTE val);
// lrc_save_BYTE_by_ref 函数将 byte // 类型值保存为参数。VuGen 将此函数生成为 // 注释掉的调用。如果要将此值用作参数,可以 // 更改 param_name 并取消调用的注释。 int lrc_save_BYTE_by_ref(const char* param_name, BYTE *val);
// 输入表示超级整型值的字符串时,lrc_hyper 函 // 数返回超级(64 位)整型值。 hyper lrc_hyper(const char* str);
// 输入表示超级整型值的字符串时, // lrc_hyper_by_ref 函数返回指向 // 超级(64 位)整型值的指针。 hyper* lrc_hyper_by_ref(const char* str);
// lrc_save_hyper 函数将 64 位超级 // 整型值保存在字符串参数中。VuGen 将 // 此函数生成为注释掉的调用。如果要将 // 此值用作参数,可以更改 name 并取消 // 调用的注释。 int lrc_save_hyper(const char* name, hyper val);
// lrc_save_hyper_by_ref 函数将 64 位
29
// 超级整型值保存到字符串参数中。 int lrc_save_hyper_by_ref(const char* name, hyper *val);
// 输入表示无符号超级整型值的字符串时, // lrc_uhyper 函数返回无符号超级 // (64 位)整型值。 uhyper lrc_uhyper(const char* str);
// 输入表示无符号超级整型值的字符串时, // lrc_uhyper_by_ref 函数返回指向 // 无符号超级(64 位)整型值。 uhyper* lrc_uhyper_by_ref(const char* str);
// lrc_save_uhyper 函数将无符号 64 位 // 超级整型值保存在字符串参数中。VuGen 将 // 此函数生成为注释掉的调用。如果要将此值 // 用作参数,可以更改 name 并取消调用的 // 注释。 int lrc_save_uhyper(const char* name, uhyper val);
// lrc_save_uhyper_by_ref 函数将无符号 // 64 位超级整型值保存到字符串参数中。VuGen // 将此函数生成为注释掉的调用。如果要将此值 // 用作参数,可以更改 name 并取消调用的 // 注释。 int lrc_save_uhyper_by_ref(const char* name, uhyper *val);
// lrc_char 函数将包含 char 类型数值 // 的字符串转换为 char 变量。 char lrc_char(const char* str);
// lrc_char_by_ref 函数将包含 char 类型数值的 // 字符串转换为 char 变量。 char* lrc_char_by_ref(const char* str);
// lrc_save_char 函数将 char 类型 // (0 - 127) 保存到字符串参数中。 // VuGen 将此函数生成为注释掉的调用。 // 如果要将此值用作参数,可以更改 name // 并取消调用的注释。 int lrc_save_char(const char* name, char val);
// lrc_save_char_by_ref 函数将 char 类型 // (0 - 127) 保存到字符串参数中。VuGen 将
30
// 此函数生成为注释掉的调用。如果要将此值 // 用作参数,可以更改 name 并取消调用的 // 注释。 int lrc_save_char_by_ref(const char* name, char *val);
// lrc_variant_empty 函数返回空变量。 VARIANT lrc_variant_empty();
// lrc_variant_empty_by_variant 返回 // 包含对空变量引用的变量。 VARIANT lrc_variant_empty_by_variant();
// lrc_variant_null 函数返回 null 变量。 VARIANT lrc_variant_null();
// lrc_variant_null_by_variant 返回 // 包含对 null 变量引用的变量。 VARIANT lrc_variant_null_by_variant();
// lrc_variant_short 函数将字符串转换为 // 短整型值,并在变量中将其返回。 VARIANT lrc_variant_short(const char* str);
// lrc_variant_short_by_variant 函数将字符串 // 转换为短整型值,并返回包含对某变量(其中包含 // 该短整型值)引用的变量。 VARIANT lrc_variant_short_by_variant(const char* str);
// lrc_variant_ushort 函数将字符串转换为 // 无符号短整型值,并在变量中将其返回。 VARIANT lrc_variant_ushort(const char* str);
// lrc_variant_char 函数将字符串转换为 // char 类型值,并在变量中将其返回。 VARIANT lrc_variant_char(const char* str);
// lrc_variant_int 函数将字符串转换为整型 // 值,并在变量中将其返回。 VARIANT lrc_variant_int(const char* str);
// lrc_variant_uint 函数将字符串转换为 // 无符号整型值,并将其存储在变量中返回。 VARIANT lrc_variant_uint(const char* str);
31
// lrc_variant_ulong 函数将字符串转换为 // 无符号长整型值,并将其存储在变量中返回。 VARIANT lrc_variant_ulong(const char* str);
// lrc_variant_BYTE 函数将字符串转换为 // 无符号 char (byte) 类型值并存储于变量中。 VARIANT lrc_variant_BYTE(const char* str);
// lrc_variant_BYTE_by_variant 函数将字符串 // 转换为无符号 char (byte) 类型值,并返回包含 // 对某变量(包含该 byte)引用的变量。 VARIANT lrc_variant_BYTE_by_variant(const char* str);
// lrc_variant_long 函数将字符串 // 转换为存储于变量中的长整型值。 VARIANT lrc_variant_long(const char* str);
// lrc_variant_long_by_variant 函数将 // 字符串转换为存储于变量中的长整型值,并且 // 返回包含对某变量(其中包含该长整型值) // 引用的变量。 VARIANT lrc_variant_long_by_variant(const char* str);
// lrc_variant_float 函数将字符串转换为 // 存储于变量中的浮点类型值。 VARIANT lrc_variant_float(const char* str);
// lrc_variant_float_by_variant 函数将 // 字符串转换为浮点类型值,并且返回包含对某 // 变量(其中包含该值)引用的变量。 VARIANT lrc_variant_float_by_variant(const char* str);
// lrc_variant_double 函数将字符串转换为 // 存储于变量中的双精度型浮点值。 VARIANT lrc_variant_double(const char* str);
// lrc_variant_double_by_variant 函数将 // 字符串转换为双精度型值,并且返回包含对某变量 // (其中包含该值)引用的变量。 VARIANT lrc_variant_double_by_variant(const char* str);
// lrc_variant_bool 函数将包含“true”或“false” // 的字符串转换为存储于变量中的 Boolean 类型值。 VARIANT lrc_variant_bool(const char* str);
32
// lrc_variant_bool_by_variant 函数将 // 包含“true”或“false”的字符串转换为 // Boolean 值,并且返回包含对某变量(其中 // 包含该值)引用的变量。 VARIANT lrc_variant_bool_by_variant(const char* str);
// lrc_variant_scode 函数将包含系统错误代码值的。 // 字符串转换为存储于变量中的错误代码 VARIANT lrc_variant_scode(const char* errcode);
// lrc_variant_scode_by_variant 函数将 // 包含系统错误代码值的字符串转换为错误代码, // 并且返回包含对某变量(其中包含该值)引用 // 的变量。 VARIANT lrc_variant_scode_by_variant(const char* errcode);
// lrc_variant_currency 函数将包含货币值 // 的字符串转换为存储于变量中的货币值。 VARIANT lrc_variant_currency(const char* str);
// lrc_variant_currency_by_variant 函数 // 将包含货币值的字符串转换为货币值,并且 // 返回包含对某变量(其中包含该值)引用的 // 变量。 VARIANT lrc_variant_currency_by_variant(const char* str);
// lrc_variant_date 函数将包含 date 类型值的 // 字符串转换为存储于变量中的 date 类型值。 VARIANT lrc_variant_date(const char* str);
// lrc_variant_date_by_variant 函数将 // 包含 date 类型值的字符串转换为 date 类型值, // 并且返回包含对某变量(其中包含该 date 类型值) // 引用的变量。 VARIANT lrc_variant_date_by_variant(const char* str);
// lrc_variant_BSTR 函数将字符串转换为 // 存储于变量中的 BSTR 类型值。 VARIANT lrc_variant_BSTR(const char* str);
// lrc_variant_BSTR_by_variant 函数将字符串 // 转换为 BSTR 值,并且返回包含对某变量(其中 // 包含该值)引用的变量。
33
VARIANT lrc_variant_BSTR_by_variant(const char* str);
// lrc_variant_ascii_BSTR 函数将字符串分配给 // 存储于变量中的 ASCII BSTR 值 VARIANT lrc_variant_ascii_BSTR(const char* str);
// lrc_variant_CoObject 函数将 IUnknown 接口 // 指针分配给变量。 VARIANT lrc_variant_CoObject(IUnknown* pUnknown);
// lrc_variant_CoObject_by_variant 函数将 // IUnknown 接口指针分配给变量,并且返回 // 包含对某变量(其中包含 IUnknown 引用) // 引用的变量。 VARIANT lrc_variant_CoObject_by_variant(IUnknown* pUnknown);
// lrc_variant_DispObject 函数将 // IDispatch 接口指针分配给变量。 VARIANT lrc_variant_DispObject(IDispatch* pDispatch);
// lrc_variant_DispObject_by_variant 函数 // 将 IDispatch 接口指针分配给变量,并且返回包含 // 对某变量(其中包含 IDispatch 引用)引用的 // 变量。 VARIANT lrc_variant_DispObject_by_variant(IDispatch* pDispatch);
// lrc_variant_short_by_ref 函数将字符串 // 分配给通过变量中的引用方式存储的短整型值。 VARIANT lrc_variant_short_by_ref(const char* str);
// lrc_variant_ushort_by_ref 函数将字符串 // 分配给通过变量中的引用方式存储的无符号短整型值。 VARIANT lrc_variant_ushort_by_ref(const char* str);
// lrc_variant_char_by_ref 函数将字符串分配 // 给通过变量中的引用方式存储的 char 类型值。 VARIANT lrc_variant_char_by_ref(const char* str);
// lrc_variant_int_by_ref 函数将字符串分配给 // 通过变量中的引用方式存储的 integer 类型值。 VARIANT lrc_variant_int_by_ref(const char* str);
// lrc_variant_uint_by_ref 函数将字符串分配给 // 通过变量中的引用方式存储的无符号 integer 类型值。
34
VARIANT lrc_variant_uint_by_ref(const char* str);
// lrc_variant_ulong_by_ref 函数将字符串分配给 // 通过变量中的引用方式存储的长整型值。 VARIANT lrc_variant_ulong_by_ref(const char* str);
// lrc_variant_BYTE_by_ref 函数将字符串分配给 // 通过变量中的引用方式存储的 char (byte) 类型值。 VARIANT lrc_variant_BYTE_by_ref(const char* str);
// lrc_variant_long_by_ref 函数将字符串分配给 // 通过变量中的引用方式存储的长整型值。 VARIANT lrc_variant_long_by_ref(const char* str);
// lrc_variant_float_by_ref 函数将字符串分配给 // 通过变量中的引用方式存储的浮点型浮点值。 VARIANT lrc_variant_float_by_ref(const char* str);
// lrc_variant_double_by_ref 函数将字符串分配给 // 通过变量中的引用方式存储的双精度型值。 VARIANT lrc_variant_double_by_ref(const char* str);
// lrc_variant_bool_by_ref 函数将包含“true” // 或“false”的字符串分配给通过变量中的 // 引用方式存储的 Boolean 类型值。 VARIANT lrc_variant_bool_by_ref(const char* str);
// lrc_variant_scode_by_ref 函数将包含 // 系统错误代码值的字符串分配给通过变量中的 // 引用方式存储的错误代码中。 VARIANT lrc_variant_scode_by_ref(const char* str);
// lrc_variant_currency_by_ref 函数将字符串 // 分配给通过变量中的引用方式存储的货币类型值。 VARIANT lrc_variant_currency_by_ref(const char* str);
// lrc_variant_date_by_ref 函数将字符串 // 分配给通过变量中的引用方式存储的 date 类型值。 VARIANT lrc_variant_date_by_ref(const char* str);
// lrc_variant_BSTR_by_ref 函数将字符串分配给的 // 通过变量中引用方式存储的 BSTR 值。 VARIANT lrc_variant_BSTR_by_ref(const char* str);
35
// lrc_variant_ascii_BSTR_by_ref 函数将字符串 // 分配给通过变量中的引用方式存储的 ascii BSTR 值。 VARIANT lrc_variant_ascii_BSTR_by_ref(const char* str);
// lrc_variant_CoObject_by_ref 函数将指针 // 分配给变量中的 IUnknown 接口。 VARIANT lrc_variant_CoObject_by_ref(IUnknown* pUnknown);
// lrc_variant_DispObject_by_ref 函数将指针 // 转换为变量中的 IDispatch 接口。 VARIANT lrc_variant_DispObject_by_ref(IDispatch* pDispatch);
// lrc_variant_variant_by_ref 函数创建包含现有 // 变量的新变量。 VARIANT lrc_variant_variant_by_ref(VARIANT * pVar);
// lrc_variant_from_variant_by_ref 函数从 // 另一个变量引用中获取变量。 VARIANT lrc_variant_from_variant_by_ref(VARIANT var);
// Create<n>D<Type-Name>Array 函数系列 // 创建由 Type-name 指定的类型的 n 维数组。 // 对于每一维,该调用必须指定 lower_bound // 和 upper_bound。 <Type-Name> Array Create<n>D<Type-Name>Array(int lower_bound,int upper_bound, int lower_bound, int upper_bound...);
// Destroy<Type-Name>Array 函数系列销毁 // 由 Type-name 指定的类型的数组。对于在 // 脚本中(而非由 VuGen)创建的数组,可以使用 // 它们恢复内存。 void Destroy<Type-Name>Array(<Type-Name>Array Array);
// DestroyBoolArray 释放由数组占用的内存。 // 该函数用于恢复由脚本为数组分配的内存。 void DestroyBoolArray(BoolArray Array);
// DestroyBstrArray 释放由数组占用的内存。 // 该函数用于恢复由脚本为数组分配的内存。 void DestroyBstrArray(BstrArray Array);
// DestroyByteArray 释放由数组占用的内存。 // 该函数用于恢复由脚本为数组分配的内存。 void DestroyByteArray(ByteArray Array);
36
// DestroyCharArray 释放由数组占用的内存。 // 该函数用于恢复由脚本为数组分配的内存。 void DestroyCharArray(CharArray Array);
// DestroyCoObjectArray 释放由数组占用的内存。 // 该函数用于恢复由脚本为数组分配的内存。 void DestroyCoObjectArray(CoObjectArray Array);
// DestroyCurrencyArray 释放由数组占用的内存。于 // 该函数用恢复由脚本为数组分配的内存。 void DestroyCurrencyArray(CurrencyArray Array);
// DestroyDateArray 释放由数组占用的内存。 // 该函数用于恢复由脚本为数组分配的内存。 void DestroyDateArray(CurrencyArray Array);
// DestroyDispObjectArray 释放由数组占用的内存。 // 该函数用于恢复由脚本为数组分配的内存。 void DestroyDispObjectArray(DispObjectArray Array);
// DestroyDoubleArray 释放由数组占用的内存。 // 该函数用于恢复由脚本为数组分配的内存。 void DestroyDoubleArray(DoubleArray Array);
// DestroyErrorArray 释放由数组占用的内存。 // 该函数用于恢复由脚本为数组分配的内存。 void DestroyErrorArray(ErrorArray Array);
// DestroyFloatArray 释放由数组占用的内存。 // 该函数用于恢复由脚本为数组分配的内存。 void DestroyFloatArray(FloatArray Array);
// DestroyIntArray 释放由数组占用的内存。 // 该函数用于恢复由脚本为数组分配的内存。 void DestroyIntArray(IntArray Array);
// DestroyLongArray 释放由数组占用的内存。 // 该函数用于恢复由脚本为数组分配的内存。 void DestroyLongArray(LongArray Array);
// DestroyShortArray 释放由数组占用的内存。 // 该函数用于恢复由脚本为数组分配的内存。 void DestroyShortArray(ShortArray Array);
37
// DestroyUIntArray 释放由数组占用的内存。 // 该函数用于恢复由脚本为数组分配的内存。 void DestroyUIntArray(UIntArray Array);
// DestroyULongArray 释放由数组占用的内存。 // 该函数用于恢复由脚本为数组分配的内存。 void DestroyULongArray(ULongArray Array);
// DestroyUShortArray 释放由数组占用的内存。 // 该函数用于恢复由脚本为数组分配的内存。 void DestroyUShortArray(UShortArray Array);
// DestroyVariantArray 释放由数组占用的内存。 // 该函数用于恢复由脚本为数组分配的内存。 void DestroyVariantArray(VariantArray Array);
// GetBufferFrom<n>DByteArray 函数系列从 n 维 // byte 类型数组的最后一维中提取缓冲区。此函数 // 的返回值是一个指向 byte 类型的缓冲区的指针。 // 缓冲区的大小返回到 *plinesize 所指定的 // 地址中。 char * GetBufferFrom<n>DByteArray(ByteArray Array, int ind1...indn-1, size_t *pLineSize);
// Fill<n>DByteArray 函数系列将 n 维 byte 数组 // 的最后一维中填充缓冲区的内容。 char * Fill<n>DByteArray(ByteArray Array, int ind1...indn-1, const char* buffer, size_t buff_size);
// lrc_variant_<Type-Name>Array 函数系列将在 // Type-Name 中指定的类型的数组分配给变量。 VARIANT lrc_variant_<Type-Name>Array(<Type-Name>Array array);
// lrc_variant_BoolArray 将数组分配给变量。 VARIANT lrc_variant_BoolArray(BoolArray array);
// lrc_variant_BstrArray 将数组分配给变量。 VARIANT lrc_variant_BstrArray(BstrArray array);
// lrc_variant_ByteArray 将数组分配给变量。 VARIANT lrc_variant_ByteArray(ByteArray array);
// lrc_variant_CharArray 将数组分配给变量。 VARIANT lrc_variant_CharArray(CharArray array);
38
// lrc_variant_CoObjectArray 将数组分配给变量。 VARIANT lrc_variant_CoObjectArray(CoObjectArray array);
// lrc_variant_CurrencyArray 将数组分配给变量。 VARIANT lrc_variant_CurrencyArray(CurrencyArray array);
// lrc_variant_DateArray 将数组分配给变量。 VARIANT lrc_variant_DateArray(DateArray array);
// lrc_variant_DispObjectArray 将数组分配给变量。 VARIANT lrc_variant_DispObjectArray(DispObjectArray array);
// lrc_variant_DoubleArray 将数组分配给变量。 VARIANT lrc_variant_DoubleArray(DoubleArray array);
// lrc_variant_ErrorArray 将数组分配给变量。 VARIANT lrc_variant_ErrorArray(ErrorArray array);
// lrc_variant_FloatArray 将数组分配给变量。 VARIANT lrc_variant_FloatArray(FloatArray array);
// lrc_variant_IntArray 将数组分配给变量。 VARIANT lrc_variant_IntArray(IntArray array);
// lrc_variant_LongArray 将数组分配给变量。 VARIANT lrc_variant_LongArray(LongArray array);
// lrc_variant_ShortArray 将数组分配给变量。 VARIANT lrc_variant_ShortArray(ShortArray array);
// lrc_variant_UintArray 将数组分配给变量。 VARIANT lrc_variant_UintArray(UintArray array);
// lrc_variant_UlongArray 将数组分配给变量。 VARIANT lrc_variant_UlongArray(UlongArray array);
// lrc_variant_UshortArray 将数组分配给变量。 VARIANT lrc_variant_UshortArray(UshortArray array);
// lrc_variant_VariantArray 将数组分配给变量。 VARIANT lrc_variant_VariantArray(VariantArray array);
// lrc_variant_<Type-Name>Array_by_ref 函数系列
39
// 返回对由 Type-name 指定的类型的数组的引用。返回类型 // 为变量。 VARIANT lrc_variant_<Type-Name>Array_by_ref( <Type-Name>Array array );
// lrc_variant_BoolArray_by_ref 返回对数组的引用 VARIANT lrc_variant_BoolArray_by_ref(BoolArray array);
// lrc_variant_BstrArray_by_ref 返回对数组的引用 VARIANT lrc_variant_BstrArray_by_ref(BstrArray array);
// lrc_variant_ByteArray_by_ref 返回对数组的引用 VARIANT lrc_variant_ByteArray_by_ref(ByteArray array);
// lrc_variant_CharArray_by_ref 返回对数组的引用 VARIANT lrc_variant_CharArray_by_ref(CharArray array);
// lrc_variant_CoObjectArray_by_ref 返回对数组的引用 VARIANT lrc_variant_CoObjectArray_by_ref(CoObjectArray array);
// lrc_variant_CurrencyArray_by_ref 返回对数组的引用 VARIANT lrc_variant_CurrencyArray_by_ref(CurrencyArray array);
// lrc_variant_DateArray_by_ref 返回对数组的引用 VARIANT lrc_variant_DateArray_by_ref(DateArray array);
// lrc_variant_DispObjectArray_by_ref 返回对数组的引用 VARIANT lrc_variant_DispObjectArray_by_ref(DispObjectArray array);
// lrc_variant_DoubleArray_by_ref 返回对数组的引用 VARIANT lrc_variant_DoubleArray_by_ref(DoubleArray array);
// lrc_variant_ErrorArray_by_ref 返回对数组的引用 VARIANT lrc_variant_ErrorArray_by_ref(ErrorArray array);
// lrc_variant_FloatArray_by_ref 返回对数组的引用 VARIANT lrc_variant_FloatArray_by_ref(FloatArray array);
// lrc_variant_IntArray_by_ref 返回对数组的引用 VARIANT lrc_variant_IntArray_by_ref(IntArray array);
// lrc_variant_LongArray_by_ref 返回对数组的引用 VARIANT lrc_variant_LongArray_by_ref(LongArray array);
// lrc_variant_ShortArray_by_ref 返回对数组的引用
40
VARIANT lrc_variant_ShortArray_by_ref(ShortArray array);
// lrc_variant_UintArray_by_ref 返回对数组的引用 VARIANT lrc_variant_UintArray_by_ref(UintArray array);
// lrc_variant_UlongArray_by_ref 返回对数组的引用 VARIANT lrc_variant_UlongArray_by_ref(UlongArray array);
// lrc_variant_UshortArray_by_ref 返回对数组的引用 VARIANT lrc_variant_UshortArray_by_ref(UshortArray array);
// lrc_variant_VariantArray_by_ref 返回对数组的引用 VARIANT lrc_variant_VariantArray_by_ref(VariantArray array);
// lrc_Get<Type-Name>ArrayFromVariant 函数系列从变量中 // 提取由 Type-name 指定的类型的数组。 <Type-Name> lrc_Get<Type-Name>ArrayFromVariant const VARIANT* var);
// lrc_GetBoolArrayFromVariant 从变量中提取数组。 VARIANT lrc_GetBoolArrayFromVariant(const VARIANT* var);
// lrc_GetBstrArrayFromVariant 从变量中提取数组。 VARIANT lrc_GetBstrArrayFromVariant(const VARIANT* var);
// lrc_GetByteArrayFromVariant 从变量中提取数组。 VARIANT lrc_GetByteArrayFromVariant(const VARIANT* var);
// lrc_GetCharArrayFromVariant 从变量中提取数组。 VARIANT lrc_GetCharArrayFromVariant(const VARIANT* var);
// lrc_GetCoObjectArrayFromVariant 从变量中提取数组。 VARIANT lrc_GetCoObjectArrayFromVariant(const VARIANT* var);
// lrc_GetCoInstanceArrayFromVariant 从变量中提取数组。 VARIANT lrc_GetCoInstanceArrayFromVariant(const VARIANT* var);
// lrc_GetCurrencyArrayFromVariant 从变量中提取数组。 VARIANT lrc_GetCurrencyArrayFromVariant(const VARIANT* var);
// lrc_GetDateArrayFromVariant 从变量中提取数组。 VARIANT lrc_GetDateArrayFromVariant(const VARIANT* var);
// lrc_GetDispObjectArrayFromVariant 从变量中提取数组。 VARIANT lrc_GetDispObjectArrayFromVariant(const VARIANT* var);
41
// lrc_GetDoubleArrayFromVariant 从变量中提取数组。 VARIANT lrc_GetDoubleArrayFromVariant(const VARIANT* var);
// lrc_GetErrorArrayFromVariant 从变量中提取数组。 VARIANT lrc_GetErrorArrayFromVariant(const VARIANT* var);
// lrc_GetFloatArrayFromVariant 从变量中提取数组。 VARIANT lrc_GetFloatArrayFromVariant(const VARIANT* var);
// lrc_GetIntArrayFromVariant 从变量中提取数组。 VARIANT lrc_GetIntArrayFromVariant(const VARIANT* var);
// lrc_GetLongArrayFromVariant 从变量中提取数组。 VARIANT lrc_GetLongArrayFromVariant(const VARIANT* var);
// lrc_GetShortArrayFromVariant 从变量中提取数组。 VARIANT lrc_GetShortArrayFromVariant(const VARIANT* var);
// lrc_GetUintArrayFromVariant 从变量中提取数组。 VARIANT lrc_GetUintArrayFromVariant(const VARIANT* var);
// lrc_GetUlongArrayFromVariant 从变量中提取数组。 VARIANT lrc_GetUlongArrayFromVariant(const VARIANT* var);
// lrc_GetUshortArrayFromVariant 从变量中提取数组。 VARIANT lrc_GetUshortArrayFromVariant(const VARIANT* var);
// lrc_GetVariantArrayFromVariant 从变量中提取数组。 VARIANT lrc_GetVariantArrayFromVariant(const VARIANT* var);
// lrc_Get<Type-Name>Array_by_refFromVariant // 函数系列从变量中的指针引用提取在 Type-Name 中 // 指定的类型的数组。 <Type-Name> lrc_Get<Type-Name>Array_by_refFromVariant const VARIANT* var);
// lrc_GetShortArray_by_refFromVariant 从变量中的 // 指针引用提取数组。 VARIANT lrc_GetShortArray_by_refFromVariant(const VARIANT* var);
// lrc_GetUshortArray_by_refFromVariant 从变量中的 // 指针引用提取数组。 VARIANT lrc_GetUshortArray_by_refFromVariant(const VARIANT* var);
42
// lrc_GetCharArray_by_refFromVariant 从变量中的 // 指针引用提取数组。 VARIANT lrc_GetCharArray_by_refFromVariant(const VARIANT* var);
// lrc_GetIntArray_by_refFromVariant 从变量中的 // 指针引用提取数组。 VARIANT lrc_GetIntArray_by_refFromVariant(const VARIANT* var);
// lrc_GetUintArray_by_refFromVariant 从变量中的 // 指针引用提取数组。 VARIANT lrc_GetUintArray_by_refFromVariant(const VARIANT* var);
// lrc_GetUlongArray_by_refFromVariant 从变量中的 // 指针引用提取数组。 VARIANT lrc_GetUlongArray_by_refFromVariant(const VARIANT* var);
// lrc_GetByteArray_by_refFromVariant 从变量中的 // 指针引用提取数组。 VARIANT lrc_GetByteArray_by_refFromVariant(const VARIANT* var);
// lrc_GetLongArray_by_refFromVariant 从变量中的 // 指针引用提取数组。 VARIANT lrc_GetLongArray_by_refFromVariant(const VARIANT* var);
// lrc_GetFloatArray_by_refFromVariant 从变量中的 // 指针引用提取数组。 VARIANT lrc_GetFloatArray_by_refFromVariant(const VARIANT* var);
// lrc_GetDoubleArray_by_refFromVariant 从变量中的 // 指针引用提取数组。 VARIANT lrc_GetDoubleArray_by_refFromVariant(const VARIANT* var);
// lrc_GetBoolArray_by_refFromVariant 从变量中的 // 指针引用提取数组。 VARIANT lrc_GetBoolArray_by_refFromVariant(const VARIANT* var);
// lrc_GetScodeArray_by_refFromVariant 从变量中的 // 指针引用提取数组。 VARIANT lrc_GetScodeArray_by_refFromVariant(const VARIANT* var);
// lrc_GetCurrencyArray_by_refFromVariant 从变量中的 // 指针引用提取数组。 VARIANT lrc_GetCurrencyArray_by_refFromVariant(const VARIANT* var);
43
// lrc_GetDateArray_by_refFromVariant 从变量中的 // 指针引用提取数组。 VARIANT lrc_GetDateArray_by_refFromVariant(const VARIANT* var);
// lrc_GetBstrArray_by_refFromVariant 从变量中的 // 指针引用提取数组。 VARIANT lrc_GetBstrArray_by_refFromVariant(const VARIANT* var);
// lrc_GetCoObjectArray_by_refFromVariant 从变量中的 // 指针引用提取数组。 VARIANT lrc_GetCoObjectArray_by_refFromVariant(const VARIANT* var);
// lrc_GetDispObjectArray_by_refFromVariant 从变量中的 // 指针引用提取数组。 VARIANT lrc_GetDispObjectArray_by_refFromVariant(DispObjectArray array);
// lrc_GetVariantArray_by_refFromVariant 从变量中的 // 指针引用提取数组。 VARIANT lrc_GetVariantArray_by_refFromVariant(DispObjectArray array);
// GetElementFrom<n>D<Type-Name>Array // 函数系列从 SafeArray 中检索指定类型的元素。 // 返回变量的类型是实际语言类型(如无符号长整型), // 而非 lrc 类型(例如,ulong 类型)。 // VuGen 将这些调用生成为注释掉的代码, // 您可以使用它们存储参数化变量。若要使用 // 这些调用,请取消它们的注释并将函数 // 返回值分配给适当类型的变量。 <Actual Type-Name> GetElementFrom<n>D<Type-Name>Array(<Type-Name>Array Array, int index1,..., indexn);
// PutElementIn<n>D<Type-Name>Array 函数 // 系列将给定类型的值存储于在 Type-Name 中 // 给出的 lrc 类型的数组中。 void PutElementIn<n>D<Type-Name>Array(<Type-Name>Array array, int index1,...int indexn, <Actual Type-Name> Value);
// lrc_FetchRecordset 函数将指针在记录集中 // 向前或向后移动到当前记录。 void lrc_FetchRecordset(recordset15* recordset,
// lrc_print_recordset 函数输出由 NumberOfRows // 指示的行数。如果 NumberOfRows 等于 -1,则 // 函数将输出所有行。
int steps);
44
void lrc_print_recordset (Recordset15* recordset, long NumberOfRows);
// lrc_print_variant 函数输出变量。 // 如果变量包含数组或记录,则只输出 // 内容的类型。 void lrc_print_variant (Variant var);
// lrc_save_rs_param 函数将指定字段 // 的值保存到 ADO 记录集的记录中。 void lrc_save_rs_param(Recordset15* recordset, int row, short col, void* reserved, char*param_name);
// lrc_RecordsetWrite 函数更新 ADO // 记录集中的字段。首先,它将指针在记录 // 集中移动指定步数。然后,它将值写入当前 // 记录中。此函数可以表示用户对网格中项目 // 的更改。 void lrc_RecordsetWrite(Recordset15* recordset, VARIANT vIndex, VARIANT vValue, long steps);
// lrc_<type>_by_ref 函数将指针的内存分配给 // 类型 <type> 的变量,并使用 str 中包含的值 // 对其进行初始化。 int * lrc_<type>_by_ref(const char* str);
// lrc_FetchRecordsetUntilEOF 函数将指针 // 在记录中移动,直到移动到记录集的末尾。 void lrc_FetchRecordsetUntilEOF(Recordset15* recordset);
// lrc_RecordsetAddColumn 函数将新列添加 // 到记录集中。它类似于 Append ADO 方法。 void lrc_RecordsetAddColumn(Recordset15* recordset, BSTR name, int type, long size, int attribute);
// lrc_RecordsetDeleteColumn 函数从记录集中删除列。 // 它类似于 Delete ADO 方法。 void lrc_RecordsetDeleteColumn(Recordset15* recordset, VARIANT index);
// lrd_alloc_connection 函数分配 LRD_CONNECTION // 结构。在 lrd_free_connection 释放该结构之前,它是 // 有效的。 LRDRET lrd_alloc_connection ( LRD_CONNECTION **mpptConnection, unsigned int muiDBType, LRD_CONTEXT *mptContext, long mliOption, int miDBErrorSeverity );
45
// lrd_assign 函数将 null 终止字符串 // (文字或存储区域)通过其描述符分配给变量。 // 必要时,字符串将被转换为变量的 // 数据类型和长度。若要在字符串中包含 // null 字符 (‘\0‘),或者如果字符串不是 // null 终止的,请使用 lrd_assign_ext 或 // lrd_assign_literal。只能通过 // 指定 NULL 或 0(不带引号),才能为 lrd_assign // 分配 NULL 值。 LRDRET lrd_assign ( LRD_VAR_DESC *mptVarDesc, char *mpcValStr, char *mpszValStrFmt, unsigned long muliIndex, long mliOffset );
// lrd_assign_ext 将带有显式长度的 // 存储区域值通过其描述符分配给变量。 // 必要时,该值将被转换为变量的数据类型 // 和长度。该值可以包含嵌入的 null 字符 // (‘\0‘)。也可以通过使用 NULL 或 0(不带引号) // 指定 NULL 值。 LRDRET lrd_assign_ext ( LRD_VAR_DESC *mptVarDesc, char *mpcValStr, long mliValStrLen, char *mpszValStrFmt, unsigned long muliIndex, long mliOffset );
// lrd_assign_literal 函数将由引号 // 括起的文字字符串值通过其描述符分配给变量 // (标量或数组)。必要时,该值将被转换为 // 变量的数据类型和长度。该值可以 // 包含嵌入的 null 字符 (‘\0‘)。也可以 // 通过使用 NULL 或 0(不带引号)指定 // NULL 值。字符串的长度由 (sizeof(string) -1) // 确定。 LRDRET lrd_assign_literal ( LRD_VAR_DESC *mptVarDesc, char *mpcValStr, char *mpszValStrFmt, unsigned long muliIndex, long mliOffset );
// lrd_assign_bind 函数将 null 终止 // 字符串值分配给标量变量并将变量绑定到 // 占位符。如果字符串不是 null 终止的,请使用 // lrd_assign_bind_ext 或 lrd_assign_bind_literal。 // 此函数将执行 lrd_assign 和 lrd_bind_placeholder // 函数,但它被限定为标量型 // 变量。 LRDRET lrd_assign_bind ( LRD_CURSOR *mptCursor, char *mpszPlaceholder, char *mpcValStr, LRD_VAR_DESC *mptVarDesc, char *mpszValStrFmt, unsigned long muliOption, int miDBErrorSeverity );
// lrd_assign_bind_ext 函数将带有
46
// 显式长度的存储区域通过其描述符分配给 // 标量变量,并将变量绑定到占位符。 // 必要时,该值将被转换为变量的类型和 // 长度。该值可以包含嵌入的 null 字符 (‘\0‘)。 // 也可以通过使用 NULL 或 0(不带引号)
// 指定 NULL 值。此函数执行 lrd_assign_ext // 和 lrd_bind_placeholder // 函数,但它被限定为标量型 // 变量。
LRDRET lrd_assign_bind_ext ( LRD_CURSOR *mptCursor, char *mpszPlaceholder, char *mpcValStr, long mliValStrLen, LRD_VAR_DESC *mptVarDesc, char *mpszValStrFmt, unsigned long muliOption, int miDBErrorSeverity );
// lrd_assign_bind_literal 函数将 // 由引号括起的文字字符串值通过其描述符 // 分配给标量变量,然后将变量绑定到 SQL 语句 // 文本中的占位符。必要时,该值将被转换 // 为变量的类型和长度。该值可以包含嵌入 // 的 null 字符 (‘\0‘)。也可以通过 // 使用 NULL 或 0(不带 // 引号)指定 NULL // 值。 LRDRET lrd_assign_bind_literal ( LRD_CURSOR *mptCursor, char *mpszPlaceholder, char *mpcValStr, LRD_VAR_DESC *mptVarDesc, char *mpszValStrFmt, unsigned long muliOption, int miDBErrorSeverity );
// lrd_attr_set 函数设置 LRDDBI 句柄 // 的属性。在使用 lrd_handle_alloc 调用此 // 函数前必须显式分配句柄。只有 Oracle 8.0 和 // 更高版本才支持此函数。 LRDRET lrd_attr_set ( void *mpvLRDDBIHandleTarget, long mliAttrType, void *mpvValue, long mliValueLen, int miDBErrorSeverity );
// lrd_attr_set_from_handle 函数设 // 置 LRDDBI 句柄的属性。在使用 lrd_handle_alloc // 调用此函数前必须显式分配句柄。 // 只有 Oracle 8.0 和更高版本才支持 // 此函数。 LRDRET lrd_attr_set_from_handle ( void *mpvLRDDBIHandleTarget, long mliAttrType, void *mpvValue, long mliValueLen, int miDBErrorSeverity );
// lrd_attr_set_literal 函数设置 // LRDDBI 句柄的属性。此函数使用文字 // 字符串指定属性,从而允许其包含 NULL 字符。
47
LRDRET lrd_attr_set_literal ( void *mpvLRDDBIHandleTarget, long mliAttrType, void **mppvValue, int miDBErrorSeverity );
// lrd_bind_col 函数将主机变量绑定到输出列。 // VuGen 为结果集中的所有列生成 lrd_bind_col // 语句。 LRDRET lrd_bind_col ( LRD_CURSOR *mptCursor, int muiColNum, LRD_VAR_DESC *mptVarDesc, long mliOption, int miDBErrorSeverity );
// lrd_bind_cols 函数将主机变量绑定 // 到输出列。VuGen 为结果集中的所有列 // 生成 lrd_bind_col 语句。 LRDRET lrd_bind_cols ( LRD_CURSOR *mptCursor, LRD_BIND_COL_INFO *mptBindColInfo, int miDBErrorSeverity );
// lrd_bind_cursor 将光标绑定到 // SQL 语句文本中的占位符。此函数 // 要与包含 PL/SQL 命令的语句配合使用。 LRDRET lrd_bind_cursor( LRD_CURSOR *mptCursor, char *mpszPlaceholder, unsigned long muliOption, LRD_CURSOR **mpptBoundCursor, int miDBErrorSeverity );
// lrd_bind_placeholder 函数将 // 主机变量或数组绑定到占位符。此函数 // 要与 lrd_assign 配合使用。 LRDRET lrd_bind_placeholder ( LRD_CURSOR *mptCursor, char *mpszPlaceholder, LRD_VAR_DESC *mptVarDesc, unsigned long muliOption, int miDBErrorSeverity );
// lrd_cancel 函数取消提交给数据库 // 服务器的前一语句或信息。在 Oracle // 中,lrd_cancel 通知服务器取消查询并 // 释放与光标相关的所有资源。如果只需要 // 多行查询的第一行,此函数是非常有用的。 // 可以在 lrd_fetch 之后调用 lrd_cancel // 以通知服务器不需要执行其他提取 // 操作。 LRDRET lrd_cancel ( LRD_CONNECTION *mptConnection, LRD_CURSOR *mptCursor, long mliOption, int miDBErrorSeverity );
// lrd_close_all_cursors 函数关闭 // 用于指定连接的所有打开的光标。 LRDRET lrd_close_all_cursors ( LRD_CONNECTION *mptConnection );
// lrd_close_connection 函数 // 关闭与数据库的指定连接。
48
LRDRET lrd_close_connection ( LRD_CONNECTION **mpptConnection, long mliOption, int miDBErrorSeverity );
// lrd_close_context 函数关闭 ctlib 函数的上下文。 LRDRET lrd_close_context ( LRD_CONTEXT **mpptContext, long mliOption, int miDBErrorSeverity );
// lrd_close_cursor 函数关闭指定 // 数据库光标。关闭光标后,则无法再使用 // 该光标执行 SQL 语句。 LRDRET lrd_close_cursor ( LRD_CURSOR **mpptCursor, int miDBErrorSeverity );
// lrd_col_data 函数设置指向 // 特定列的数据的指针。 // 此函数访问数据,但不执行绑定操作。 // 注意,若要引用数据(通过指针),必须将其 // 转换为相应类型。lrd_col_data 只出现 // 在 Vuser 脚本目录的 print.inl 文件中。 LRDRET lrd_col_data ( LRD_CURSOR *mptCursor, unsigned int muiColNum, long mliOffset, LRD_VAR_DESC *mptVarDesc, unsigned long *mpuliFetchedLen, int miDBErrorSeverity );
// lrd_commit 函数提交当 // 前数据库事务。提交事务后, // 不能执行回滚。 LRDRET lrd_commit ( LRD_CONTEXT *mptContext, LRD_CONNECTION *mptConnection, int miDBErrorSeverity );
// lrd_ctlib_cursor 函数指定要初始化 // 的 CtLib 光标命令。此函数指定命令 // 类型及其适用选项。 LRDRET lrd_ctlib_cursor ( LRD_CURSOR *mptCursor, char *mpcName, long mliNameLen, char *mpcText, long mliTextLen, LRDOS_INT4 mjCmdType, LRDOS_INT4 mjCmdOption, int miDBErrorSeverity );
// lrd_data_info 函数基于请求 // 规范获取 I/O 描述符信息。 // 请求规范字符串是 null 终止的字符串, // 其中包含由分号分隔的 <keyword>=<value> // 规范对。 LRDRET lrd_data_info ( LRD_CURSOR *mptCursor, unsigned int muiColNum, unsigned long muliIODescNum, char *mpszReqSpec, int miDBErrorSeverity );
// lrd_db_option 函数为数据库光标、 // 上下文或连接设置选项。
49
LRDRET lrd_db_option ( void *mpvTargetObject, unsigned long muliOption, void *mpvOptionValue, int miDBErrorSeverity );
// lrd_dynamic 函数指定要处理的动态 SQL 语句。 LRDRET lrd_dynamic ( LRD_CURSOR *mptCursor, char *mpcID, long mliIDLen, char *mpcText, long mliTextLen, LRDOS_INT4 mjCmdType, int miDBErrorSeverity );
// lrd_end 函数关闭 VuGen 环境 // 并清除所有打开的结构和指针。此函数 // 在 Vuser 脚本中只被调用一次。 LRDRET lrd_end ( void *mpvEndParams );
// lrd_env_init 函数分配并 // 初始化 LRDBI 环境句柄。 // 如果被指向的指针是 NULL,则将分配 // 新的 LRDDBI 环境句柄。如果该值不是 NULL, // 且被指向的 LRDDBI 句柄具有要求 // 的属性,则不会分配新的 LRDDBI 句柄, // 并且函数将成功返回。否则将 // 返回 LRDRET_E_EXISTING_HANDLE_ERROR。 LRDRET lrd_env_init ( unsigned int muiDBType, void **mppvLRDDBIHandleEnv, unsigned long muliMode, int miDBErrorSeverity );
// lrd_exec 函数执行 lrd_stmt 设置的 SQL 语句。 LRDRET lrd_exec ( LRD_CURSOR *mptCursor, unsigned long muliTotalRows, unsigned long muliSkipRows, unsigned long *mpuliRowsProcessed, long mliOption, int miDBErrorSeverity );
// lrd_fetch 函数从结果集中提取后续若干行。 // 在录制的脚本中,结果集中的行数是参数 // mliRequestedRows 的绝对值。例如, // 如果 lrd_fetch 的第二个参数是 -14,
// 则检索了十四行数据。 // LRDRET lrd_fetch ( LRD_CURSOR *mptCursor, long mliRequestedRows, long mliRowsBatchSize, unsigned long *mpuliFetchedRows, LRD_PRINT_ROW_TYPEDEF mpfjPrintRow, int miDBErrorSeverity );
// lrd_fetchx 函数使用扩展 // 提取 (SQLExtendedFtech) 从结果集 // 中提取后续若干行。在录制的脚本中, // 结果集中的行数是参数 mliRequestedRows // 的绝对值。例如,如果 lrd_fetchx 的第二个 // 参数是 -14,则检索了十四行数据。 LRDRET lrd_fetchx ( LRD_CURSOR *mptCursor, long mliRequestedRows, long
50
mliRowsBatchSize, unsigned long *mpuliFetchedRows, LRD_PRINT_ROW_TYPEDEF mpfjPrintRow, long mliOption, int miDBErrorSeverity );
// lrd_fetch_adv 使用 ODBC 扩展 // 提取 (SQLExtendedFtech) 从结果集 // 中提取多行。在录制的脚本中, // 结果集中的行数是参数 mliRequestedRows 的 // 绝对值。 LRDRET lrd_fetch_adv( LRD_CURSOR *mptCursor, long mliRequestedRows, long mliRowsBatchSize, unsigned long *mpuliFetchedRows, LRD_PRINT_ROW_TYPEDEF mpfjPrintRow, long mliOption, int miDBErrorSeverity, long mlilFetchOffset, unsigned short musOrientation);
// lrd_free_connection 释放 lrd_alloc_connection // 创建的 LRD_CONNECTION 结构。 LRDRET lrd_free_connection ( LRD_CONNECTION **mpptConnection, long mliOption, int miDBErrorSeverity );
// lrd_handle_alloc 函数分配并初始化 // LRDBI 句柄。注意,在调用此函数前必须 // 显式地(使用 lrd_handle_alloc)或 // 隐式地(使用 lrd_logon)分配父句柄。 LRDRET lrd_handle_alloc ( unsigned int muiDBType, void *mpvLRDDBIHandleParent, long mliDBHandleType, void **mppvLRDDBIHandle, int miDBErrorSeverity );
// lrd_handle_free 函数显式地释放 // LRDDDBI 句柄。注意,句柄必须已被 // 显式地(使用 lrd_handle_alloc) // 或隐式地(使用 lrd_logon)分配。只有 // Oracle 8.0 和更高版本才支持此函数。 LRDRET lrd_handle_free ( void **mppvLRDDBIHandle, int miDBErrorSeverity);
// lrd_init 函数设置包含 LRD 环境 // 初始化信息的 LRD_INIT_INFO 结构。 // 此函数在脚本中只被调用一次,并且要 // 置于所有其他 LRD 函数调用之前。 LRDRET lrd_init ( LRD_INIT_INFO *mptInitInfo, LRD_DEFAULT_DB_VERSION *mpatDefaultDBVersion );
// lrd_initialize_db 函数初始化数据库 // 进程环境。注意,内存回调函数是 // 不受支持的。 LRDRET lrd_initialize_db( unsigned int muiDBType, long mliMode, int miDBErrorSeverity );
51
// lrd_logoff 函数终止由 lrd_logon 或 // lrd_logon_ext 启动的简单数据库会话。 LRDRET lrd_logoff ( void *mppvLRDDBIHandleSvcCtx, int miDBErrorSeverity );
// lrd_logon 函数创建简单登录会话, // 其中的用户名、密码和数据库服务器 // 标识字符串都是 null 终止字符串。 // 只有 Oracle 8.0 和更高版本才支持此函数。 LRDRET lrd_logon (void *mpvLRDDBIHandleEnv, void **mppvLRDDBIHandleSvcCtx, char *mpcUserName, char *mpcPassword, char *mpcServerID, int miDBErrorSeverity);
// lrd_logon_ext 函数通过显式指定 // 长度的用户名、密码和数据库 // 服务器标识字符串创建简单数据库会话。 // 只有 Oracle 8.0 和更高版本 // 才支持此函数。 LRDRET lrd_logon_ext (void const *mpvLRDDBIHandleEnv, void **mppvLRDDBIHandleSvcCtx, char *mpcUserName, long mliUserNameLen, char *mpcPassword, long mliPasswordLen, char *mpcServerID, long mliServerIDLen, int miDBErrorSeverity );
// lrd_msg 函数允许您向日志文件 // output.txt 发送数据库消息。只有 // 当指定消息的类匹配 Log 运行时设置中的 // 设置时,消息才发送给日志文件。例如, // 如果在运行时设置中选择“Brief Log”, // 则只有分配给 brief 类的调式消息才会 // 出现。 LRDRET lrd_msg ( int miMsgClass, char *mpszMsg );
// // // // // // // LRDRET lrd_oci8_to_oci7 ( void* mpvLRDDBIHandleSvcCtx, LRD_CONNECTION** mpptConnection, int miDBErrorSeverity );
// lrd_open_connection 函数设置 LRD_CONNECTION // 结构。在使用 lrd_close_connection 释放该结构之前, // 它是有效的。 LRDRET lrd_open_connection ( LRD_CONNECTION **mpptConnection, unsigned int
函数 lrd_oci8_to_oci7 将现有 Oracle OCI 8
连接 mpptConnectionconverts 转换为 Oracle OCI 7 连接。脚本将使用 OCI 7 连接通过执行 OCI 7 和 OCI 8 操作来继续运行。此函数修改现有
连接 mpptConnection 并且不创建任何与数据库的 新的连接。
52
muiDBType, char *mpszUser, char *mpszPassword, char *mpszServer, char *mpszExtConnectStr, LRD_CONTEXT *mptContext, long mliOption, int miDBErrorSeverity );
// lrd_open_context 函数打开 ctlib 函数的上下文。 LRDRET lrd_open_context ( LRD_CONTEXT **mpptContext, unsigned int muiDBType, long mliLibVersionBehavior, unsigned int muiOption, int miDBErrorSeverity );
// lrd_open_cursor 函数通过设置 LRD_CURSOR // 结构打开光标。您可以使用单个光标执行后续 SQL // 语句。在使用 lrd_close_cursor 释放该结构之前, // 它是有效的。 LRDRET lrd_open_cursor ( LRD_CURSOR **mpptCursor, LRD_CONNECTION *mptConnection, int miDBErrorSeverity );
// lrd_option 函数将值分配给 LRD // 选项 (LRD_OPTION_) 之一。 LRDRET lrd_option ( unsigned long muliOption, void *mpvOptionValue );
// lrd_ora8_attr_set 函数设置 LRDDBI 句柄 // 的属性。在使用 lrd_handle_alloc 调用此 // 函数前必须显式分配句柄。只有 Oracle 8.0 和 // 更高版本才支持此函数。 LRDRET lrd_ora8_attr_set ( void *mpvLRDDBIHandleTarget, long mliAttrType, void *mpvValue, long mliValueLen, int miDBErrorSeverity );
// lrd_ora8_attr_set_from_handle 函数设置 // LRDDBI 句柄的属性。在使用 lrd_handle_alloc // 调用此函数之前,必须显式地分配句柄。 // 只有 Oracle 8.0 和更高版本才支持此函数。 // LRDRET lrd_ora8_attr_set_from_handle ( void *mpvLRDDBIHandleTarget, long mliAttrType, void *mpvValue, long mliValueLen, int miDBErrorSeverity );
// lrd_ora8_attr_set_literal 函数 // 设置 LRDDBI 句柄的属性。此函数使用 // 文本字符串指定属性,从而允许其包含 NULL // 字符。 LRDRET lrd_ora8_attr_set_literal ( void *mpvLRDDBIHandleTarget, long mliAttrType, void *mpvValue, int miDBErrorSeverity );
// lrd_ora8_bind_col 函数将主机变量 // 绑定到输出列。VuGen 为结果集中的所有列生成 // lrd_ora8_bind_col 语句。 LRDRET lrd_ora8_bind_col (void *mpvLRDDBIHandleStmt, void
53
**mppvLRDDBIHandleDefine, int muiColNum, LRD_VAR_DESC *mptVarDesc, long mliMode, int miDBErrorSeverity );
// lrd_ora8_bind_placeholder 函数将 // 主机变量或数组绑定到占位符。此函数要 // 与 lrd_assign 配合使用。 LRDRET lrd_ora8_bind_placeholder (void *mpvLRDDBIHandleStmt, void **mppvLRDDBIHandleBind, char *mpszPlaceholder, LRD_VAR_DESC *mptVarDesc, unsigned long muliOption, long mliMode, int miDBErrorSeverity );
// lrd_ora8_commit 函数从 Oracle 8.x 客户端 // 的上一保存点提交当前数据库事务。 LRDRET lrd_ora8_commit ( void *ServiceContextHandle, long Mode,
int ErrorSeverity );
// lrd_ora8_exec 函数执行 lrd_stmt 设置 // 的 SQL 语句。此函数重置由 lrd_ora8_stmt 设置 // 的 SQL 语句内容;在每个 lrd_ora8_exec 函数 // 调用之后,您必须提供新的语句(并可选择 // 绑定参数)。 LRDRET lrd_ora8_exec ( void *mpvLRDDBIHandleSvcCtx, char *mpvLRDDBIHandleStmt, unsigned long muliTotalRows, unsigned long muliSkipRows, unsigned long *mpuliRowsProcessed, LRD_ORA8_PRINT_ROW_TYPEDEF mpfjPrintRow, void *Reserved1, void *Reserved2, long mliMode, int miDBErrorSeverity );
// lrd_ora8_fetch 函数从结果集中 // 提取后续若干行。在录制的脚本中,结果集 // 中的行数是参数 mliRequestedRows 的 // 绝对值。例如,如果 lrd_ora8_fetch 的 // 第二个参数是 -14,则检索了十四 // 行数据。 LRDRET lrd_ora8_fetch (void *mpvLRDDBIHandleStmt, long mliRequestedRows, long mliRowsBatchSize, unsigned long *mpuliFetchedRows, LRD_PRINT_ROW_TYPEDEF mpfjPrintRow, long mliOrientation, long mliMode, int miDBErrorSeverity );
// lrd_ora8_handle_alloc 函数分配 // 并初始化 LRDBI 句柄。句柄类型只由 // 限定符指定。限定符是 LRD_HTYPE_ORACLE_ 字符串 // 的唯一后缀。例如,在 LRD_HTYPE_ORACLE_SESSION 中, // 限定符是“SESSION”。 LRDRET lrd_ora8_handle_alloc ( void const * mpvParentHandle, long const mliDBHandleType, void * * const mppvLRDDBIHandle, int const miDBErrorSeverity );
// lrd_ora8_lob_read 函数在大对象 // (LOB) 描述符已从数据库中提取后,从该
54
// 描述符中读取字符。注意,lrd_ora8_lob_read // 读取的字符无法被访问。此函数用于增加 // Oracle 服务器的负载并模拟现实的服务器 // 活动。
LRDRET lrd_ora8_lob_read ( void * const mpvLRDDBIHandleSvcCtx, void * const mpvLRDDBIHandleLob, unsigned long const mjAmtToRead, unsigned long * const mpjAmtRead, unsigned long const mjOffset, unsigned long const mjBufl, unsigned short const mjCsid, unsigned char const mjCsfrm, int const miDBErrorSeverity);
// lrd_ora8_rollback 函数将当前数据库事务回 // 滚到 Oracle 8.x 客户端的上一保存点。 LRDRET lrd_ora8_rollback ( void *const ServiceContextHandle, long const Mode, ErrorSeverity );
int const
// lrd_ora8_save_col 函数保存指定 // 表单元格的动态值并将其分配给参数。 // 在 Vuser 脚本中,此函数用于关联 // 语句和其他 SQL 语句。不使用在查询 // 期间提取的实际结果,而是使用参数 // 替换常量值。然后,此参数可由同一 // 脚本中的其他数据库语句使用。注意, // lrd_ora8_save_col 总是置于 // lrd_ora8_fetch 语句之前。 LRDRET lrd_ora8_save_col (void *mpvLRDDBIHandleStmt, unsigned int muiColNum, long mliRowNum, unsigned long muliOption, char *mpszParamName );
// lrd_ora8_stmt 函数准备用于执行的 SQL // 或 PL/SQL 语句。语句的文本是 null 终止 // 字符串,在该字符串中没有任何 null 字符。 // (对于包含 null 字符的字符串,请使用 // lrd_ora8_stmt_literal 或 lrd_ora8_stmt_ext。) LRDRET lrd_ora8_stmt (void *mpvLRDDBIHandleStmt, char *mpcStmtText, long mliLanguage, long mliMode, int miDBErrorSeverity );
// lrd_ora8_stmt_ext 函数准备 // 用于执行的 SQL 或 PL/SQL 语句。 // 语句文本是由地址和显式长度指定的。 // 文本可以包含 null 字符,并且应该 // 由 null 字符终止。lrd_ora8_stmt_ext // 可用于可能包含嵌入 null 字符的动态 // 构造存储区域。 LRDRET lrd_ora8_stmt_ext (void *mpvLRDDBIHandleStmt, char *mpcStmtText, long mliStmtTextLen, long mliLanguage, long mliMode, int miDBErrorSeverity );
55
// lrd_ora8_stmt_literal 函数准备 // 用于执行的文字 SQL 或 PL/SQL 语句。 // lrd_ora8_stmt_ext 可用于包含 // 嵌入 null 字符的字符串常量。语句的 // 长度由公式 sizeof()-1 确定。 LRDRET lrd_ora8_stmt_literal (void *mpvLRDDBIHandleStmt, char *mpcStmtText, long mliLanguage, long mliMode, int miDBErrorSeverity );
// 在自动提取中,数据由 exec 命令提取, // 所以组合提取与输出的 lrd_fetch 是 // 不适用的。lrd_print 使用指向 // bympfjPrintRow 的函数输出行。 LRDRET lrd_print ( LRD_CURSOR *mptCursor mptCursor, LRD_PRINT_ROW_TYPEDEF mpfjPrintRow );
// lrd_reset_rows 函数为使用 ODBC SqlSetPos 函数 // 的 UPDATE 操作准备可供提取的行。 LRDRET lrd_reset_rows ( LRD_CURSOR *mptCursor, long mliRowIndex );
// lrd_result_set 函数准备用于 // 通过光标输出字符串(通常为 SQL 语句) // 的下一结果集。对于 CtLib,它发出 ct_result // 命令,并且在 ODBC 中它运行用于当前数据库 // 语句的 SqlMoreResults。 LRDRET lrd_result_set (LRD_CURSOR *mptCursor, long mliOpt1, long mliOpt2, int miDBErrorSeverity );
// lrd_result_set_ext 函数准备 // 用于通过光标输出字符串(通常为 SQL 语句) // 的下一结果集。它发出用于当前数据库 // 语句的 ct_result。 LRDRET lrd_result_set_ext ( LRD_CURSOR *mptCursor, long mliOpt1, long mliOpt2, long *mpliReturnCode, long *mpliResultType, int miDBErrorSeverity );
// lrd_rollback 函数将当前数据库 // 事务回滚到上一保存点。 LRDRET lrd_rollback ( LRD_CONTEXT *mptContext, LRD_CONNECTION *mptConnection, int miDBErrorSeverity );
// lrd_row_count 函数返回 // 受到 UPDATE、DELETE 或 INSERT 语句影响的行数。 // 只有 ODBC 和 DB2 Vuser 才支持它。 LRDRET lrd_row_count ( LRD_CURSOR * mptCursor, long * mpliRowCount, int miDBErrorSeverity );
56
// lrd_save_col 函数保存指定 // 表单元格的动态值并将其分配给某 // 参数。在 Vuser 脚本中,此函数 // 用于关联语句和其他 SQL 语句。不 // 使用在查询期间提取的实际结果,而是 // 使用参数替换常量值。然后,此参数 // 可由同一脚本中的其他数据库 // 语句使用。注意,lrd_save_col 总是 // 置于 lrd_fetch 语句之前。 LRDRET lrd_save_col ( LRD_CURSOR *mptCursor, unsigned int muiColNum, long mliRowNum, unsigned long muliOption, char *mpszParamName );
// lrd_save_last_rowid 函数将当前结果集 // 最后一行的 rowid 保存到参数中。最后的 rowid 值 // 可用在该脚本的稍后位置。 LRDRET lrd_save_last_rowid ( LRD_CURSOR *mptCursor,
char *mpszParamName );
// lrd_save_ret_param 函数将存储 // 过程的返回参数的值保存到参数中。 // 如果函数无法检索返回参数,该 // 参数将标记为未初始化。此函数用于关联 // 数据库语句。 LRDRET lrd_save_ret_param ( LRD_CURSOR *mptCursor, unsigned int muiRetParamNum, unsigned long muliOption, char *mpszParamName );
// lrd_save_value 函数保存占位符 // 描述符的动态值。此函数 // 用于设置输出占位符(例如,Oracle 中 // 的某些存储过程)的关联数据库语句。 // 在同一脚本中,此动态保存的值 // 可由其他数据库语句使用。注意,lrd_save_value 总是 // 跟随在 lrd_exec 语句之后。 LRDRET lrd_save_value ( LRD_VAR_DESC *mptVarDesc, unsigned long muIiIndex, unsigned long muliOption, char *mpszParamName );
// lrd_send_data 函数将某数据块 // 发送给服务器。数据的位置由 // 请求规范字符串 mpszReqSpec 指定。 // 此 null 终止字符串包含关键字及其值的列表。 LRDRET lrd_send_data ( LRD_CURSOR *mptCursor, unsigned int muiUnused, unsigned long muliIODescNum, char *mpszReqSpec, LRD_VAR_DESC *mptVarDesc, int miDBErrorSeverity );
57
// lrd_server_detach 函数删除 // 用于数据库操作的数据源的访问路径。只有 Oracle 8.0 和 // 更高版本才支持此函数。 LRDRET lrd_server_detach ( void const * mpvLRDDBIHandleServer, long const mliMode, int const miDBErrorSeverity );
// lrd_session_begin 函数启动 // 服务器的用户会话。只有 Oracle 8.0 和 // 更高版本才支持此函数。 LRDRET lrd_session_begin ( void *mpvLRDDBIHandleSvcCtx, void *mpvLRDDBIHandleSession, unsigned long muliCredentials, long mliMode, int miDBErrorSeverity );
// lrd_session_end 函数结束服务器的用户会话。 // 只有 Oracle 8.0 和更高版本才支持此函数。 LRDRET lrd_session_end ( void const *mpvLRDDBIHandleSvcCtx, void const
*mpvLRDDBIHandleSession, long const mliMode,
// lrd_siebel_incr 函数按指定 // 值递增字符串(由数值表示)。在该函数 // 递增字符串后,它将字符串写回到原 // 内存位置。表示字符串的数值 // 以 36 为基。Siebel 使用以 36 为基的 // 算法,使用从 0 到 9 的数字或 // 从 A 到 Z 的字母(对应于 10 到 35)表示 // 数值。
int const miDBErrorSeverity );
LRDRET lrd_siebel_incr (char *string, int increment );
// lrd_siebel_str2num 用于自动的 Siebel 关联。 LRDRET lrd_siebel_str2num (const char *szString);
// {0>The lrd_stmt function associates a character string<}72{>?lrd_stmt 函数将字符串(通常 <0) // 为 SQL 语句}与光标相关联。如果一个 lrd_stmt 函数 // 之后跟随有另一个(两者之间没有 lrd_exec),
// 则这些字符串将被连接。 // 注意,单个光标可以支持多个连续 // 的 SQL 语句。虽然可以将 SQL 语句 // 文本拆分为若干个段,但无法拆分 // 占位符标识符。 LRDRET lrd_stmt (LRD_CURSOR *mptCursor, char *mpcText, long mliTextLen, LRDOS_INT4 mjOpt1, LRDOS_INT4 mjOpt2, int miDBErrorSeverity );
// lrd_to_printable 函数将变量
58
// 或数组元素转换为可打印字符串。 // 在录制期间,将在脚本目录的 print.inl 文件 // 中生成此函数。它提供了有关如何在 VuGen 的 // 网格中显示结果的信息。 LRDRET lrd_to_printable ( LRD_VAR_DESC *mptVarDesc, unsigned long muliIndex, char *mpszOutputStr, unsigned long muliOutputStrSize, char *mpszOutputStrFmt );
// SiebelPreSave_x 函数指示, // 在对 2 层 Siebel 调用 lrd_fetch 或 lrd_ora8_fetch 之前, // 需要为自动关联保存哪些 Siebel 参数。 int SiebelPreSave_x(void);
// SiebelPostSave_x 函数在对 2 层 // Siebel 调用 lrd_fetch 或 lrd_ora8_fetch 之后 // 保存以后的 Siebel 参数的值。 int SiebelPostSave_x(void);
// ms_dns_query 函数使用 // 域名服务 (DNS) 解析指定主机名的 IP 地址。 // 此函数不会自动将域添加到主机名(需要您显式 // 包含该域)。 char * ms_dns_query( char *transaction, char *dnsserver, [char *query_host,] [char *local_address,] LAST );
// ms_dns_nextresult 函数在 IP 地址列表 // (由 ms_dns_query 返回)中查询下一个 IP 地址。 char* ms_dns_nextresult (char *ipaddresslist);
// ftp_delete 函数从 FTP 服务器中删除文件。 int ftp_delete (char *transaction, char *item_list, LAST);
// ftp_delete_ex 函数针对指定会话 // 从 FTP 服务器中删除文件。 int ftp_delete_ex (FTP *ppftp, char *transaction, char *item_list, LAST);
// ftp_dir 函数在 FTP 服务器上运行 dir 命令。 int ftp_dir (char *transaction, char *item_list, LAST);
// ftp_dir_ex 函数针对指定会话在 FTP // 服务器上运行 dir 命令。 int ftp_dir_ex (FTP *ppftp, char *transaction, <List of Attributes>, LAST);
// ftp_get 函数在 FTP 服务器上设置工作目录。 int ftp_get (char *transaction, char *item_list, LAST);
59
// ftp_get_last_download_details 获取 // 上次下载的统计信息。它以毫秒 // 为单位将总计下载持续时间分配给 pDuration 指向 // 的长整型变量。此持续时间包括实际传输时间和 // 连接开销。 int ftp_get_last_download_details ( unsigned long * pByteCount, unsigned long *pDuration);
// ftp_get_last_download_details_ex 获取 // 会话中上次下载的统计信息。 // 它以毫秒为单位将总计下载持续时间 // 分配给 pDuration 指向的长整型变量。 // 此持续时间包括实际传输时间和连接开销。 int ftp_get_last_download_details_ex (FTP *ppFtp, unsigned long * pByteCount, unsigned long * pDuration);
// ftp_get_ex 函数针对指定会话在 FTP 服务器 // 上设置工作目录。 int ftp_get_ex (FTP *ppftp, char *transaction, char *item_list, LAST);
// ftp_get_last_error 函数返回 FTP 会话 // 期间发生的最后一次错误。 char * ftp_get_last_error (FTP *ppftp);
// ftp_get_last_error_id 函数 // 返回在指定 FTP 会话期间发生的 // 最后一次错误的 ID 编号。 int ftp_get_last_error_id (FTP *ppftp);
// ftp_get_last_handshake_duration 以毫秒为单位返回最后一次 // 连接创建的持续时间。 double ftp_get_last_handshake_duration ();
// ftp_get_last_handshake_duration_ex 以毫秒为单位返回会话中 // 最后一次连接创建的持续时间。 double ftp_get_last_handshake_duration_ex (FTP *ppFtp);
// ftp_get_last_transfer_duration 以毫秒 // 为单位返回最后一次 get 命令的净传输时间。 // 净传输持续时间不包括连接开销。 double ftp_get_last_transfer_duration ();
// ftp_get_last_transfer_duration_ex 以 // 毫秒为单位返回此会话最后一次 get 命令
60
// 的净传输时间。净传输持续时间不包括 // 连接开销。 double ftp_get_last_transfer_duration_ex (FTP *ppftp);
// ftp_logon 函数执行登录到 FTP 服务器的操作。 int ftp_logon ( char *transaction, char *url, LAST);
// ftp_logon_ex 函数针对特定会话登录到 FTP 服务器。 int ftp_logon_ex (FTP *ppftp, char *transaction, char *url, LAST);
// ftp_logon 函数执行从 FTP 服务器注销的操作。 int ftp_logout ( );
// ftp_logout_ex 函数针对特定会话 // 从 FTP 服务器注销。 int ftp_logout_ex (FTP *ppftp);
// ftp_mkdir 函数在 FTP 服务器上设置工作目录。 int ftp_mkdir(char *transaction, char * path);
// ftp_mkdir_ex 函数针对指定会话 // 在 FTP 服务器上设置工作目录。 int ftp_mkdir_ex(FTP *ppftp, char *transaction, char * path);
// ftp_put 函数在 FTP 服务器上设置工作目录。 int ftp_put ( char *transaction, char *item_list, LAST);
// ftp_put_ex 函数针对指定会话 // 在 FTP 服务器上设置工作目录。 int ftp_put_ex (FTP *ppftp, char *transaction, char *item_list, LAST);
// ftp_rendir 函数重命名 FTP 服务器上的文件或目录。 int ftp_rendir (char *transaction, <item list>, LAST);
// 在下列示例中,ftp_rendir_ex 函数针对指定会话 // 重命名 FTP 服务器上的文件或目录。 int ftp_rendir_ex (FTP *ppftp, char *transaction, ITEM LIST, LAST);
// ftp_rmdir 函数重命名 FTP 服务器上的目录。 int ftp_rmdir (const char *transaction, const char * path);
// ftp_rmdir_ex 函数针对指定会话 // 删除 FTP 服务器上的目录。 int ftp_rmdir_ex (FTP *ppftp, const char *transaction, const char *path);
61
// imap_logon 函数通过身份验证信息(使用纯文本用户名和密码) // 登录到 IMAP 服务器。 int imap_logon(char *transaction, char *url, char *certificate, char *key, char *password, LAST);
// imap_logon_ex 函数针对特定会话 // 登录到 MS Exchange 服务器。它使用 // 简单 IMAP(MS Exchange 协议)执行登录。 int imap_logon_ex(IMAP *ppimap, char *transaction, char *url, char *certificate, char *key, char *password, LAST);
// imap_logout 函数从 IMAP 服务器注销。 int imap_logout( );
// imap_logout_ex 函数针对特定会话 // 从 IMAP 服务器注销。 int imap_logout_ex(IMAP *ppimap);
// imap_free_ex 函数释放 IMAP 会话描述符。 // 在从 IMAP 服务器注销后调用此函数。 int imap_free_ex(IMAP *ppimap);
// imap_get_result 函数获取 IMAP 服 // 务器返回代码。使用此函数可确定 // 由 IMAP 服务器发出的有关以前的 IMAP 函数的精确错误 // 代码。 int imap_get_result( );
// imap_get_result_ex 函数获取 // 指定服务器会话的 IMAP 服务器返回代码。 // 使用此函数可确定由 IMAP 服务器发出的有关以前的 IMAP 函数 // 的错误代码。 int imap_get_result_ex(IMAP *ppimap);
// imap_select 函数选择 // 邮箱以访问其邮件。调用此函数 // 将修改邮箱状态(未读邮件数、邮件 // 总数,等等)。若要检索邮箱属性,请调用 // imap_get_attribute_int。 int imap_select(char *transaction, char *mailbox, LAST);
// imap_select_ex 函数选择邮箱 // 以访问其邮件。调用此函数将修改 // 邮箱状态(未读邮件数、邮件总数,
62
// 等等)。若要检索邮箱属性, // 请调用 imap_get_attribute_int_ex。 int imap_select_ex (IMAP *ppimap, char *transaction, char *mailbox, LAST);
// imap_examine 函数选择邮箱 // 以查看其邮件。调用此函数不会 // 修改邮箱状态(未读邮件数、邮件总数, // 等等)。 int imap_examine (char *transaction, char *mailbox, LAST);
// imap_examine_ex 函数选择 // 邮箱以查看其邮件。调用 // 此函数不会修改邮箱状态 // (未读邮件数、邮件总数,等等)。 int imap_examine_ex (IMAP *ppimap, char *transaction, char *mailbox, LAST);
// imap_status 函数请求指定 // 邮箱的状态。它既不更改当前 // 选中邮箱,也不影响查询邮箱中任何 // 邮件的状态。请求这些状态 // 后,请使用 imap_get_attribute_int 获取 // 状态值。 int imap_status (char *transaction, char *mailbox, char *item, LAST);
// imap_status_ex 函数请求 // 指定邮箱的状态。它既不 // 更改当前选中邮箱,也不影响查询 // 邮箱中任何邮件的状态。请求 // 这些状态后,可使用 imap_get_attribute_int_ex 读取 // 状态值。 int imap_status_ex (IMAP *ppimap, char *transaction, char *mailbox, char *item, LAST);
// imap_list_mailboxes 函数列出 // 客户端可使用的邮箱。回复中包含名称属性、 // 层次结构分隔符和邮箱名称。 int imap_list_mailboxes(char *transaction, char *reference, char *name, LAST);
// imap_list_mailboxes_ex 函数列出 // 客户端可使用的邮箱。回复中包含名称属性、 // 层次结构分隔符和邮箱名称。 int imap_list_mailboxes_ex (IMAP *ppimap, char *transaction, char *reference, char *name, LAST);
// imap_list_subscriptions 函数列出
63
// 对客户端声明为订阅或活动的邮箱。 // 回复中包含名称属性、层次结构分隔符和 // 邮箱名称。 int imap_list_subscriptions (char *transaction, char *reference, char *name, LAST);
// imap_list_subscriptions_ex 函数 // 列出对客户端声明为订阅或活动的邮箱。 // 回复中包含名称属性、层次结构分隔符和 // 邮箱名称。 int imap_list_subscriptions_ex (IMAP *ppimap, char *transaction, char *reference, char *name, LAST);
// imap_subscribe 函数将指定 // 邮箱设置为订阅或活动的。若要检索具有订阅 // 的邮箱列表,请调用 imap_list_subscriptions。 int imap_subscribe(char *transaction, char *mailbox, LAST);
// imap_subscribe_ex 函数将指定 // 邮箱设置为订阅或活动的。若要 // 检索具有订阅的邮箱列表,请调用 // imap_list_subscriptions_ex。 int imap_subscribe_ex (IMAP *ppimap, char *transaction, char *mailbox, LAST);
// imap_unsubscribe 函数取消 // 对指定邮箱的订阅。取消订阅 // 命令将从服务器的“活动”或“订阅” // 邮箱集中删除指定邮箱名称。 int imap_unsubscribe(char *transaction, char *mailbox, LAST);
// imap_unsubscribe_ex 函数取消 // 对指定邮箱的订阅。取消订阅 // 命令将从服务器的“活动”或“订阅”邮箱 // 集中删除指定邮箱名称。 int imap_unsubscribe_ex (IMAP *ppimap, char *transaction, char *mailbox, LAST);
// imap_expunge 函数使用指定 // 函数删除 IMAP 服务器上的邮件。 int imap_expunge(char *transaction, char *method, [char *message,] LAST);
// imap_expunge_ex 函数针对特定会话 // 从 IMAP 服务器上永久删除邮件。 int imap_expunge_ex(IMAP *ppimap, char *transaction, char *method, [char *message,] LAST);
// imap_store 函数更改与当前
64
// 邮箱中的指定邮件相关的标志。 // 可以更改所有标志、在现有标志上添加 // 标志或删除标志。 int imap_store(char *transaction, char *method, char *message, char *action, ENDITEM, LAST);
// imap_store_ex 函数更改 // 与当前邮箱中的指定邮件相关的标志。 // 可以更改所有标志、在现有标志上 // 添加标志或删除标志。 int imap_store_ex (IMAP *ppimap, char *transaction, char *method, char *message, char *action, ENDITEM, LAST);
// imap_copy 函数将消息 // 从当前邮箱复制到另一邮箱中。 // 可以指定复制单个邮件或某个范围的邮件。 // 如果目标邮箱不存在,服务器将返回错误。 int imap_copy(char *transaction, char *message, char *mailbox, ENDITEM, LAST);
// imap_copy_ex 函数将消息从 // 当前邮箱复制到另一邮箱中。可以指定 // 复制单个邮件或某个范围的邮件。如果目标 // 邮箱不存在,服务器将返回错误。 int imap_copy_ex (IMAP *ppimap, char *transaction, char *message, char *mailbox, ENDITEM, LAST);
// imap_fetch 函数针对特定会话 // 检索与邮箱邮件相关联的数据。 // 可以请求任何邮件数据值, // 包括标志、标题和邮件 ID。 int imap_fetch (char *transaction, char *mode, char *message, ENDITEM, LAST);
// imap_fetch_ex 函数针对特定会话 // 检索与邮箱邮件相关联的数据。 // 可以请求任何邮件数据值,包括标志、 // 标题和邮件 ID。 int imap_fetch_ex (IMAP *ppimap, char *transaction, char *mode, char *message, char *saveto, ENDITEM, LAST);
// imap_search 函数搜索 // 邮箱以查找与搜索标准匹配的邮件。 // 搜索标准可以由一个或多个搜索项组成。 int imap_search (char *transaction, char *key, char *param, char * saveto, ENDITEM, LAST);
// imap_search_ex 函数搜索邮箱
65
// 以查找与搜索标准匹配的邮件。搜索标准 // 可以由一个或多个搜索项组成。 int imap_search_ex (IMAP *ppimap, char *transaction, char *key, char *param, ENDITEM, LAST);
// 使用 imap_set_max_param_len 设置 // 用于将邮件作为参数存储的缓冲区的 // 最大大小。该函数要在将邮件保存到参数的函数 // (imap_fetch 和 imap_search)之前被调用。 int imap_set_max_param_len ( char *size );
// 使用 imap_set_max_param_len_ex 设置用于 // 将邮件作为参数存储的缓冲区的最大大小。 // 该函数要在将邮件保存到参数 // 的函数(imap_fetch 和 imap_search)之前被调用。 int imap_set_max_param_len_ex ( IMAP *ppimap, char *size );
// imap_append 函数将文本表达式 // 作为新邮件追加到指定邮箱的末尾。 int imap_append (char *transaction, char *message, char *flag, char *mailbox, ENDITEM, LAST);
// imap_append_ex 函数将文本表达式 // 作为新邮件追加到指定邮箱的末尾。 int imap_append_ex (IMAP *ppimap, char *transaction, char *message, char *flag, char *mailbox, ENDITEM, LAST);
// imap_create 函数创建新的邮箱。 int imap_create(char *transaction, char *mailbox, LAST);
// imap_create_ex 函数针对特定会话创建新邮箱。 int imap_create_ex (IMAP *ppimap, char *transaction, char *mailbox, LAST);
// imap_delete 函数删除现有邮箱。 int imap_delete(char *transaction, char *mailbox, LAST);
// imap_delete_ex 函数针对特定会话 // 删除现有邮箱。 int imap_delete_ex (IMAP *ppimap, char *transaction, char *mailbox, LAST);
// imap_noop 函数在邮箱上执行 noop 操作。 // 这对于测试网络非常有用。 int imap_noop(char *transaction);
66
// imap_noop_ex 函数在指定 IMAP 会话 // 的邮箱上执行 noop 操作。 // 这对于测试网络非常有用。 int imap_noop_ex (IMAP *ppimap, char *transaction);
// imap_check 函数在当前 // 邮箱中请求检查点。检查点涉及任何依赖于 // 实现并适用于邮箱内部的内务管理。 int imap_check (char *transaction);
// imap_check_ex 函数在指定 IMAP 会话 // 的当前邮箱中请求检查点。检查点 // 涉及任何依赖于实现并适用于邮箱内部的 // 内务管理。 int imap_check_ex (IMAP *ppimap, char *transaction);
// imap_close 函数将设置 // 有 \Deleted 标记的所有邮件从 // 当前邮箱中永远删除。它将邮件从 // 选中状态返回到身份验证状态。 // 当前选中邮箱将关闭。 int imap_close(char *transaction, char *mailbox, LAST);
// imap_close_ex 函数针对特定会话将 // 设置有 \Deleted 标记的所有邮件 // 从当前邮箱中永久删除。 // 它将邮件从选中状态返回到身份验证状态。 // 当前选中的邮箱将被关闭。
int imap_close_ex (IMAP *ppimap, char *transaction, char *mailbox, LAST);
// imap_custom_request 函数执行 // 自定义的 IMAP 请求。此函数对于 // 处理未包含在 IMAP4rev1 协议规范中、特定 // 于 IMAP 服务器的扩展非常有用。 int imap_custom_request (char *transaction, char *operation, char *arguments );
// imap_custom_request_ex 函数针对特定会话 // 执行自定义的 IMAP 请求。此函数对于 // 处理未包含在 IMAP4rev1 协议规范中、特定 // 于 IMAP 服务器的扩展非常有用。 int imap_custom_request_ex (IMAP *ppimap, char *transaction, char *operation, char *arguments);
// imap_get_attribute_int 函数将 IMAP 会话
67
// 属性的值作为 integer 类型值返回。 int imap_get_attribute_int(char *property);
// imap_get_attribute_int_ex 函数针对特定会话将 IMAP 属性的 // 值作为 integer 类型值返回。 int imap_get_attribute_int_ex(IMAP *ppimap, char *attribute);
// imap_get_attribute_sz 函数将 IMAP 会话 // 属性的值作为字符串返回。 char *imap_get_attribute_sz(char *property);
// imap_get_attribute_sz_ex 函数针对特定会话 // 将 IMAP 属性的值作为字符串返回。 char *imap_get_attribute_sz_ex(IMAP *ppimap, char *attribute);
// mldap_add 函数向 LDAP 目录中添加条目。 int mldap_add (char *transaction, char *dn, <List of Attributes>, LAST);
// mldap_add_ex 函数针对特定会话 // 向 LDAP 目录中添加条目。 int mldap_add_ex (MLDAP *pldap, char *transaction, char *dn, <List of Attributes>, LAST);
// mldap_delete 函数删除条目或条目的属性。 // 如果指定条目名称,该条目将被删除。 // 如果指定属性名称,则只有该属性 // 被删除。
int mldap_delete (char *transaction, char *dn, LAST);
// mldap_delete_ex 函数针对指定会话 // 从 LDAP 服务器删除文件。 int mldap_delete_ex (MLDAP *pldap, char *transaction, char *dn, LAST);
// mldap_get_attrib_name 函数检索 // 指定属性索引的属性名。可以选择 // 将此名称保存为参数。 char * mldap_get_attrib_name (char *transaction, char *index, [char *param,] LAST);
// mldap_get_attrib_name_ex 函数检索 // 指定会话的指定索引的属性名。 // 可以选择将此名称保存为参数。 char * mldap_get_attrib_name_ex (MLDAP *pldap, char *transaction, char *index, *param,] LAST);
// mldap_get_attrib_value 函数检索
[char
68
// 当前条目的属性值。既可以 // 指定属性的索引,也可以指定 // 属性的名称。默认情况下, // 如果不指定任何值,函数将 // 返回第一个属性的值。可选的 offset 参数允 // 许您获取第一个属性之外的其他属性的值。 // 例如,如果属性具有多个值,offset 为 0 将返回第一个值, // offset 为 1 将返回第二个值,依此类推。 char * mldap_get_attrib_value (char *transaction, char *name, char *index, [char *offset,] [char *param,] LAST);
// mldap_get_attrib_value_ex 函数检索 // 指定会话指定属性的值。既可以指定 // 属性的索引,也可以指定属性的名称。 // 默认情况下,如果不指定任何值,函数将返回 // 第一个属性的值。可选的 offset 参数 // 允许您获取第一个属性之外的其他属性 // 的值。例如,如果属性具有多个值, // offset 为 0 将返回第一个值,offset 为 1 将返回第二个值, // 依此类推。 // 1 would return the second, etc. char * mldap_get_attrib_value_ex (MLDAP *pldap, char *transaction, char *name, char *index, [char *offset,] [char *param,] LAST);
// mldap_get_next_entry 函数显示作为 // 搜索结果的下一条目。对于异步搜索, // 此函数检索并显示条目;对于同步搜索, // 它只显示下一条目。函数返回 DN 条目的名称, // 但您也可以命令该函数将其 // 保存为参数。如果没有其他条目,或者如果在检索 // 项目时发生错误,函数将 // 返回 NULL。 char * mldap_get_next_entry (char *transaction, [char *timeout,] [char *param,] LAST);
// mldap_get_next_entry_ex 函数显示 // 作为指定会话的搜索结果的下一 // 条目。对于异步搜索,此函数检索 // 并显示条目;对于同步搜索,它只显示 // 下一条目。函数返回 DN 条目的名称, // 但您也可以命令该函数将其保存为参数。 // 如果没有其他条目,或者如果
// 在检索项目时发生错误,函数将 // 返回 NULL。 char * mldap_get_next_entry_ex (MLDAP *pldap, char *transaction, [char *timeout,] [char
69
*param,] LAST);
// mldap_logon 函数执行登录到 LDAP 服务器的操作。 int mldap_logon (char *transaction, char *url, LAST);
// mldap_logon_ex 函数针对特定会话登录 // 到 LDAP 服务器。 int mldap_logon_ex (MLDAP *pldap, char *transaction, char *url, LAST);
// mldap_logoff 函数执行从 LDAP 服务器注销的操作。 int mldap_logoff ( );
// mldap_logoff_ex 函数针对特定会话 // 从 LDAP 服务器注销。 int mldap_logoff_ex (MLDAP *pldap);
// mldap_modify 函数更改 LDAP 条目 // 属性的值。每个函数只能修改一个条目。 // 若要修改另一个条目的属性,请使用 // 另一个 mldap_modify 函数。 int mldap_modify (char *transaction, char *dn, <List of Attributes>, LAST);
// mldap_modify_ex 函数针对特定会话 // 向 LDAP 目录中添加条目。 int mldap_modify_ex (MLDAP *pldap, char *transaction, char *dn, <List of Attributes>, LAST);
// mldap_rename 函数替换 LDAP 服务器上的 DN // 项。您可以替换一个或多个属性类型。例如, // 如果某雇员更改了名称,您可以更改 // 其 CN 属性。如果某雇员换到了其他部门,
// 您可以更改其 OU 属性。 int mldap_rename (char *transaction, char *dn, char *NewDn, LAST);
// mldap_rename_ex 函数针对特定会话替换 LDAP 服务器上 // 的 DN 项。您可以替换 // 一个或多个属性类型。例如,某雇员 // 更改了名称,您可以更改其 CN 属性。
// 如果某雇员换到了其他部门,您可以 // 更改其 OU 属性。 int mldap_rename_ex (MLDAP *pldap, char *transaction, char *dn, char *NewDn, LAST);
// mldap_search 函数在 LDAP 中搜索 // 特定属性。您指明 VuGen 用作搜索 // 基础的 DN。搜索范围可以是
70
// 基础自身 (base)、基础下一级 (Onelevel) 或 // 基础下的所有级别 (subtree)。您可以 // 指定属性及其值,还可以指定通配符。 // 如果使用通配符,VuGen 将返回指定属性
// 的所有值。 int mldap_search (char *transaction, char *base, char *scope, char *filter, [char *timeout,] [char *mode,] [const char *SaveAsParam,][const char *Attrs,] LAST);
// mldap_search_ex 函数在 LDAP 中搜索 // 特定属性。您指明 VuGen 用作搜索 // 基础的 DN。搜索范围可以是 // 基础自身 (base)、基础下一级 (Onelevel) 或 // 基础下的所有级别 (subtree)。您可以
// 指定属性及其值,还可以指定通配符。 // 如果使用通配符,VuGen 将返回指定属性 // 的所有值。 int mldap_search_ex (MLDAP *pldap, const char *transaction, const char *base, const char *scope, const char *filter, [const char *timeout,] [const char *mode,][const char *SaveAsParam,][const char *Attrs,] LAST);
// mapi_delete_mail 函数删除 MS Exchange 服务器上 // 的当前或选定的电子邮件项。 int mapi_delete_mail(char *transaction, [char *ID,] LAST);
// mapi_delete_mail_ex 函数针对特定会话删除 // MS Exchange 服务器上的邮件。 int mapi_delete_mail_ex(MAPI *ppmapi, char *transaction, [char *ID,] LAST);
// mapi_get_property_sz 函数针对特定会话 // 为 MAPI 属性的值分配缓冲区,并 // 返回指向缓冲区的值。 char* mapi_get_property_sz(char *property);
// mapi_get_property_sz_ex 函数针对特定会话 // 为 MAPI 属性的值分配缓冲区,并 // 返回指向缓冲区的值。 char *mapi_get_property_sz_ex(MAPI *ppmapi, char *property);
// mapi_logon 函数使用简单 MAPI(一种 // MS Exchange 协议)登录到 MS Exchange 服务器。 int mapi_logon(char *transaction, char *profilename, char *profilepass, NULL);
// mapi_logon_ex 针对特定会话登录到 // MS Exchange 服务器。它使用简单 MAPI(一种 MS Exchange
71
// 协议)执行登录。 int mapi_logon_ex (MAPI *ppmapi, char *transaction, char *profilename, NULL);
// mapi_logout 函数从 MS Exchange 服务器注销。 int mapi_logout( );
// mapi_logout_ex 函数针对特定函数 // 从 MAPI 服务器注销。 int mapi_logout_ex(MAPI *ppmapi);
char *profilepass,
// mapi_read_next_mail 函数使用 MAPI 服务器读取 // 邮件。使用 Peek 选项,可以控制 // 是否将邮件标记为“已读”或“未读”。 int mapi_read_next_mail(char *transaction, char *Show, [char *options,] LAST);
// mapi_read_next_mail_ex 函数针对 // 指定会话读取邮箱中的下一封邮件 // 消息。使用 Peek 选项,可以控制是否 // 将邮件标记为“已读”或“未读”。 int mapi_read_next_mail_ex( MAPI *ppmapi, char *transaction, char *Show, [char *Peek,] [char *Type,] [char *Save,] [char *MessageId,] LAST );
// mapi_send_mail 函数使用 MAPI 服务器发送邮件消息。 int mapi_send_mail(char *transaction, char *To, [char *CC,] [char *BCC,] [char *Subject,] [char *Type,] [char *Body,] [ATTACHMENTS,] LAST);
// mapi_send_mail_ex 函数针对指定会话 // 使用 MAPI 服务器发送邮件消息。 int mapi_send_mail_ex(MAPI *ppmapi, char *transaction, char *To, [char *CC,] [char *BCC,] [char *Subject,] [char *Type,] [char *Body,] [ATTACHMENTS,] LAST);
// mapi_set_property_sz 函数设置 MAPI 会话属性值。 void mapi_set_property_sz(char *property, char *value );
// mapi_set_property_sz_ex 函数针对特定会话 // 设置 MAPI 会话属性值。 void mapi_set_property_sz_ex(MAPI *ppmapi, char *property, char *value);
// mms_close 函数关闭现有媒体播放器 // 会话。此函数仅对活动的播放器会话 // 有效。只有使用持续时间标记,而非 –1(无穷) // 调用 mms_play 时(流传输尚未完成),播放器会话 // 才会处于活动状态。
72
int mms_close( );
// mms_close_ex 函数关闭指定的媒体 // 播放器会话。此函数仅对活动播放器 // 会话有效。只有使用持续时间标记, // 而非 –1(无穷)调用 mms_play 时(流传输尚未完成), // 播放器会话才会处于活动 // 状态。 int mms_close_ex(MMS *ppmms);
// mms_get_property 函数检索当前 // 媒体剪辑的属性。 double mms_get_property(int property);
// mms_get_property_ex 函数检索当前 // 媒体剪辑的属性。用于特定会话。 double mms_get_property_ex (MMS *ppmms, int property);
// mms_set_property 函数设置媒体播放器剪辑属性。 int mms_set_property(int property, char *value);
// mms_set_property_ex 函数针对特定会话 // 设置媒体剪辑属性。 int mms_set_property_ex(MMS *ppmms, int property, char *value);
// mms_isactive 函数检查 Media Player 是否处于 // 活动状态。它验证 Media Player 是否已打开 // 以及是否正在传入或传出数据。 int mms_isactive( );
// mms_isactive_ex 函数检查 Media Player // 是否处于活动状态。它针对指定会话验证 // 是否打开了 Media Player,以及 // 是否正在传入或传出数据。 int mms_isactive_ex(MMS *ppmms);
// mms_pause 函数暂停媒体播放器剪辑。只有播放持续时间不为负值时,此函数 // 才起作用。 int mms_pause( );
// mms_pause_ex 函数针对指定会话 // 暂停媒体播放器剪辑。只有播放持续时间不为负值时,此函数 // 才起作用。 int mms_pause_ex(MMS *ppmms);
73
// mms_play 函数播放媒体播放器剪辑。如果只 // 希望连接到剪辑并手动控制它,请指定持续时间为 // 0,后面再跟所需的函数。 int mms_play(char *transaction, char *URL, [char *duration,] [char *starttime,] LAST);
// mms_play_ex 函数针对指定会话 // 播放媒体播放器剪辑。 int mms_play_ex(MMS *ppmms, char *transaction, char *URL, [char *duration,] [char *starttime,] LAST);
// 在使用 mms_pause 暂停播放媒体剪辑后, // mms_resume 函数继续播放。只有播放持续时间 // 不为负值时,此函数才起作用。 int mms_resume( DWORD resumetime, DWORD duration);
// 在指定会话中,在使用 mms_pause 暂停播放 // 媒体剪辑后,mms_resume_ex 函数继续 // 播放。只有播放持续时间不为负值时,此函数 // 才起作用。
int mms_resume_ex( MMS *ppmms, DWORD resumetime, DWORD duration);
// mms_sampling 函数通过收集指定 // 持续时间内的统计信息来采样播放媒体剪辑。 // 只有播放持续时间为无限(mms_play 中的 // 持续时间值设为 0)时,此函数才起作用。 int mms_sampling(DWORD duration);
// mms_sampling_ex 函数通过收集 // 指定持续时间内的统计信息来获取 // Media Player 会话采样。只有播放持续时间为无限 // (mms_play_ex 中的持续时间值设为 0)时, // 此函数才起作用。 int mms_sampling_ex(MMS *ppmms, DWORD duration);
// mms_set_timeout 函数设置用于 // 打开或关闭剪辑的 Media Player 超时值。 int mms_set_timeout (int type, int value);
// mms_set_timeout_ex 函数针对特定会话、设置用于 // 打开或关闭剪辑的 Media Player 超时值。 int mms_set_timeout_ex (MMS *ppmms, int type, int value);
// mms_stop 函数停止播放 Media Player
74
// 剪辑。只有播放持续时间为无限(mms_play 中的 // 持续时间值设为 0)时,此函数才起作用。 int mms_stop( );
// mms_stop_ex 函数针对特定会话 // 停止播放媒体播放器剪辑。只有播放持续时间为无限 // (mms_play_ex 中的持续时间值设为 0)时, // 此函数才起作用。 int mms_stop_ex(MMS *ppmms);
// nca_button_double_press 函数两次按指定的 // 推按钮。 int nca_button_double_press (LPCSTR name);
// nca_button_press 函数激活指定的推按钮。 int nca_button_press ( LPCSTR button );
// nca_button_set 函数将按钮状态设置为 ON // 或 OFF。TOGGLE 选项反转当前状态。 int nca_button_set ( LPCSTR button, int istate );
// nca_combo_select_item 函数选择组合框中的项目。 int nca_combo_select_item (LPCSTR name, LPCSTR item_name);
// nca_combo_set_item 函数将 item_name 写入组合框名称。 int nca_combo_set_item ( LPCSTR name, LPCSTR item_name );
// nca_connect_server 函数使用指定的主机、端口号和模块 // 连接到 Oracle NCA 数据库服务器。 int nca_connect_server (LPCSTR host, LPCSTR port, LPCSTR command_line);
// nca_console_get_text 函数检索 // Oracle NCA 控制台消息。 int nca_console_get_text (char *text);
// nca_edit_box_press 函数在编辑框消息上按下。 int nca_edit_box_press (LPCSTR name);
// nca_edit_click 函数在指定编辑对象内单击, // 以便将光标放置在框中。一旦 // 光标位于框中,用户就可以键入值 // 或从值列表中选择一个值。
int nca_edit_click ( LPCSTR edit );
75
// nca_edit_get_text 函数返回在 // 指定的编辑对象中找到的所有文本。 int nca_edit_get_text ( LPCSTR edit, char *out_string );
// nca_edit_press 函数激活编辑字段中的 // “浏览”按钮。这将打开可用值列表。 int nca_edit_press ( LPCSTR edit );
// nca_edit_set 函数将编辑对象的内容设置为 // 指定的字符串。它将替换现有字符串。 int nca_edit_set ( LPCSTR edit, LPCSTR text );
// nca_flex_click_cell 函数在 Flexfield 窗口中的 // 指定表单元格中单击。 int nca_flex_click_cell ( LPCSTR name, LPCSTR row, LPCSTR column);
// nca_flex_get_cell_data 函数获取 Flexfield 中指定单元格 // 的内容,并将其存储在变量中。 int nca_flex_get_cell_data(LPCSTR name, LPCSTR row, LPCSTR column, LPSTR data);
// nca_flex_get_column_name 函数获取 Flexfield 窗口中 // 某列的名称。此函数将列名写入 // 输出参数 column_name。 int nca_flex_get_column_name ( LPCSTR window_name, int column, LPCSTR column_name );
// nca_flex_get_row_name 函数获取 Flexfield 窗口中 // 某行的名称。此函数将行名写入 // 输出参数 row_name。 int nca_flex_get_row_name ( LPCSTR window_name, int row, LPCSTR row_name );
// nca_flex_press_clear 函数按 // 指定 Flexfield 窗口中的“清除”按钮。 int nca_flex_press_clear (LPCSTR name );
// nca_flex_press_find 函数按 // 指定 Flexfield 窗口中的“查找”按钮。 int nca_flex_press_find ( LPCSTR name );
// nca_flex_press_help 函数按指定 // Flexfield 窗口中的“帮助”按钮(问号)。 int nca_flex_press_help ( LPCSTR name );
// nca_flex_press_lov 函数单击 // 指定 Flexfield 窗口中的“值列表”按钮,
76
// 以便显示活动字段的值列表。 int nca_flex_press_lov( LPCSTR name, LPCSTR row, LPCSTR column );
// nca_flex_press_ok 函数按指定 // Flexfield 窗口中的“确定”按钮。 int nca_flex_press_ok ( LPCSTR name );
// nca_flex_set_cell_data 函数设置指定 // Flexfield 窗口中的单元格数据。 int nca_flex_set_cell_data ( LPCSTR name, LPCSTR row, LPCSTR column, LPCSTR data );
// nca_flex_set_cell_data_press_ok 函数在手动 // 向 Flexfield 中输入(而不是从值列表中 // 选择)数据之后按 Flexfield 窗口中的 // “确定”按钮。
int nca_flex_set_cell_data_press_ok ( LPCSTR name, LPCSTR row, LPCSTR column, LPCSTR data );
// exit_oracle_application 函数断开与 // Oracle NCA 数据库服务器的连接,并退出应用程序。 int exit_oracle_application( );
// nca_get_top_window 函数将顶部窗口的名称分配给 // 由 winName 指向的用户分配的缓冲区。 int nca_get_top_window ( char *winName);
// nca_java_action 函数使用指定参数 // 在 Java 对象上执行事件。 int nca_java_action(LPCSTR name, LPCSTR event, LPCSTR arglist);
// 使用 nca_java_delete_name 可以删除用于存储属性的内存 // (这些属性是录制 Java 对象时由 Vugen // 保存的)。只有在 nca_java_set_option 中启用了 // JAVA_SAVE_PROP 选项,Vugen 才会保存 Java 对象。。 int nca_java_delete_name(LPCSTR name, LPCSTR property_name);
// nca_java_get_value 函数检索指定 // Java 对象的值。 int nca_java_get_value(LPCSTR name, char *value );
// nca_java_get_value_ex 检索 Java 对象内指定 // 属性 property_name 的值。 int nca_java_get_value_ex (LPCSTR name, LPCSTR property_name, LPSTR property_value);
77
// nca_java_set_option 函数在录制 Java 对象时设置选项。 int nca_java_set_option(int option, < option value > );
// nca_java_set_reply_property 函数设置 // 指定的 Java 回复属性。 void nca_java_set_reply_property (void * ReplyPropList);
// nca_list_activate_item 函数双击列表中的 // 项目。项目通过其逻辑名称指定。 int nca_list_activate_item ( LPCSTR list, LPCSTR item );
// nca_list_get_text 从列表中检索选定项目并放到 value 中。 int nca_list_get_text( LPCSTR name, char *value );
// nca_list_select_item 函数从列表中 // 选择项目(在项目上执行一次鼠标单击)。 // 项目通过其名称指定。 int nca_list_select_item ( LPCSTR list, LPCSTR item );
// nca_list_select_index_item 函数从列表中 // 选择项目(在项目上执行一次鼠标单击)。该项目 // 通过其数字索引指明。该索引被指定为 // 字符串,起始值为 0。 int nca_list_select_index_item ( LPCSTR list, int index );
// nca_logon_connect 函数执行到 Oracle NCA // 数据库的登录。它使用指定的用户名和密码 // 连接到数据库。 int nca_logon_connect (LPCSTR connection_name, LPCSTR username, LPCSTR password, LPCSTR database);
// nca_logon_cancel 函数取消与 Oracle NCA // 数据库的连接。连接名称通过 // nca_logon_connect 的 connection_name // 参数设置。但是,此函数并不断开与服务器 // 的连接。
int nca_logon_cancel (LPCSTR name);
// nca_lov_auto_select 函数输入一个字母 // 来指明要从值列表中选择的项目的第一个 // 字符。以指定字母开头的项目 // 被选中。如果存在多个以该字母 // 开头的项目,那么所有匹配的值都将显示在列表中, // 您需要从新列表中选择一个
78
// 项目。 int nca_lov_auto_select ( LPCSTR name, char selection );
// nca_lov_find_value 函数查找对象的 // 值列表。当您单击“值列表”窗口中的“查找” // 按钮时,将录制此函数。 int nca_lov_find_value ( LPCSTR name, LPCSTR value );
// nca_lov_get_item_name 函数在值列表中检索 // 某项目的名称,并将其写入该函数 // 的 value 参数。调用该函数之前,必须为值分配足够的 // 内存空间。 int nca_lov_get_item_name ( LPCSTR name, int item_index, char *value);
// nca_lov_retrieve_items 函数基于指定的 // 范围,从值列表中检索项目。该范围 // 通过函数的参数 first_item 和 last_item // 指定,其中“1”表示第一个项目。
int nca_lov_retrieve_items ( LPCSTR name, int first_item, int last_item );
// nca_lov_select_index_item 函数使用项目的索引编号 // 从值列表中选择项目。 int nca_lov_select_index_item ( LPCSTR name, int index );
// nca_lov_select_item 函数从值列表中选择项目。 int nca_lov_select_item ( LPCSTR name, LPCSTR item );
// nca_lov_select_random_item 函数从值列表中 // 选择随机项目。第二个参数是 // 输出参数,用于指明随机选择时 // 选择的是哪个值。
int nca_lov_select_random_item ( LPCSTR name, char *item );
// nca_menu_select_item 函数根据 // 菜单的逻辑名称和项目的名称从菜单中选择 // 项目。注意,菜单和项目表示分别表示为 // 单个字符串,并使用分号分隔。 int nca_menu_select_item ( LPCSTR window, LPCSTR menu;item );
// nca_message_box_press 函数按 // 消息窗口中的指定按钮。该按钮通过其索引指定, // 通常是从左到右 // 的按钮顺序。例如,如果消息框包含 // 三个按钮:“是”、“否”和“取消”,那么相应的
79
// 索引可能为 1、2 和 3。 int nca_message_box_press ( LPCSTR name, int button );
// nca_obj_get_info 函数检索指定属性的值, // 并存储在 out_value 中。 int nca_obj_get_info ( LPCSTR object, LPCSTR property, char *out_value );
// nca_obj_mouse_click 函数在 // 对象内的指定坐标处单击鼠标。 int nca_obj_mouse_click ( LPCSTR object, int x, int y, unsigned char modifier);
// nca_obj_mouse_dbl_click 函数在 // 对象内的指定坐标处双击鼠标。 int nca_obj_mouse_dbl_click ( LPCSTR object, int x, int y, unsigned char modifier);
// nca_obj_status 函数返回指定对象的状态。 int nca_obj_status ( LPCSTR name );
// nca_obj_type 函数指定 keyboard_input 将 // 发送到的对象。此函数录制 // 特殊字符,如 Tab 键、功能键以及 // 快捷键组合。
int nca_obj_type ( LPCSTR object, unsigned char keyboard_input, unsigned char modifier);
// nca_popup_message_press 函数按 // 消息窗口中的指定按钮。 int nca_popup_message_press ( LPCSTR name, LPCSTR button );
// nca_response_get_cell_data 函数从“响应”框 // 中的单元格中检索数据。应指定“响应”对象 // 的名称和字段的名称。 int nca_response_get_cell_data ( const char *name, const char * rowname, char * data);
// nca_response_press_lov 函数单击“响应”框 // 中的下拉箭头。 int nca_response_press_lov(LPCSTR name, LPCSTR field);
// nca_response_press_ok 函数按指定响应框 // 中的“确定” int nca_response_press_ok (LPCSTR name);
// nca_response_set_cell_data 函数向“响应”框中 // 的单元格中插入数据。应指定“响应”对象的名称、 // 单元格的名称以及数据。
80
int nca_response_set_cell_data (LPCSTR name, LPCSTR cell, LPCSTR data);
// nca_response_set_data 函数向“响应”框中 // 插入数据。应指定“响应”对象的名称 // 和数据。 int nca_response_set_data (LPCSTR name, LPCSTR data);
// nca_scroll_drag_from_min 函数从最小位置 // 滚动到指定距离。 int nca_scroll_drag_from_min ( LPCSTR object, int position );
// nca_scroll_line 函数滚动指定的 // 行数。此函数可用于 // 滚动栏和滑块对象。 int nca_scroll_line ( LPCSTR scroll, int lines );
// nca_scroll_page 函数滚动指定的 // 页数。此函数可用于 // 滚动栏和滑块对象。 int nca_scroll_page ( LPCSTR scroll, int pages );
// Vugen 将 nca_set_connect_opt 插入到 nca_connect_server 的前面, // 这样就能识别为服务器连接 // 录制的值将不同于默认值。 // 保存录制的值将确保与服务器
// 的连接与录制脚本期间的服务器连接完全 // 相同。 int nca_set_connect_opt (eConnectionOption option, ...);
// nca_set_custom_dbtrace 设置在应用程序中 // 启用 DB 跟踪的自定义函数。如果使用 // 内置机制无法启用 DB 跟踪,可能需要 // nca_set_custom_dbtrace 和 nca_set_dbtrace_file_index。 // 当自定义应用程序包含非标准 UI 时,可能
// 会出现这种情况。nca_set_custom_dbtrace // 设置在应用程序中启用 DB 跟踪的 // 自定义函数。 void nca_set_custom_dbtrace(long function);
// nca_set_dbtrace_file_index 标识跟踪文件,以便 // 以后供控制器和分析使用。如果使用 // 内置机制无法启用 DB 跟踪,可能需要 // nca_set_dbtrace_file_index 和 nca_set_custom_dbtrace。当 // 自定义应用程序包含非标准 UI 时,可能会出现
81
// 这种情况。 void nca_set_dbtrace_file_index(LPCSTR fileindex);
// nca_set_exception 函数指定在出现 // 异常时应执行的操作。应指定要调用以处理 // 异常窗口的函数。 void nca_set_exception (LPCSTR title, long function, [void *this_context]);
// 当显示了“启用诊断”窗口而且其中的密码 // 不同于默认值“apps”时,使用 // nca_set_diagnostics_password。必须在 // nca_connect_server 的后面添加此函数调用。 void nca_set_diagnostics_password( LPCSTR password );
// nca_set_iteration_offset 函数设置对象 // ID 编号的偏移值。在 Oracle NCA 脚本 // 常规录制中,VuGen 会录制每个 // 对象的名称。(在起始页中设置 record=names)。 // 如果您的版本不支持 record=names // 标记,VuGen 将为每个对象生成一个新 ID 编号。 // 运行脚本的多次循环时,对象在 // 每次打开都将生成新的 ID 编号。 // 因此,当您回放脚本时,特殊对象 // 的 ID 编号将与首次循环之后 // 同一对象的 ID 不匹配,从而导致测试 // 失败。 void nca_set_iteration_offset (int offset);
// nca_set_server_response_time 函数为 Oracle NCA // 服务器指定响应超时值。这是用户 // 向服务器发送请求之后继续停留在 // 侦听状态的时间。
void nca_set_server_response_time(int time);
// nca_set_think_time 函数指定脚本 // 执行期间使用的思考时间范围。测试使用指定时间 // 范围内的随机思考时间,并在每次操作之后暂停该 // 思考时间长度。 void nca_set_think_time ( DWORD start_range, DWORD end_range );
// nca_set_window 函数指明活动窗口的名称。 int nca_set_window ( LPCSTR window);
// nca_tab_select_item 函数选择选项卡项目。
82
int nca_tab_select_item ( LPCSTR tab, LPCSTR item );
// nca_tree_activate_item 函数激活 // Oracle NCA 树中的指定项目。 int nca_tree_activate_item (LPCSTR name, LPCSTR item);
// nca_tree_select_item 函数选择 // Oracle NCA 树中的指定项目。 int nca_tree_select_item (LPCSTR name, LPCSTR item);
// nca_tree_expand_item 函数展开 Oracle NCA 树中的节点。 int nca_tree_expand_item (LPCSTR name, LPCSTR item);
// nca_tree_collapse_item 函数折叠 // Oracle NCA 树中的节点。 int nca_tree_collapse_item (LPCSTR name, LPCSTR item);
// nca_win_close 函数关闭指定窗口。 int nca_win_close ( LPCSTR window );
// nca_win_get_info 函数检索指定属性的值, // 并存储在 out_value 中。 int nca_win_get_info ( LPCSTR window, LPCSTR property, char *out_value );
// nca_win_move 将某窗口移到一个新的绝对位置。 int nca_win_move ( LPCSTR window, int x, int y );
// nca_win_resize 函数更改窗口的位置。 int nca_win_resize ( LPCSTR window, int width, int height );
// pop3_command 函数向 POP3 服务器发送 // 命令。服务器返回命令结果。 // 例如,如果发送命令“UIDL 1”,服务器将返回 // 第一封邮件的唯一 ID。 long pop3_command(char *transaction, char *command, [char *command,] [char *save_to_param,] LAST);
// pop3_command_ex 函数针对特定会话 // 向 POP3 服务器发送命令。服务器 // 返回命令结果。例如,如果 // 发送命令“UIDL 1”,服务器将返回 // 第一封邮件的唯一 ID。
long pop3_command_ex (POP3 *pppop3, char *transaction, char *command, LAST);
[char *command,]
83
// pop3_delete 函数删除 POP3 服务器上的邮件。 long pop3_delete(char *transaction, char *deleteList, [char *save_to_param,] LAST);
// pop3_delete_ex 函数针对特定会话 // 删除 POP3 服务器上的邮件。 long pop3_delete_ex(POP3 *pppop3, char *transaction, char *deleteList, LAST);
// pop3_logon 函数登录到 POP3 服务器。 // 它使用 FTP 协议使用的格式。 int pop3_logon (char *transaction, char *url, LAST);
// pop3_logon_ex 函数针对特定会话登录 // 到 POP3 服务器。它使用 FTP 协议使用的格式。 int pop3_logon_ex (POP3 *pppop3, char *transaction, char *url, LAST);
// pop3_logoff 函数从 POP3 服务器注销。 long pop3_logoff( );
// pop3_logoff_ex 函数针对特定会话 // 从 POP3 服务器注销。 long pop3_logoff_ex(POP3 *pppop3);
// pop3_free 函数释放 POP3 服务器并取消 // 所有挂起的命令。 void pop3_free( );
// pop3_free_ex 函数针对特定会话释放 POP3 // 服务器,并取消所有挂起的命令。 void pop3_free_ex(POP3 *pppop3);
// pop3_list 函数列出 POP3 // 服务器上的邮件。它返回该服务器上 // 存在的邮件总数。 long pop3_list(char *transaction, [char *save_to_param,] LAST);
// pop3_list_ex 函数针对特定会话 // 列出 POP3 服务器上的邮件。它返回该服务器上 // 存在的邮件总数。 long pop3_list_ex (POP3 *pppop3, char *transaction, LAST);
// pop3_retrieve 函数从 POP3 服务器 // 检索邮件。您可以指定邮件范围或 // 所有邮件。默认情况下,它在检索邮件之后
84
// 将其从服务器中删除。 long pop3_retrieve(char *transaction, char *retrieveList, < Options, > LAST);
// pop3_retrieve_ex 函数从 POP3 服务器 // 检索邮件。您可以指定邮件范围或 // 所有邮件。默认情况下,它在检索邮件之后 // 将其从服务器中删除。 long pop3_retrieve_ex(POP3 *pppop3, char *transaction, char *retrieveList, char * deleteFlag, [<Options>,] LAST);
// lreal_clip_size 函数返回当前与 // 播放器关联的剪辑的大小,单位为毫秒。 unsigned long lreal_clip_size(int miPlayerID);
// lreal_close_player 函数关闭 // RealPlayer 的指定示例。 int lreal_close_player ( int miplayerID );
// lreal_current_time 用于查明剪辑已运行 // 多长时间。返回的时间以毫秒为单位。 unsigned long lreal_current_time( int miplayerID );
// lreal_get_property 获取播放器的属性。 int lreal_get_property ( int miPlayerID, unsigned int miProperty );
// lreal_open_player 函数创建新的 RealPlayer 实例。 int lreal_open_player ( int miplayerID );
// lreal_open_url 函数将 URL 与 // RealPlayer 实例相关联。使用 lreal_play 向 // 实例发出命令让其播放时,将显示此处 // 指定的 szURL。 int lreal_open_url ( int miplayerID, LPSTR szURL );
// lreal_pause 函数将 RealPlayer 实例 // 暂停一段指定的时间(单位为毫秒)。此函数 // 模拟 RealPlayer 的“播放”菜单中的“暂停”命令。 int lreal_pause ( int miplayerID, unsigned long mulPauseTime );
// lreal_play 函数播放 RealPlayer 剪辑 // 一段指定的时间(单位为毫秒)。此函数 // 模拟 RealPlayer 的“播放”菜单中的“播放”命令。 int lreal_play ( int miplayerID, long mulTimeToPlay );
85
// lreal_seek 函数搜寻当前剪辑中的 // 指定位置。此函数模拟 RealPlayer 的 // “播放”菜单中的“搜寻至位置”命令。注意, // 您必须输入以毫秒为单位的时间。 int lreal_seek ( int miplayerID, unsigned long mulTimeToSeek );
// lreal_stop 函数停止播放 RealPlayer 实例。此 // 函数模拟 RealPlayer 的“播放”菜单中的“停止”命令。 int lreal_stop ( int miplayerID);
// TE_connect 函数在您录制与主机 // 的连接时由 VuGen 生成。使用 com_string 的 // 内容连接到主机。 int TE_connect ( const char *com_string, unsigned int timeout );
// TE_find_text 搜索与通过 col1, // row1, col2, row2 定义的矩形中的模式匹配的 // 文本。与模式匹配的文本将返回给 // match,实际的行与列位置将返回给 // retcol 和 retrow。搜索从矩形 // 左上角开始。 int TE_find_text ( const char *pattern, int col1, int row1, int col2, int row2, int *retcol, int *retrow, char *match );
// TE_get_cursor_pos 返回当前鼠标在终端仿真器 // 屏幕上的位置的坐标。 int TE_get_cursor_pos ( int *col, int *row );
// TE_get_line_attribute 检查终端屏幕中 // 一行文本的格式。行中的第一个字符 // 由 col, row 定义。行中最后一个 // 字符的列坐标由 Width
// 指定。该函数将每个字符的字符格式存储在 // 缓冲区 buf 中。 char * TE_get_line_attribute ( int col, int row, int width, char *buf );
// TE_get_text_line 将一行文本从终端屏幕复制到 // 缓冲区。行中的第一个字符 // 由 col, row 定义。行中最后一个 // 字符的列坐标由 Width
// 指定。如果该行包含制表符或空格,将返回相同 // 数目的空格。 char * TE_get_text_line ( int col, int row, int width, char *text );
86
// TE_getvar 函数返回 RTE 系统变量的值。 int TE_getvar ( int var );
// TE_set_cursor_pos 将鼠标位置设置为 col, row。 int TE_set_cursor_pos( int col, int row );
// TE_setvar 函数设置 RTE 系统变量。 int TE_setvar ( int var, int val );
// TE_perror 将 TE_errno 的当前值转换为 // 相应的错误字符串,设置字符串格式,并将其发送到 // Topaz 代理日志或 LoadRunner 输出窗口。 void TE_perror ( char *prefix );
// TE_sperror 将 TE_errno 的当前值转换为 // 相应的错误字符串。 char *TE_sperror ();
// TE_type 函数描述发送到 // 终端仿真器的键盘输入。 int TE_type ( const char *string );
// TE_unlock_keyboard 用于在因为 // 出现错误消息而导致大型机终端的键盘 // 被锁定之后解除锁定。TE_unlock_keyboard 等价于 // 按 F3 键。 int TE_unlock_keyboard ( void );
// TE_typing_style 函数确定键入的 // 字符串如何提交给在终端仿真器上运行的 // 客户端应用程序。如果选择 FAST, // 将把字符作为单个字符串发送。 // 此输入方式不需要参数。 int TE_typing_style ( const char *style );
// 回放期间,TE_wait_cursor 等待鼠标出现在 // 终端窗口中的指定位置。 int TE_wait_cursor ( int col, int row, int stable, int timeout );
// TE_wait_silent 函数等待客户端 // 应用程序静默指定的时间。当终端仿真器 // 未接到任何字符时,认为客户端处于 // 静默状态。如果客户端应用程序 // 由于过了超时时间(以秒为单位)
87
// 而未静默认指定的时间,该函数将 // 返回错误。 int TE_wait_silent ( int sec, int milli, int timeout );
// 执行期间,TE_wait_sync 函数暂停 // 脚本执行,并等待“X SYSTEM”消息 // 从屏幕上消失之后再继续。出现 // “X SYSTEM”消息表示系统处于“内部输入” // 模式。 int TE_wait_sync (void);
// 您可以指示 VuGen 录制每次 // 进入 X SYSTEM 模式时系统停留在 X SYSTEM // 模式的时间。要这样做,VuGen 在每个 TE_wait_sync 函数之后插入 // TE_wait_sync_transaction 函数。 int TE_wait_sync_transaction (char *transaction_name );
// TE_wait_text 函数等待与通过 col1, // row1, col2, row2 定义的矩形中 // 的模式匹配的文本。与模式 // 匹配的文本将返回给 match,实际的 // 行和列位置返回给 retcol 和
// retrow。如果模式超时时间已过而未 // 显示模式,该函数将返回错误 // 代码。如果模式已显示在屏幕上, // 该函数将立即返回。
int TE_wait_text ( const char *pattern, int timeout [, int col1, int row1, int col2, int row2, int *retcol, int *retrow, char *match ] );
// TE_run_script_command 执行 PSL 命令。 int TE_run_script_command ( const char *command );
// TE_run_script_file 运行 PSL 脚本文件。 int TE_run_script_file ( const char *filename );
// sapgui_active_object_from_parent_method 函数 // 使用 ID 编号 control_id 从大的 // 父级对象中选择对象。嵌入的 // 对象由方法 method_name 返回。
int sapgui_active_object_from_parent_method ( const char *control_id, const char *method_name, char *arg1, ..., char *argn, [optionArguments,] LAST );
// sapgui_active_object_from_parent_property 函数 // 使用 ID 编号 control_id 从大的
88
// 父级对象中选择对象。嵌入的 // 对象由属性 property_name 返回。 int sapgui_active_object_from_parent_property (const char *control_id, const char *property_name, [args,] LAST);
// sapgui_calendar_focus_date 将焦点置于 // 日历中的日期上。从日历中选择 // 日期时,将自动录制此函数。 // 但是,实际返回日期的函数是
// sapgui_calendar_select_interval。 int sapgui_calendar_focus_date(const char *description, const char *calendarID, const char *date, [args,] LAST ) ;
// sapgui_calendar_scroll_to_date 模拟使用 // 滚动栏使日期可见的操作。它不是通过 // 将焦点置于日期上来选择日期。 int sapgui_calendar_scroll_to_date(const char *description, const char *calendarID, const char *date, [args,] LAST ) ;
// sapgui_calendar_select_interval 从日历中 // 将日期间隔返回给调用日历 // 弹出框时焦点所在的控件。它等价于 // 在不显示日历的情况下,将控件文本
// 设置为日期字符串。 int sapgui_calendar_select_interval(const char *description, const char *calendarID, const char *interval, [args,] LAST ) ;
// sapgui_call_method 函数使用 SAP 标识符 // control_id 来标识 SAP 对象,并调用 // 对象的方法 method_name。它向方法传递 // 实际参数 arg1...argn。
int sapgui_call_method ( const char *control_id, const char *method_name, void *arg1, ..., void *argn, [optionalArguments] LAST );
// sapgui_call_method_of_active_object 函数调用 // 通过 sapgui_active_object_from_parent_method // 或 sapgui_active_object_from_parent_property // 选择的当前活动对象的方法 method_name。 int sapgui_call_method_of_active_object ( const char *method_name, char *arg1, [args,] char *argn, [optionalArguments,] LAST );
// sapgui_create_new_session 创建一个新会话。它等价于 // 从“系统”菜单中选择“创建会话”。 int sapgui_create_new_session([optionalArgs,] LAST );
89
// sapgui_get_active_window_title 数据检索函数 // 获取当前 SAP 会话中活动窗口的名称, // 并保存到 output_param_name 中。 int sapgui_get_active_window_title (const char *output_param_name, [args,]
LAST);
// sapgui_get_ok_code 数据检索函数获取 // “命令”字段的文本。“命令”字段是主窗口中 // 第一个工具栏左边的框。 int sapgui_get_ok_code( const char *outParamName, [args,]
LAST);
// sapgui_get_property 数据检索函数获取 // ID 编号为 control_id 的 SAP 对象中 // 指定属性 property_name 的值。 // 该值保存在 output_param_name 中。 int sapgui_get_property ( const char *control_id, const char *property_name, char *output_param_name, [args,] LAST);
// sapgui_get_property_of_active_object 数据检索 // 函数从当前活动对象中检索 // 指定属性 property_name 的值。 // 该值保存在 output_param_name 中。
int sapgui_get_property_of_active_object ( const char *property_name, const char *output_param_name, [args,] LAST );
// sapgui_get_text 数据检索函数 // 获取任意可视屏幕对象的文本属性, // 并保存到参数 outParamName 中。 int sapgui_get_text(const char *description, const char *controlID, const char *outParamName, [args,] LAST);
// sapgui_grid_fill_data 在网格中输入表格数据 // 参数。当您在网格中输入数据并按 Enter 时, // 录制此函数。表格参数 paramName 是 // 自动创建的。录制之后,可以在 VuGen 中编辑此表格参数, // 以便更改数据。 int sapgui_grid_fill_data( const char *description, const char *gridID, const char *paramName, [args,] LAST );
// sapgui_grid_clear_selection 取消选择已在网格控件中 // 选定的所有单元格、行和列。 int sapgui_grid_clear_selection(const char *description, const char *gridID, [args,]
// sapgui_grid_click 模拟用户在通过“row”或
LAST );
90
// “column”指定的网格单元格中单击。 int sapgui_grid_click(const char *description, const char *gridID, const char *row, const char *column, [args,] LAST );
// sapgui_grid_click_current_cell 模拟用户 // 在当前选定的单元格中单击。 int sapgui_grid_click_current_cell(const char *description, const char *gridID, [args,] LAST );
// sapgui_grid_deselect_column 取消选择某列。 int sapgui_grid_deselect_column(const char *description, const char *gridID, const char* column, [args,] LAST );
// sapgui_grid_double_click 模拟用户在 // 网格中的单元格中双击。 int sapgui_grid_double_click(const char *description, const char *gridID, const char *row, const char *column, [args,] LAST );
// sapgui_grid_double_click_current_cell 模拟用户在 // 当前选定的单元格中双击。 int sapgui_grid_double_click_current_cell(const char *description, const char *gridID, [args,] LAST );
// sapgui_grid_get_cell_data 数据检索函数 // 获取网格单元格中的数据,并保存到 outParamName 中。 int sapgui_grid_get_cell_data(const char *description, const char *gridID, const char *row, const char *column, const char *outParamName, [args,] LAST );
// sapgui_grid_get_columns_count 数据检索 // 函数获取网格中的列数。 int sapgui_grid_get_columns_count(const char *description, const char *gridID, const char *outParamName, [args,] LAST );
// sapgui_grid_get_current_cell_column 数据 // 检索函数获取当前活动单元格的列标识符, // 并保存到 outparamName 中。 int sapgui_grid_get_current_cell_column(const char *description, const char *gridID, const char *outParamName, [args,] LAST );
// sapgui_grid_get_current_cell_row 数据 // 检索函数获取当前活动单元格的行号, // 并保存到 outparamName 中。 int sapgui_grid_get_current_cell_row(const char *description, const char *gridID, const char *outParamName, [args,] LAST );
91
// sapgui_grid_get_rows_count 数据检索 // 函数获取网格中的行数。 int sapgui_grid_get_rows_count(const char *description, const char *gridID, const char *outParamName, [args,] LAST );
// sapgui_grid_is_checkbox_selected 验证 // 函数在复选框被选中时返回 true, // 在复选框未被选中时返回 false。 int sapgui_grid_is_checkbox_selected(const char *description, const char *gridID, const char *row, const char *column, [args,] LAST );
// sapgui_grid_open_context_menu 模拟用户 // 在网格中右键单击以便打开上下文菜单。 int sapgui_grid_open_context_menu(const char *description, const char *gridID, [args,] LAST );
// sapgui_grid_press_button 函数单击网格单元格中的按钮。 int sapgui_grid_press_button(const char *description, const char *gridID, const char *row, const char *column, [args,] LAST );
// sapgui_grid_press_button_current_cell 模拟用户 // 单击当前活动的网格单元格中的按钮。 int sapgui_grid_press_button_current_cell(const char *description, const char *gridID, [args,] LAST );
// sapgui_grid_press_column_header 模拟用户 // 单击网格控件中的列标题。 int sapgui_grid_press_column_header(const char *description, const char *gridID, const char *column, [args,] LAST );
// sapgui_grid_press_ENTER 模拟用户 // 在网格处于活动状态时按 Enter 键。 int sapgui_grid_press_ENTER (const char *description, const char *gridID, [args,]
LAST );
// sapgui_grid_press_F1 模拟用户 // 在网格处于活动状态时按 F1 键。其结果是 // 显示上下文相关帮助。 int sapgui_grid_press_F1 (const char *description, const char *gridID, [args,]
// sapgui_grid_press_F4 模拟用户在网格处于 // 活动状态时按 F4 键。其结果通常是 // 显示活动字段可能的选项。 int sapgui_grid_press_F4 (const char *description, const char *gridID, [args,]
LAST );
LAST );
92
// sapgui_grid_press_toolbar_button 模拟 // 用户单击网格工具栏按钮。 int sapgui_grid_press_toolbar_button(const char *description, const char *gridID, const char *buttonID, [args,] LAST );
// sapgui_grid_press_toolbar_context_button 模拟用户 // 通过单击上下文按钮打开选项列表。 int sapgui_grid_press_toolbar_context_button(const char *description, const char *gridID, const char *buttonID, [args,] LAST );
// sapgui_grid_press_total_row 函数按 // 网格单元格中的总计行按钮。如果总计 // 行被精简了,该函数将展开它。如果总计行 // 已展开,该函数将精简它。 int sapgui_grid_press_total_row(const char *description, const char *gridID, const char *row, const char *column, [args,] LAST );
// sapgui_grid_press_total_row_current_cell 函数按 // 当前活动网格单元格中的总计行按钮。 // 如果总计行被精简了,该函数将展开它。 // 如果总计行已展开,该函数将精简它。
int sapgui_grid_press_total_row_current_cell(const char *description, const char *gridID, [args,] LAST );
// sapgui_grid_scroll_to_row 滚动到网格中的指定行, // 从而使其可见。它不会选择行。 int sapgui_grid_scroll_to_row(const char *description, const char *gridID, const char *row, [args,] LAST ) ;
// sapgui_grid_select_all 选择网格控件中的所有单元格。 int sapgui_grid_select_all(const char *description, const char *gridID, [args,] LAST );
// sapgui_grid_select_cell 选择网格控件中的单个单元格。 int sapgui_grid_select_cell(const char *description, const char *gridID, const char *row, const char *column, [args,] LAST );
// sapgui_grid_select_cell_column 选择与当前选择 // 位于同一行但位于不同列的单元格。 // 它在同一行中向左或向右移动选择,以便移动到 // 由参数 column 指定的列号。 int sapgui_grid_select_cell_column(const char *description, const char *gridID, const char *column, [args,] LAST );
// sapgui_grid_select_cell_row 选择与当前选择
93
// 位于同一列但位于不同行的单元格。 // 它在同一列中向上或向下移动选择,以便移动到 // 由参数 row 指定的行号。 int sapgui_grid_select_cell_row(const char *description, const char *gridID, const char *row, [args,] LAST );
// sapgui_grid_select_cells 函数选择 // 网格中的单元格。单元格列表以 // “LAST”或“BEGIN_OPTIONAL”结束。 int sapgui_grid_select_cells(const char *description, const char *gridID, const char *cell1 ,..., celln, [args,] LAST );
// sapgui_grid_select_column 选择网格控件中的一列。 int sapgui_grid_select_column ( const char *description, const char *gridID, const char* column, [optionalArgs,] LAST );
// sapgui_grid_select_columns 选择网格控件中的 // 一列或多列。这些列不必相邻, // 也不必按照网格中的显示顺序传递给 // 函数。
int sapgui_grid_select_columns(const char *description, const char *gridID, char *arg1, ..., char *argn, [optionalArgs,] LAST);
// sapgui_grid_select_context_menu 模拟用户 // 从上下文菜单中选择选项。 int sapgui_grid_select_context_menu(const char *description, const char *gridID, const char *functionCode, [args,] LAST );
// sapgui_grid_select_rows 选择网格单元格中的一行或多行。 int sapgui_grid_select_rows(const char *description, const char *gridID, const char *rows, [args,] LAST );
// sapgui_grid_select_toolbar_menu 模拟用户 // 从网格工具栏菜单中选择选项。 int sapgui_grid_select_toolbar_menu(const char *description, const char *gridID, const char *functionCode, [args,] LAST );
// sapgui_grid_selection_changed 验证函数 // 返回选择是否已发生更改。 int sapgui_grid_selection_changed(const char *description, const char *gridID, [args,]
LAST );
// sapgui_grid_set_cell_data 在网格单元格中插入数据。字符串 // newValue 被写入位于 row 和 column 的单元格中。 int sapgui_grid_set_cell_data(const char *description, const char *gridID, const char *row, const
94
char *column, const char *newValue, [args,] LAST );
// sapgui_grid_set_checkbox 函数选择或清除网格复选框。 int sapgui_grid_set_checkbox(const char *description, const char *gridID, const char *row, const char *column, const char *newValue, [args,] LAST );
// sapgui_grid_set_column_order 模拟用户 // 将列拖动到网格中的新位置。 int sapgui_grid_set_column_order(const char *description, const char *gridID, const char *row, const char *columns, [args,] LAST );
// sapgui_grid_set_column_width 模拟用户 // 拖动列边框以便设置新宽度。 int sapgui_grid_set_column_width(const char *description, const char *gridID, const char* column, const char* width, [args,] LAST);
// sapgui_htmlviewer_send_event 发送 HTML 事件。 int sapgui_htmlviewer_send_event(const char *htmlViewerID, const char *frame, const char *data, const char *url, [args,] LAST ) ;
// sapgui_is_checkbox_selected 验证函数返回 // 复选框的状态。如果复选框被选中,该函数返回 True。 // 如果复选框未被选中,该函数返回 False。 int sapgui_is_checkbox_selected(const char *description, const char *checkBoxID, [args,] LAST );
// sapgui_is_object_available 验证函数检查 // 指定对象是否可用在函数中。 int sapgui_is_object_available (const char *object_name, [args,] LAST);
// sapgui_is_object_changeable 验证函数返回 // 组件是否可被修改。如果组件既未被禁用,也不是只读, // 则可被修改。 int sapgui_is_object_changeable(const char *controlID, [args,] LAST);
// sapgui_is_radio_button_selected 验证函数 // 返回单选按钮是否已被选中。 int sapgui_is_radio_button_selected(const char *description, const char *buttonID,[args,] LAST );
// sapgui_is_tab_selected 验证函数返回一个布尔值, // 指明当前是否选择了选项卡 tabID。 int sapgui_is_tab_selected(const char *description, const char *tabID, [args,] LAST);
95
// sapgui_logon 登录到 SAP 服务器。 int sapgui_logon ( const char *user_name, const char *password, const char *client_num, const char *language, [args,] LAST );
// sapgui_open_connection 函数打开 // 由 connection_name 定义的连接。如果在 // 现有的 SAP 客户端定义中未找到 // connection_name,该函数将试图连接到 // 使用该名称的服务器。 int sapgui_open_connection (const char *connection_name, const char *connection_id, [args,] LAST );
// sapgui_open_connection_ex 函数打开 // 与由 connection_string 定义的服务器的连接。此函数 // 设置输出参数 connection_id。此参数用在 // sapgui_select_active_connection 中。 int sapgui_open_connection_ex (const char *connection_string, const char *connection_name, const char *connection_id, [args,] LAST );
// sapgui_press_button 模拟用户单击按钮 buttonID。 int sapgui_press_button( const char *description, const char *buttonID, [args,]
// sapgui_select_active_connection 指定一个打开的服务器连接 // 作为工作连接。 int sapgui_select_active_connection(const char *connectionID);
// sapgui_select_active_session 从打开的会话集合中 // 选择当前工作会话。 int sapgui_select_active_session(const char *sessionID);
// 录制时,只要您在不属于前一活动 // 窗口的控件上执行操作,就会自动 // 生成 sapgui_select_active_window // 语句。随后的所有操作都将在此
// 窗口上执行,直到调用下一个 sapgui_select_active_window // 语句。 int sapgui_select_active_window ( const char *window_id );
LAST );
// sapgui_select_combobox_entry 从组合框中选择项目 entryKey。 int sapgui_select_combobox_entry(const char *description, const char *objectID, const char *entryKey, [args,] LAST );
// sapgui_select_menu 模拟用户打开 // 菜单并选择菜单项目。
96
int sapgui_select_menu(const char *description, const char *menuID, [args,] LAST );
// sapgui_select_radio_button 从组中选择一个单选按钮, // 并清除该组中的所有其他按钮。 int sapgui_select_radio_button(const char *description, const char *buttonID, [args,]
LAST );
// sapgui_select_tab 激活一个选项卡页。它 // 模拟用户单击选项卡 tabID。 int sapgui_select_tab(const char *description, const char *tabID, [args,]
// sapgui_send_vkey 函数通过发送 // 虚拟键来模拟键盘。 int sapgui_send_vkey(const char *key, [args,] LAST );
LAST );
// 如果 isSelected 为“True”,那么 sapgui_set_checkbox 将选中 // 复选框。如果 isSelected 为“False”,将清除该复选框。 int sapgui_set_checkbox(const char *description, const char *isSelected, const char *checkBoxID, [args,] LAST );
// sapgui_set_collection_property 函数使用组成 // GuiCollection 对象的字符串列表项目 arg1...argn // 设置指定的属性 property_name。 int sapgui_set_collection_property ( const char *control_id, const char *property_name, char *arg1, ..., char *argn, [optionalArgs,] LAST );
// sapgui_set_focus 将焦点置于对象 controlID 上。 int sapgui_set_focus(const char *controlID, [args,] LAST );
// sapgui_set_ok_code 在“命令”字段中输入文本。 // “命令”字段是主窗口中第一个工具栏 // 左边的框。文本必须是 SAP 命令。 int sapgui_set_ok_code(const char *text, [args,] LAST );
// sapgui_set_password 在“密码”文本框中输入 // 密码。录制函数时,密码文本被 // 隐藏。要回放脚本,请编辑函数并输入 // 密码。
int sapgui_set_password(const char *description, const char *password, const char *controlID, [args,] LAST );
// sapgui_set_property 函数使用 ID 编号为 // control_id 的 SAP 对象中的值 new_value 设置 // 指定属性 property_name。 int sapgui_set_property ( const char *control_id, const char *property_name, const char
97
*new_value, [args,] LAST );
// sapgui_set_property_of_active_object 函数使用 // 值 new_value 设置当前活动对象的指定 // 属性 property_name。当前对象通过 // sapgui_active_object_from_parent_method 或
// sapgui_active_object_from_parent_property 选择。 int sapgui_set_property_of_active_object ( const char *property_name, const char *new_value, [args,] LAST );
// sapgui_set_text 将 text 参数的值写入 // 控件。如果 text 为文字,请将它放置在引号中: // “The text to enter”。如果 text 是文件, // 语法为 “file=filename.ext”。引号是语法的 // 组成部分。文件必须位于 // script 文件夹中。不能使用路径。 int sapgui_set_text(const char *description, const char *text, const char *controlID, [args,] LAST );
// sapgui_status_bar_get_param 数据检索函数 // 从状态栏获取位置 paramIndex 中的参数, // 并将其存储在参数 outputParamName 中。 int sapgui_status_bar_get_param(const char *paramIndex, const char *outputParamName, [args,] LAST );
// sapgui_status_bar_get_text 数据检索函数 // 从状态栏获取文本,并将其存储在参数 // outputParamName 中。将检索用户看到的整个文本, // 包括固定文本和参数。 int sapgui_status_bar_get_text(const char *outputParamName, [args,]
LAST );
// 成功调用 sapgui_status_bar_get_type 后,outputParamName 的值 // 为以下文字字符串之一 // :“Success”、“Warning”或“Error”。该函数 // 用于测试上一操作的结果。
int sapgui_status_bar_get_type(const char *outputParamName, [args,] LAST );
// 当您在表中输入数据并按 Enter 键时录制 sapgui_table_fill_data // 。将自动创建表参数 paramName // 。录制后可以在 VuGen 中编辑表参数 // 以便更改数据。
int sapgui_table_fill_data(const char *description, const char *tableID, const char *paramName, [args,] LAST );
98
// sapgui_table_get_column_width 数据检索函数 // 将列的宽度放到参数 paramName 中。 int sapgui_table_get_column_width(const char *description, const char *tableID, const char *column, const char *paramName, [args,] LAST );
// sapgui_table_get_text 数据检索函数将由 // row 和 column 指定的单元格中的文本放到参数 paramName 中。 int sapgui_table_get_text(const char *description, const char *tableID, const char *row, const char *column, const char *paramName, [args,] LAST );
// 如果选中列,则 sapgui_table_is_column_selected 返回 True。 int sapgui_table_is_column_selected ( char * tableID, char * column, [args,]
LAST );
// sapgui_table_is_checkbox_selected 验证函数 // 适用于表控件中的复选框。 // 它返回是选中还是清除了该复选框。 int sapgui_table_is_checkbox_selected(const char *description, const char *tableID, const char *row, const char *column, [args,] LAST );
// 如果选中表中的单选按钮, // 则 sapgui_table_is_radio_button_selected 验证函数返回 True。 int sapgui_table_is_radio_button_selected(const char *description, const char *tableID, const char *row, const char *column, [args,] LAST );
// sapgui_table_is_row_selected 验证函数 // 适用于表控件中的行。 // 它返回行是否被选中。 int sapgui_table_is_row_selected(const char *tableID, const char *row, [args,]
LAST );
// sapgui_table_press_button 适用于表单元格中的 // 按钮控件。它模拟用户单击由 row 和 column 指定的 // 单元格中的按钮。 int sapgui_table_press_button(const char *description, const char *tableID, const char *row, const char *column, [args,] LAST );
// sapgui_table_reorder 对表中的列进行重新排序。 // order 参数是新顺序中 // 列的原有位置。使用空格来分隔列编号 // 。例如,“0 1 3 2”会将第 4 列
// (列 3)移动到第 3 个位置。 int sapgui_table_reorder ( const char *description, const char *tableID, const char *order, [args,] LAST );
// sapgui_table_select_combobox_entry 从组合框中
99
// 选择项目 entryKey,并在由 row 和 column 指定的 // 表单元格中输入该值。 int sapgui_table_select_combobox_entry (const char *description, const char *tableID, const char *row, const char *column, const char *entryKey, [args,] LAST );
// sapgui_table_select_radio_button 适用于表单元格中的 // 单选按钮控件。它模拟用户选中由 row 和 column 指定 // 的单元格中的按钮。 int sapgui_table_select_radio_button(const char *description, const char *tableID, const char *row, const char *column, [args,] LAST );
// sapgui_table_set_checkbox 设置表中复选框 // 的状态。如果 newValue 为“True”,则该复选框处于选中状态。 // 如果 newValue 为“False”,则该复选框处于清除状态。 int sapgui_table_set_checkbox(const char *description, const char *tableID, const char *row, const char *column, const char *newValue, [args,] LAST );
// sapgui_table_set_column_selected 模拟用户 // 单击表中的列标题。 int sapgui_table_set_column_selected(const char *description, const char *tableID, const char *column, const char *isSelected, [args,] LAST );
// sapgui_table_set_column_width 模拟用户 // 拖动表中列标题的边缘。 int sapgui_table_set_column_width ( const char *description, const char *tableID, const char *column, const char *width, [args,] LAST );
// sapgui_table_set_focus 模拟用户在由 // row 和 column 指定的表单元格中单击。 int sapgui_table_set_focus (const char *description, const char *tableID, const char *row, const char *column, const char *newValue, [args,] LAST );
// sapgui_table_set_password 在表单元格密码字段中 // 设置密码。 int sapgui_table_set_password(const char *description, const char *tableID, const char *row, const char *column, const char *password, [args,] LAST );
// sapgui_table_set_row_selected 设置表中行的 // 选中状态。如果 isSelected 为“True”, // 则行号为 row 的行处于选中状态。如果 isSelected // 为“False”,则该行处于未选中状态。 int sapgui_table_set_row_selected(const char *tableID, const char *row, const char *isSelected, [args,] LAST );
100
// sapgui_table_set_text 在由 row 和 column 指定的 // 单元格中输入字符串文本。 int sapgui_table_set_text(const char *description, const char *tableID, const char *row, const char *column, const char *text, [args,] LAST );
// sapgui_text_edit_scroll_to_line 模拟用户滚动, // 直到指定行可见。但不选中该行。 int sapgui_text_edit_scroll_to_line( const char *description, const char *textEditID, const char *lineNumber, [args,] LAST );
// sapgui_text_edit_set_selection_indexes 设置 // 选择的可视文本范围。参数 start 和 end 都是基于 // 零的字符索引。参数 start 对应 // 所选内容的开始位置,而参数 end 是 // 所选内容之后第一个字符的位置。 int sapgui_text_edit_set_selection_indexes( const char *description, const char *textEditID, const char *startNumber, const char *endNumber, [args,] LAST );
// sapgui_text_edit_set_unprotected_text_part // 通过基于零的索引将 text 的内容分配给未受保护的 // 文本部分,即 part。 int sapgui_text_edit_set_unprotected_text_part( const char *description, const char *textEditID, const char *part, const char *text, [args,] LAST );
// sapgui_text_edit_get_first_visible_line 将在控件 // 顶部边框可见的第一行的编号 // 分配给 outParamName。行从 1 开始编号。 int sapgui_text_edit_get_first_visible_line( const char *description, const char *textEditID, const char *outParamName, [args,] LAST );
// sapgui_text_edit_get_selection_index_start 将 // 选定范围开始位置的基于零的字符索引 // 分配给参数 outParamName。 int sapgui_text_edit_get_selection_index_start( const char *description, const char *textEditID, const char *outParamName, [args,] LAST );
// sapgui_text_edit_get_selection_index_end 将 // 选定范围结束位置的基于零的字符索引 // 分配给参数 outParamName。这是所选内容之后第一个字符的 // 位置。 int sapgui_text_edit_get_selection_index_end( const char *description, const char *textEditID, const char *outParamName, [args,] LAST );
// sapgui_text_edit_get_number_of_unprotected_text_parts 将
101
// 未受保护文本部分的编号分配给 outParamName。 int sapgui_text_edit_get_number_of_unprotected_text_parts( const char *description, const char *textEditID, const char *outParamName, [args,] LAST );
// sapgui_text_edit_double_click 模拟鼠标双击。 // 要设置所选内容,请在 sapgui_text_edit_double_click 之前 // 调用 sapgui_text_edit_set_selection_indexes。 int sapgui_text_edit_double_click( const char *description, const char *textEditID, [args,] LAST );
// sapgui_text_edit_single_file_dropped 模拟 // 将 fileName 拖放到文本编辑控件中。 int sapgui_text_edit_single_file_dropped( const char *description, const char *textEditID, const char * fileName, [args,] LAST );
// sapgui_text_edit_multiple_files_dropped 模拟 // 将 listOfFiles 中的文件 // 拖放到文本编辑控件中。 int sapgui_text_edit_multiple_files_dropped( const char *description, const char *textEditID, listOfFiles, [args,] LAST );
// sapgui_text_edit_press_F1 调用 // 在应用程序中针对文本编辑控件定义的 // 上下文相关帮助。如果未定义帮助, // 则 sapgui_text_edit_press_F1 不起作用。 int sapgui_text_edit_press_F1( const char *description, const char *textEditID, [args,]
// sapgui_text_edit_press_F4 调用 // 应用程序中针对文本编辑控件定义的选项列表。如果未 // 定义选项,则 sapgui_text_edit_press_F4 不起作用。 int sapgui_text_edit_press_F4( const char *description, const char *textEditID, [args,]
LAST );
LAST );
// sapgui_text_edit_open_context_menu 打开 // 应用程序中针对文本编辑控件定义的 // 快捷菜单。如果未定义菜单,则 sapgui_text_edit_open_context_menu // 不起作用。 int sapgui_text_edit_open_context_menu( const char *description, const char *textEditID, [args,] LAST );
// sapgui_text_edit_select_context_menu 选中 // 由 menuId 指定的快捷菜单项。 // menuId 是项目的函数代码。 int sapgui_text_edit_select_context_menu( const char *description, const char *textEditID, const char *menuId, [args,] LAST );
102
// sapgui_text_edit_modified_status_changed 设置 // 文本编辑控件的已修改状态。 // 其值可以是“True”,也可以是“False”。 int sapgui_text_edit_modified_status_changed( const char *description, const char *textEditID, const char *value, [args,] LAST );
// sapgui_toolbar_press_button 模拟在工具栏按钮上进行单击操作。 int sapgui_toolbar_press_button( const char * description, const char * toolbarID, const char * buttonID, [args,] LAST );
// sapgui_toolbar_press_context_button 模拟 // 用户按工具栏上下文按钮。 int sapgui_toolbar_press_context_button(const char * description, const char * toolbarID, const char * buttonID, [args,] LAST );
// sapgui_toolbar_select_menu_item 模拟 // 用户选择工具栏菜单项。 int sapgui_toolbar_select_menu_item( const char * description, const char * toolbarID, const char * menuID, [args,] LAST );
// sapgui_toolbar_select_menu_item_by_text 模拟 // 用户选择工具栏菜单项。 int sapgui_toolbar_select_menu_item_by_text( const char * description, const char * toolbarID, const char * menuItem, [args,] LAST );
// sapgui_toolbar_select_context_menu_item 模拟 // 用户选择上下文菜单项。 int sapgui_toolbar_select_context_menu_item( const char * description, const char * toolbarID, const char * menuID, [args,] LAST );
// sapgui_toolbar_select_context_menu_item_by_text // 模拟用户选择上下文菜单项。 int sapgui_toolbar_select_context_menu_item_by_text( const char * description, const char * toolbarID, const char * menuItem, [args,] LAST );
// sapgui_tree_click_link 模拟用户单击树中的链接。 int sapgui_tree_click_link(const char *description, const char *treeID, const char *nodeKey, const char *itemName, [args,] LAST ) ;
// sapgui_tree_collapse_node 模拟用户单击 // “-”符号以折叠节点。调用 sapgui_tree_collapse_node 之后, // “-”符号将替换为“+”符号, // 而且子节点不可见。
103
int sapgui_tree_collapse_node(const char *description, const char *treeID, const char *nodeKey, [args,] LAST ) ;
// sapgui_tree_double_click_item 模拟用户 // 双击树中的某一项。如果该项是一个链接, // 则打开其目标;如果是命令,则执行该命令。 int sapgui_tree_double_click_item(const char *description, const char *treeID, const char *nodeKey, const char *itemName, [args,] LAST ) ;
// sapgui_tree_double_click_node 模拟 // 用户双击树中的某个节点。 int sapgui_tree_double_click_node(const char *description, const char *treeID, const char *nodeKey, [args,] LAST );
// sapgui_tree_expand_node 模拟用户通过单击“+”符号 // 展开一个节点。调用 sapgui_tree_expand_node 之后, // “+”符号将替换为“-”符号, // 而且子节点可见。
int sapgui_tree_expand_node(const char *description, const char *treeID, const char *nodeKey, [args,] LAST ) ;
// sapgui_tree_get_item_text 数据检索函数 // 将树中某一项的文本属性放到 outParamName 中。 int sapgui_tree_get_item_text(const char *description, const char *treeID, const char *nodeKey, const char *itemName, const char *outParamName, [args,] LAST ) ;
// sapgui_tree_get_node_text 数据检索函数 // 将节点文本放到 outParamName 中。 int sapgui_tree_get_node_text(const char *description, const char *treeID, const char *nodeKey, const char *outParamName, [args,] LAST ) ;
// sapgui_tree_is_checkbox_selected 验证函数 // 适用于树控件中的复选框。如果复选框处于选中状态, // 则返回 True,如果复选框处于清除状态,则返回 False。 int sapgui_tree_is_checkbox_selected(const char *description, const char *treeID, const char *nodeKey, const char *itemName, [args,] LAST ) ;
// sapgui_tree_open_default_context_menu 打开 // 树的默认上下文相关菜单。 int sapgui_tree_open_default_context_menu(const char *description, const char *treeID, [args,] LAST ) ;
// sapgui_tree_open_header_context_menu 模拟用户 // 右键单击树标题以打开上下文相关菜单。
104
int sapgui_tree_open_header_context_menu(const char *description, const char *treeID, const char *headerName, [args,] LAST ) ;
// sapgui_tree_open_item_context_menu 模拟用户 // 右键单击树项以打开上下文相关菜单。 int sapgui_tree_open_item_context_menu(const char *description, const char *treeID, const char *nodeKey, const char *itemName, [args,] LAST ) ;
// sapgui_tree_open_node_context_menu 模拟用户 // 右键单击树节点以打开上下文相关菜单。 int sapgui_tree_open_node_context_menu(const char *description, const char *treeID, const char *nodeKey, [args,] LAST ) ;
// sapgui_tree_press_button 模拟用户单击树中的按钮。 int sapgui_tree_press_button(const char *description, const char *treeID, const char *nodeKey, const char *itemName, [args,] LAST );
// sapgui_tree_press_header 模拟用户 // 单击树中的列标题。 int sapgui_tree_press_header(const char *description, const char *treeID, const char *headerName, [args,] LAST ) ;
// sapgui_tree_press_key 模拟用户在 // 树具有焦点时按键盘。 int sapgui_tree_press_key(const char *description, const char *treeID, const char *key, [args,] LAST );
// sapgui_tree_scroll_to_item 与 // sapgui_tree_select_item 自动录制为一对。它模拟 // 使用滚动条,以便 itemName 可见。 int sapgui_tree_scroll_to_item(const char *description, const char *treeID, const char *nodeKey, const char *itemName, [args,] LAST ) ;
// sapgui_tree_scroll_to_node 滚动树,以便 // topNode 成为窗格顶端 // 的第一个可见节点。但不选中该节点。 int sapgui_tree_scroll_to_node(const char *description, const char *treeID, const char *topNode, [args,] LAST );
// sapgui_tree_select_column 模拟用户 // 使用鼠标选择树列。 int sapgui_tree_select_column(const char *description, const char *treeID, const char *columnName, [args,] LAST ) ;
105
// sapgui_tree_select_context_menu 从树控件的 // 快捷菜单中选择一项。 int sapgui_tree_select_context_menu ( const char *description, const char *treeID, const char *value, [args,] LAST );
// sapgui_tree_select_item 适用于树控件中 // 任何可选项。它模拟用户单击 // itemName 项以便选中该项。如果在调用 sapgui_tree_select_item 时 // 该项在树窗格中不可见, // 则滚动树以使该项可见。 int sapgui_tree_select_item(const char *description, const char *treeID, const char *nodeKey, const char *itemName, [args,] LAST ) ;
// sapgui_tree_select_node 模拟用户单击 // MultipleNodeSelection 树中的节点。调用 // sapgui_tree_select_node 会将节点 nodeKey // 添加到选定节点的集合。 int sapgui_tree_select_node(const char *description, const char *treeID, const char *nodeKey, [args,] LAST ) ;
// sapgui_tree_set_checkbox 适用于树控件中的 // 复选框。如果该值为“True”,则选中复选框; // 如果该值为“False”,则清除复选框。 int sapgui_tree_set_checkbox(const char *description, const char *treeID, const char *nodeKey, const char *itemName, const char *value, [args,] LAST );
// sapgui_tree_set_column_order 设置树中 // 列的顺序。新顺序由列在列列表中 // 的位置来确定。 int sapgui_tree_set_column_order(const char *description, const char *treeID, const char *columns, [args,] LAST ) ;
// sapgui_tree_set_column_width 将 columnName 的宽度设置为 width。 int sapgui_tree_set_column_width(const char *description, const char *treeID, const char *columnName, const char *width, [args,] LAST ) ;
// sapgui_tree_set_hierarchy_header_width 将 // 树视图中标题的宽度更改为 width。 int sapgui_tree_set_hierarchy_header_width(const char *description, const char *treeID, const char *width, [args,] LAST );
// sapgui_tree_set_selected_node 模拟用户单击 // SingleNodeSelection 树中的节点。调用 // sapgui_tree_set_selected_node 将取消选中
106
// 先前选中的节点,并选中节点 nodeKey。 int sapgui_tree_set_selected_node(const char *description, const char *treeID, const char *nodeKey, [args,] LAST );
// sapgui_tree_unselect_all 取消选中树中 // 所有选中的项,而不选中其他项。 int sapgui_tree_unselect_all(const char *description, const char *treeID, [args,] LAST) ;
// sapgui_tree_unselect_column 取消选中树列。 int sapgui_tree_unselect_column(const char *description, const char *treeID, const char *columnName, [args,] LAST ) ;
// sapgui_tree_unselect_node 取消选中树节点。 int sapgui_tree_unselect_node(const char *description, const char *treeID, const char *nodeKey, [args,] LAST ) ;
// sapgui_window_close 关闭 SAP GUI 应用程序。 int sapgui_window_close( LAST);
// sapgui_window_maximize 将窗口设置为全屏大小。 int sapgui_window_maximize( LAST);
// sapgui_window_resize 将活动窗口调整为 width 和 height 大小。 int sapgui_window_resize( const char *width, const char *height, [args,]
// sapgui_window_restore 将窗口还原为非最大化状态。 int sapgui_window_restore( LAST);
// sapgui_window_scroll_to_row 滚动到某一窗口行,但 // 不在该行上设置焦点,也不针对该行执行任何操作 int sapgui_window_scroll_to_row( const char * newPosition, [args,]
LAST );
// sapgui_apogrid_clear_selection 取消选中 // APO 网格中当前选中的区域。 int sapgui_apogrid_clear_selection ( const char *description, const char *gridID, [args,] LAST ) ;
// sapgui_apogrid_deselect_cell 取消选中 APO 网格中 // 由“row”和“column”指定的单元格。 int sapgui_apogrid_deselect_cell ( const char *description, const char *gridID, const char *row, const char *column, [args,] LAST ) ;
// sapgui_apogrid_deselect_column 取消选中 APO 网格中的 // 指定列。 int sapgui_apogrid_deselect_column ( const char *description, const char *gridID, const char
LAST );
107
*column, [args], LAST ) ;
// sapgui_apogrid_deselect_row 取消选中 APO 网格中的指定行。 int sapgui_apogrid_deselect_row ( const char *description, const char *gridID, const char *row, [args,] LAST ) ;
// sapgui_apogrid_double_click 模拟用户 // 双击 APO 网格中的单元格。 int sapgui_apogrid_double_click ( const char *description, const char *gridID, const char *row, const char *column, [args,] LAST ) ;
// sapgui_apogrid_get_cell_data 将 APO 网格中 // 某单元格的数据分配给参数 outParamName。 // 数据始终以字符串形式保存。 int sapgui_apogrid_get_cell_data ( const char *description, const char *gridID, const char *row, const char *column, const char *outParamName, [args,] LAST ) ;
// sapgui_apogrid_get_cell_format 将 APO 网格中 // 某单元格的格式描述分配给参数 outParamName。 int sapgui_apogrid_get_cell_format ( const char *description, const char *gridID, const char *row, const char *column, const char *outParamName, [args,] LAST ) ;
// sapgui_apogrid_get_cell_tooltip 将 APO 网格中 // 某单元格的工具提示分配给参数 outParamName。 int sapgui_apogrid_get_cell_tooltip ( const char *description, const char *gridID, const char *row, const char *column, const char *outParamName, [args,] LAST ) ;
// sapgui_apogrid_is_cell_changeable 返回一个值,指明 // 用户是否可以修改 APO 网格中某单元格的值。 int sapgui_apogrid_is_cell_changeable ( const char *description, const char *gridID, const char *row, const char *column, [args,] LAST ) ;
// sapgui_apogrid_open_cell_context_menu 打开 APO 网格中 // 某单元格的上下文菜单。 int sapgui_apogrid_open_cell_context_menu ( const char *description, const char *gridID, const char *row, const char *column, [args,] LAST ) ;
// sapgui_apogrid_press_ENTER 模拟用户在 APO 网格中按 Enter 键。 int sapgui_apogrid_press_ENTER ( const char *description, const char *gridID, [args,]
LAST ) ;
// sapgui_apogrid_scroll_to_column 模拟 // 用户滚动到 APO 网格中的某列。 // 该函数不选中该列。 int sapgui_apogrid_scroll_to_column ( const char *description, const char *gridID, const char
108
*column, [args,] LAST ) ;
// sapgui_apogrid_scroll_to_row 模拟用户 // 滚动到 APO 网格中的某行。该函数不选中该行。 int sapgui_apogrid_scroll_to_row ( const char *description, const char *gridID, const char *row, [args,] LAST ) ;
// sapgui_apogrid_select_all 全选 APO 网格中的单元格。 int sapgui_apogrid_select_all ( const char *description, const char *gridID, [args,] LAST ) ;
// sapgui_apogrid_select_cell 选中 APO 网格中的一个单元格。 int sapgui_apogrid_select_cell ( const char *description, const char *gridID, const char *row, const char *column, [args,] LAST ) ;
// sapgui_apogrid_select_column 选中 APO 网格中的一列。 int sapgui_apogrid_select_column ( const char *description, const char *gridID, const char *column, [args,] LAST) ;
// sapgui_apogrid_select_context_menu_item 选中 APO 网格的 // 上下文菜单中的一项。 int sapgui_apogrid_select_context_menu_item ( const char *description, const char *gridID, const char *value, [args,] LAST ) ;
// sapgui_apogrid_select_row 选中 APO 网格中的一行。 int sapgui_apogrid_select_row ( const char *description, const char *gridID, const char *row, [args,] LAST ) ;
// sapgui_apogrid_set_cell_data 将 newValue // 分配给 APO 网格中某单元格的内容。 int sapgui_apogrid_set_cell_data ( const char *description, const char *gridID, const char *row, const char *column, const char *newValue, [args,] LAST ) ;
// smtp_abort_mail 取消当前的邮件事务。 // 废弃所有已存储的发件人、收件人和邮件数据。 // 清除所有缓冲区和状态表。 int smtp_abort_mail( );
// smtp_abort_mail_ex 针对特定会话取消 // 当前邮件事务。废弃所有 // 已存储的发件人、收件人和邮件数据。 // 清除所有缓冲区和状态表。
int smtp_abort_mail_ex( SMTP *ppsmtp); // smtp_free 函数释放 SMTP 服务器
109
// 并取消所有挂起命令。 void smtp_free( );
// smtp_free_ex 函数释放 SMTP 服务器 // 并取消所有挂起命令。 void smtp_free_ex (SMTP *ppsmtp);
// smtp_logon 函数登录到 SMTP 服务器。 // 它使用 FTP 协议所用的格式。 int smtp_logon (char *transaction, char *url, [ char *CommonName, char *LogonUser, char *LogonPass,] LAST);
// smtp_logon_ex 函数针对特定会话 // 登录到 SMTP 服务器。 int smtp_logon_ex ( SMTP *ppsmtp, char *transaction, char *url, [ char *CommonName, char *LogonUser, char *LogonPass,] LAST );
// smtp_logout 函数从 SMTP 服务器注销。 int smtp_logout( );
// smtp_logout_ex 函数针对特定会话 // 从 SMTP 服务器注销。 int smtp_logout_ex (SMTP *ppsmtp);
// smtp_send_mail 函数使用 SMTP 服务器发送一封邮件。 int smtp_send_mail (char *transaction, char *RecipientTo, [char *RecipientCC,] [char *RecipientBCC,] char *Subject, [char *From,][char * ContentType, <char * charset,>] char *MAILOPTIONS, char *MAILDATA, LAST);
// smtp_send_mail_ex 函数针对指定会话 // 使用 SMTP 服务器发送一封邮件。 int smtp_send_mail_ex (SMTP *ppsmtp, char *transaction, char *RecipientTo, [char *RecipientCC,] [char *RecipientBCC,] char *Subject,[char *From,] [char * ContentType, < char * charset,>] char *MAILOPTIONS, char *MAILDATA, LAST);
// smtp_translate 函数为 SMTP 服务器 // 转换消息。应指定源文件和目标文件、 // 内容标题和编码类型。 int smtp_translate (char *filename, char *content_header, ENCODING_TYPE encoding, char *output_filename);
// smtp_translate_ex 函数为 SMTP 服务器 // 转换消息。应指定源文件和目标文件、 // 内容标题和编码类型。
110
int smtp_translate_ex (SMTP *ppsmtp, char *filename, char *content_header, ENCODING_TYPE encoding, char *output_filename);
// lrt_abort_on_error 函数 // 在上一个 Tuxedo 函数产生错误时 // 中止当前事务。这意味着事务异常 // 结束。将撤消事务执行过程中 // 对资源所做的所有更改。 void lrt_abort_on_error ( );
// lrt_ClarifyCorrelate 在使用 Clarify CRM 应用程序时 // 由 Vugen 自动生成, // 并将返回的数据 // 保存在对数据库的 DB_OBJNUM 或 DB_OBJIDS 调用 // 的回复缓冲区中。该数据用于关联。
void lrt_ClarifyCorrelate (void *buf, int occurrence, char *param);
// lrt_display_buffer 函数将有关缓冲区的 // 信息存储到输出文件 section_name.out 中。 // 该文件包含每个 // 发送缓冲区和回复缓冲区的缓冲区描述。该信息 // 以以下格式显示: int lrt_display_buffer (const char* bufferName, const char* bufferPtr, long actualLen, long expectedLen );
// lrt_Fadd[32]_fld 函数将新字段 // 添加到 FML 缓冲区。必须将 FML 字段的名称或其字段 ID // 指定为第二个参数。 // 必须在第三个参数中指定新 // FML fielFML 缓冲区的值。字段长度是可选的。 // 只需将 FML 字段的类型指定为 // CARRAY(二进制数据)。其他字段的长度 // 由字段类型和值来确定。 int lrt_Fadd[32]_fld ( FBFR[32] *fbfr, "name=fldname" | "id=idval", "value=fldvalue" [, "len=8"], LRT_END_OF_PARAMS );
// lrt_Finitialize[32] 函数初始化 // 某个现有的 FML 缓冲区。该函数替代 // Tuxedo 函数 Finit 和 Fsizeof 的使用。 int lrt_Finitialize[32] ( FBFR[32] *fbfr );
// lrt_Fname[32] 函数提供从字段标识符 // 到其字段名的运行时转换。 char * lrt_Fname[32] ( FLDID[32] fieldid );
111
// lrt_Fstrerror[32] 函数检索 // 与 FML 错误代码对应的错误消息字符串。 char *lrt_Fstrerror[32] ( int err );
// lrt_getFerror[32] 函数检索上次失败的 // FML 操作的错误代码。在多任务 // 环境中,该函数用于为每个任务 // 提供一个独立的错误状态,而不
// 依赖于全局错误变量 (Ferrno)。 int lrt_getFerror[32] ( void );
// lrt_gettperrno 函数检索 // 上次失败事务的错误代码。在多任务 // 环境中,该函数用于为每个任务 // 提供一个独立的错误状态,而不 // 依赖于全局错误变量 (tperrno)。 int lrt_gettperrno ( void );
// lrt_gettpurcode 函数检索最后 // 一次调用 lrt_tpgetrply、lrt_tpcall、 // lrt_tprecv 或 lrt_tpdequeue 时设置的 // 全局应用程序返回代码变量 (tpurcode)。如果指定, // tpurcode 还将包含使用 lrt_tpenqueue // 发送的“user-return code”的值。 long lrt_gettpurcode ( void );
// lrt_InterateIDCals 在使用 Clarify CRM 应用程序时 // 由 Vugen 自动生成,并将返回的数据保存在 // 对数据库的 AS_EXESVC 调用 // 的回复缓冲区中。该数据用于关联。
void lrt_InterateIDCals (void *buf, int occurrence, char *param);
// lrt_memcpy 函数将指定的字节数 // 从源复制到目标。在复制到目标 // 之前,源保存在一个参数中 // 。该函数与
// C 函数 (memcpy) 功能相同。如果在用户计算机上 // 找不到 C 函数 (memcpy), // 则提供 lrt_memcpy 函数。由于我们使用 C 解释器, // 因此不能假定在每台用户计算机上 // 都可以找到标准 C 库。 void lrt_memcpy ( void *dest, const void *source, unsigned long count );
112
// lrt_save_fld_val 函数将 FML 缓冲区的 // 当前值保存到 paramName 指定的参数中。 // 该函数用于关联脚本中的 // 查询。并不使用查询期间实际获取的 // 结果,而是用一个参数来代替 // 该常量值。之后,同一个脚本中的其他数据库语句 // 可以使用该参数。 int lrt_save_fld_val ( FBFR *fbfr, char *name, FLDOCC occ, char *paramName );
// lrt_save32_fld_val 函数将 FML32 缓冲区的 // 当前值保存到 paramName 指定的参数中。 // 该函数用于关联脚本中的 // 查询。并不使用查询期间实际获取的
// 结果,而是用一个参数来代替 // 该常量值。之后,同一个脚本中的其他数据库语句 // 可以使用该参数。 int lrt_save32_fld_val ( FBFR32 *fbfr, char *name, FLDOCC32 occ, char *paramName );
// lrt_save_parm 函数将字符数组的一部分 // 保存到 parm_name 指定的参数中。该函数 // 保存 parm_len 指定的字符数, // 从 offset 指定的偏移量开始。 int lrt_save_parm ( char *buffer, int offset, int parm_len, char *parm_name );
// lrt_set_carray_error_list 函数设置 // 可用于 CARRAY 回复缓冲区的错误消息 // 列表。使用该函数之前,应在 CARRAY_ERROR_INFO 结构中 // 定义错误消息。 void lrt_set_carray_error_list (CARRAY_ERROR_INFO *newcarrayErrors);
// lrt_set_env_list 函数设置之后可以由 lrt_tuxputenv 设置 // 的变量列表。在调用 lrt_set_env_list // 之后,可以设置 allowedEnv 列表 // 中的环境变量。
void lrt_set_env_list ( char **allowedEnv );
// lrt_strcpy 函数将指定的字符串从 // 源复制到目标。在复制到 // 目标之前,源保存在一个参数中。该 // 函数与 C 函数 (strcpy) 功能相同。 void lrt_strcpy ( char *destString, const char *sourceString );
// lrt_tpabort 函数中止当前的 Tuxedo // 或 System/T 事务。这意味着事务的
113
// 异常结束。将撤消事务执行过程中 // 对资源所做的所有更改。lrt_tpabort // 只能由事务的发起者调用。 int lrt_tpabort ( long flags );
// lrt_tpacall 函数将请求消息发送给 // 指定的服务。这是可以以简要模式打印调试信息的 // 少数几个函数之一。 int lrt_tpacall ( char *svc, char *data, long len, long flags );
// lrt_tpalloc 函数分配新缓冲区,并 // 返回一个指向指定类型缓冲区的指针。由于 // 一些缓冲区类型在使用前 // 需要初始化,因此 lrt_tpalloc 会在分配之后,返回之前 // 初始化缓冲区。 char *lrt_tpalloc ( char *type, char *subtype, long size );
// lrt_tpbegin 函数开始一个 System/T 事务。 // System/T 中的事务是没有完全成功或根本没有生效的 // 工作的一个逻辑单元。 // 此类事务允许由多个进程执行工作, // 而在不同的站点这些进程可能被视为 // 单一的工作单元。事务的发起者可以 // 可以使用 lrt_tpabort 或 lrt_tpcommit // 结束事务。 int lrt_tpbegin(unsigned long timeout, long flags);
// lrt_tpbroadcast 函数允许客户端或服务器 // 将未经请求的消息发送到系统中已注册的客户端。 int lrt_tpbroadcast ( char *lmid, char *username, char *cltname, char * data, long len, long flags );
// lrt_tpcall 函数发送服务请求并等待其回复。 int lrt_tpcall ( char *svc, char *idata, long ilen, char **odata, long *olen, long flags );
// lrt_tpcancel 函数取消调用描述符。 // 在 lrt_tpcancel 之后,调用描述符 cd 不再 // 有效,并将忽略对 cd 的任何回复。任何 // 取消与事务关联的调用描述符的尝试 // 都会产生错误。 int lrt_tpcancel ( int cd );
// lrt_tpchkauth 函数检查应用程序配置 // 是否要求身份验证。这通常由应用程序客户端 // 在调用 lrt_tpinitialize 之前使用,
114
// 以确定是否要求输入密码。 int lrt_tpchkauth ( );
// lrt_tpchkunsol 函数通过检查来确定 // Tuxedo 客户端是否接收到任何未经请求的消息。 int lrt_tpchkunsol ( void );
// lrt_tpcommit 函数提交当前的 System/T 事务。 int lrt_tpcommit ( long flags );
// lrt_tpconnect 函数建立一个半双工 // 会话式服务连接。 int lrt_tpconnect ( char *svc, char *data, long len, long flags );
// lrt_tpdequeue 函数获取用于处理的消息, // 并将其从队列中删除。默认情况下,获取的是队列 // 顶端的消息。要请求一条特定的 // 消息,请在 ctl 中指定消息标识符。 int lrt_tpdequeue ( char *qspace, char *qname, TPQCTL *ctl, char **data, long *len, long flags );
// lrt_tpdiscon 函数断开会话式 // 服务连接。该函数只能由 // 会话的发起者调用。调用 // 该函数之后,您将再也无法在 // 该连接上进行发送或接收。 int lrt_tpdiscon ( int cd );
// lrt_tpenqueue 函数存储要在 qname 指定的队列上 // 处理的消息。 int lrt_tpenqueue ( char *qspace, char *qname, TPQCTL *ctl, char *data, long len, long flags );
// lrt_tpfree 函数释放先前由 // lrt_tpalloc 或 lrt_tprealloc 获取的缓冲区。 void lrt_tpfree ( char *ptr );
// lrt_tpgetlev 函数检查事务是否正在执行。 int lrt_tpgetlev ( ) ;
// lrt_tpgetrply 函数返回上次所发送请求的回复。 int lrt_tpgetrply ( int *cd, char **data, long *len, long flags );
// lrt_tpgprio 函数返回上次发送或接收 // 的请求的优先级。优先级范围 // 从 1 到 100,最高优先级为 100。
115
int lrt_tpgprio ( );
// lrt_tpinitialize 函数使客户端可以加入 System/T // 应用程序。该函数将替换 TVG_tpinit 函数。 int lrt_tpinitialize (["usrname=value",] ["cltname=value", ] ["passwd=value", ] [grpname=value,] [flags= value, ] [datalen=value, ] [data=value, ] LRT_END_OF_PARAMS );
// lrt_tprealloc 函数更改类型化缓冲区的大小。 char * lrt_tprealloc ( char *ptr, long size );
// lrt_tprecv 函数通过打开的连接接收 // 发自另一个程序的数据。它 // 与 lrt_tpsend 结合使用, // 且只能由对该连接没有控制权的
// 程序发出。该函数可以以简要 // 模式打印调试信息。 int lrt_tprecv ( int cd, char **data, long *len, long flags, long *revent );
// lrt_tpresume 函数继续执行全局事务。它 // 与 lrt_tpsuspend 语句结合使用。 int lrt_tpresume ( TPTRANID *tranid, long flags );
// lrt_tpscmt 函数与 lrt_tpcommit 结合使用, // 设置 lrt_tpcommit 应在何时返回。 int lrt_tpscmt ( long flags );
// lrt_tpsend 函数通过打开的连接 // 将消息发送到另一个程序。调用方 // 必须拥有连接控制权。它与 // lrt_tprecv 结合使用。该函数可以以 // 简要模式打印调试信息。 int lrt_tpsend ( int cd, char *data, long len, long flags, long *revent );
// lrt_tpsetunsol 函数 // 设置在接收到未经请求的消息时调用的回调过程。 // 回调过程必须在外部 DLL 中定义, // 并具有以下原型: void *lrt_tpsetunsol ( void *func );
// lrt_tpsprio 函数设置下一个 // 发送或转发请求的优先级。 int lrt_tpsprio ( int prio, long flags );
// lrt_tpstrerror 函数检索 System/T 错误
116
// 的错误消息字符串。 char *lrt_tpstrerror ( int err );
// lrt_tpsuspend 函数挂起全局事务。 // 它与 lrt_tpresume 语句结合使用。 int lrt_tpsuspend ( TPTRANID *tranid, long flags );
// lrt_tpterm 函数从 System/T 应用程序中 // 删除客户端。如果客户端处于事务 // 模式,则回滚该事务。 int lrt_tpterm ( );
// lrt_tptypes 函数确定有关类型化缓冲区的信息。 long lrt_tptypes ( char *ptr, char *type, char *subtype );
// lrt_tuxgetenv 函数在环境列表中搜索与环境名称 // 相对应的值 // 。在通常没有环境变量的平台上, // 该函数对不同平台间环境值的
// 可移植性非常有用。 char *lrt_tuxgetenv ( char *name );
// lrt_tuxputenv 函数更改现有 // 环境变量的值,或者新建一个变量。 // 使用 lrt_set_env_list 确定 // 可以设置的变量。在通常没有环境变量的平台上, // 该函数对不同平台间环境值的 // 可移植性非常有用。默认 // 情况下,lrt_tuxputenv 只允许更改 WSNADDR, // 使用 lrt_set_env_list 时除外。 int lrt_tuxputenv (char *string);
// lrt_tuxreadenv 函数读取包含 // 环境变量的文件,并将其添加到环境中。 // 在通常没有环境变量的平台上, // 该函数对不同平台间环境值的 // 可移植性非常有用。 int lrt_tuxreadenv ( char *file, char *label );
// lrt_tx_begin 函数开始一个全局事务。 int lrt_tx_begin ( );
// lrt_tx_close 函数关闭一组资源管理器。 // 该函数与 lrt_tx_open 结合使用。
117
int lrt_tx_close ( );
// lrt_tx_commit 函数提交一个全局事务。 int lrt_tx_commit ( );
// lrt_tx_info 函数返回全局事务信息。 int lrt_tx_info ( TXINFO *info );
// lrt_tx_open 函数打开一组资源管理器。 // 该函数与 lrt_tx_close 结合使用。 int lrt_tx_open ( );
// lrt_tx_rollback 函数回滚一个全局事务。 int lrt_tx_rollback ( );
// lrt_tx_set_commit_return 函数将 commit_return // 特征设置为 when_return 中指定的值。 int lrt_tx_set_commit_return ( COMMIT_RETURN when_return );
// lrt_tx_set_transaction_control 函数将 transaction_control // 特征设置为 control 中指定的值。 int lrt_tx_set_transaction_control ( TRANSACTION_CONTROL control );
// lrt_tx_set_transaction_timeout 函数将 transaction_timeout // 特征设置为 timeout 中指定的值。 int lrt_tx_set_transaction_timeout ( TRANSACTION_TIMEOUT timeout );
// lr_advance_param 函数使脚本使用 // 参数的下一个可用值。如果要 // 运行多次循环,可以在 // 参数属性中指定自动前进到
// 每次循环的下一个值。在某次循环中使用该函数 // 可前进到下一个值。 int lr_advance_param ( const char * param);
// lr_abort 函数中止脚本 // 的执行。它停止 Actions 部分的执行, // 执行 vuser_end 部分,然后 // 结束该执行。当因特定的错误情况 // 需要手动中止运行时, // 该函数非常有用。使用该函数 // 结束运行时,状态为“停止”。 void lr_abort( );
118
// lr_continue_on_error 函数指定如何 // 处理错误。如果发生错误,可以选择 // 继续运行,或者中止运行执行。 void lr_continue_on_error ( int value );
// lr_convert_string_encoding 在下列编码 // 之间转换字符串编码:系统区域设置、Unicode 和 UTF-8。 // 该函数将结果字符串(包括其终止 // 结果字符串 NULL)保存在参数 paramName 中。 int lr_convert_string_encoding ( const char *sourceString, const char *fromEncoding, const char *toEncoding, const char *paramName);
// lr_debug_message 函数在指定的消息级别 // 处于活动状态时发送一条调试消息。如果指定的 // 消息级别未处于活动状态,则不发出消息。 // 您可以从用户界面 // 或者使用 lr_set_debug_message,将处于活动状态的消息级别 // 设置为 MSG_CLASS_BRIEF_LOG 或 MSG_CLASS_EXTENDED_LOG。要确定当前级 别, // 请使用 lr_get_debug_message。 int lr_debug_message (unsigned int message_level, const char * format, ... );
// lr_decrypt 函数对已编码的字符串进行解密。 // 该函数在录制过程中生成,以便 // 对密码进行编码。VuGen 录制实际的密码, // 但在 lr_decrypt function 函数中
// 显示密码的编码版本。 char * lr_decrypt (const char *EncodedString);
// lr_disable_ip_spoofing 在脚本运行过程中禁用 IP 欺骗。 int lr_disable_ip_spoofing ( );
// lr_enable_ip_spoofing 在脚本运行过程中启用 IP 欺骗。 int lr_enable_ip_spoofing ( );
// lr_end_sub_transaction 函数标记 // 子事务的结束。要标记子事务的 // 开始,请使用 lr_start_sub_transaction // 函数。应紧接子事务步骤前后 // 插入这些函数。 int lr_end_sub_transaction (const char * sub_transaction, int status );
// lr_end_transaction 函数标记事务的 // 结束,并录制执行事务
119
// 所用的时间量。要指明希望分析的事务, // 请在事务之前放置 lr_start_transaction // 函数,并在事务之后 // 放置 lr_end_transaction 函数。
int lr_end_transaction (const char * transaction_name, int status ) ;
// lr_end_transaction_instance 函数标记 // 事务实例的结束,并录制 // 执行事务所用的时间量。要指明 // 希望分析的事务实例,请在
// 事务之前放置 lr_start_transaction_instance 函数, // 并在事务之后 // 放置 lr_end_transaction_instance 函数。 int lr_end_transaction_instance (long parent_handle, int status );
// lr_end_timer 停止在调用 lr_start_timer 时开始计时的 // 计时器。它以秒为单位返回已用时间。 // 分辨率取决于运行时环境。 // 最大分辨率为一微秒。
double lr_end_timer (merc_timer_handle_t timer);
// lr_eval_string 函数在评估任何嵌入的参数之后 // 返回输入字符串。如果字符串 // 实参 (argument) 只包含一个形参 (parameter),该函数 // 返回形参的当前值。 char * lr_eval_string (const char * instring );
// lr_eval_string_ext 函数通过将参数替换为 // 字符串值来评估 in_str。 // 它创建包含扩展字符串的缓冲区, // 并将 out_str 设置为指向该缓冲区。它还 // 将缓冲区的长度分配给 out_len。
int lr_eval_string_ext (const char * in_string, unsigned long const in_len, char ** const out_str, unsigned long * const out_len, unsigned long const options, const char *file, long const line );
// lr_eval_string_ext_free 函数释放 // lr_eval_string_ext 分配的内存。 void lr_eval_string_ext_free (const char **param);
// lr_error_message 函数将错误消息发送到 // 输出窗口和 Vuser 日志文件。要发送 // 不是特定错误消息的特殊通知, // 请使用 lr_output_message。
int lr_error_message (const char * format, exp1, exp2,...expn. );
120
// 使用 lr_exit 函数可在执行过程中 // 退出脚本运行。 void lr_exit (int continuation_option, int exit_status);
// lr_fail_trans_with_error 函数使用 // lr_end_transaction 语句中的 LR_AUTO,将所有 // 打开事务的默认退出状态设置为 LR_FAIL, // 并发送错误消息。 int lr_fail_trans_with_error (const char * format, exp1, exp2,...expn.);
// lr_get_attrib_double 函数返回 // 命令行参数的值,其类型为 // 双精度浮点型。应将命令行参数的名称 // 放置在函数的实参 (argument) 字段,lr_get_attrib_double 将返回 // 该参数的值。 double lr_get_attrib_double (const char * parameter);
// lr_get_attrib_long 函数返回 // 命令行参数的值,其类型为长整型。 // 应将命令行参数名称放置在 // 函数的实参 (argument) 字段,lr_get_attrib_long // 将返回该参数的值。 long lr_get_attrib_long (const char * parameter);
// lr_get_attrib_string 函数返回命令行 // 参数字符串。应将参数名称放置在函数的 // argument 字段,lr_get_attrib_string 将返回 // 与该参数关联的字符串值。 char * lr_get_attrib_string (const char * argument);
// lr_get_debug_message 函数返回当前的 // 日志运行时设置。该设置确定 // 发送到输出端的信息。日志设置是 // 使用运行时设置对话框或通过使用
// lr_set_debug_message 函数指定的。 unsigned int lr_get_debug_message ( );
// lr_get_host_name 函数返回 // 执行脚本的计算机的名称。 char * lr_get_host_name ( );
// lr_get_vuser_ip 函数返回 Vuser 的 // IP 地址。执行 IP 欺骗时,每个 Vuser 都
121
// 可以使用不同的地址。使用该函数可以确定 // 当前 Vuser 的 IP 地址。 char * lr_get_vuser_ip( );
// lr_get_master_host_name 函数返回运行 // 控制器或优化模块控制台的计算机的名称。 char * lr_get_master_host_name ( );
// lr_get_transaction_duration 函数返回 // 到该点为止指定事务的持续时间(秒) // 。使用该函数可确定 // 事务结束前的总 // 事务时间。lr_get_transaction_duration 只针对打开事务返回 // 大于零的值。 double lr_get_transaction_duration (const char * transaction);
// lr_get_transaction_status 返回事务的 // 当前状态。不能在 lr_end_transaction 之后 // 调用 lr_get_transaction_status。由于 lr_get_transaction_status // 只能返回打开事务的状态,因此 // 无法报告最终的事务状态。 int lr_get_transaction_status ( const char *transaction_name ) ;
// lr_get_trans_instance_status 返回事务实例的 // 当前状态。不能在 lr_end_transaction_instance 之后 // 调用 lr_get_trans_instance_status。它 // 无法报告最终的事务实例状态。 int lr_get_trans_instance_status ( long transaction_handle ) ;
// lr_get_trans_instance_duration 函数返回 // 到该点为止打开事务实例的持续 // 时间(秒)。使用该函数可确定事务结束前 // 的总事务时间。 double lr_get_trans_instance_duration (long trans_handle);
// lr_get_transaction_think_time 函数返回 // 到该点为止指定事务的 // 思考时间。它只针对打开事务返回 // 大于零的值。
double lr_get_transaction_think_time (const char * transaction);
// lr_get_trans_instance_think_time 函数返回 // 到该点为止指定事务的思考时间。 double lr_get_trans_instance_think_time (long trans_handle);
122
// lr_get_transaction_wasted_time 函数返回 // 到该点为止指定事务的浪费时间(秒)。 double lr_get_transaction_wasted_time (const char * transaction);
// lr_get_trans_instance_wasted_time 函数返回 // 到该点为止指定事务的浪费时间。 double lr_get_trans_instance_wasted_time (long trans_handle);
// lr_load_dll 函数加载 DLL (Windows) // 或共享对象 (UNIX),使您可以在 // 使用 C 解释器回放时调用外部函数。加载 // DLL 之后,您就可以调用 DLL 中定义的 // 任何函数,而不必声明。 int lr_load_dll (const char *library_name );
// lr_log_message 函数将消息发送到 // Vuser 或代理日志文件(取决于应用程序), // 而不是发送到输出窗口。通过向日志文件发送错误消息或 // 其他信息性消息,可以将 // 该函数用于调试。 int lr_log_message (const char * format, exp1, exp2,...expn.);
// lr_message 函数将消息发送到日志文件和 // 输出窗口。在 VuGen 中运行时,输出文件为 output.txt。 int lr_message (const char * format, exp1, exp2,...expn.);
// lr_output_message 函数将带有脚本部分和行号的消息 // 发送到输出窗口和日志文件。 int lr_output_message (const char * format, exp1, exp2,...expn.);
// lr_next_row 函数获取指定文件中参数的 // 下一个可用行的值。如果 // 要运行多次循环,可以在参数 // 属性中指定前进到每次循环
// 的下一行。在特定循环中使用 // 该函数,可以前进到下一组值。 int lr_next_row ( const char * dat_file );
// lr_param_increment 函数检索 // source_param 的值,并以 1 为单位递增其值, // 然后将递增后的值作为 null 终止字符串 // 存储在 destination_param 中。 int lr_param_increment (const char * destination_param, const char * source_param);
123
// lr_peek_events 函数用于在脚本执行期间 // 的特定时刻接收事件。应将该函数 // 插入到 Vuser 程序中希望 Vuser 暂停的 // 位置。如果脚本中不
// 包含 lr_peek_events 函数,您将无法 // 暂停 Vuser。 void lr_peek_events ( );
// lr_rendezvous_ex 函数在 Vuser 脚本中创建 // 一个集合点。执行该语句时, // Vuser 程序会停止并等待 LoadRunner 赋予 // 权限以便继续。
int lr_rendezvous_ex (const char * rendezvous_name);
// lr_rendezvous 函数在 Vuser 脚本中 // 创建一个集合点。执行该语句时, // Vuser 程序会停止并等待 LoadRunner 赋予 // 权限以便继续。 int lr_rendezvous (const char * rendezvous_name);
// lr_resume_transaction 函数继续执行 // 被 lr_stop_transaction 挂起的脚本中 // 事务数据的报告。调用 lr_stop_transaction 之后, // “get”事务函数返回的统计信息 // 只反映该调用之前的数据, // 直到调用此函数。 void lr_resume_transaction (const char * transaction_name);
// lr_resume_transaction_instance 函数可以继续报告由 // lr_stop_transaction_instance 挂起的脚本中的 // 事务数据。 // 调用 lr_stop_transaction_instance 后,
// “get”事务函数返回的统计信息 // 只反映该调用之前的数据,直到调用 // 此函数。 void lr_resume_transaction_instance ( long trans_handle );
// lr_save_datetime 函数将当前日期 // 和时间,或具有指定偏移的日期和时间 // 保存在参数中。如果达到 MAX_DATETIME_LEN 个字符, // 结果字符串将截断。 void lr_save_datetime(const char *format, int offset, const char *name);
124
// lr_save_searched_string 函数在字符串 // 或字符数组缓冲区中搜索字符串 search_string, // 并找到 search_string 第 n 次出现的位置,其中 // n 为 occurrence 加 1。要保存的子字符串 // 从 search_string 第 n 次出现位置的末尾偏移 offset 处开始, // 长度为 string_len。 int lr_save_searched_string (const char *buffer, long buf_size, unsigned int occurrence, const char *search_string, int offset, unsigned int string_len, const char *parm_name );
// lr_save_string 函数将指定的以 null 终止的 // 字符串赋给参数。该函数可用于关联 // 查询。要确定参数值,请使用 // 函数 lr_eval_string。
int lr_save_string (const char *param_value, const char *param_name);
// lr_save_var function 函数将指定的变长 // 字符串赋给参数。该函数可用于 // 关联查询。要确定参数值, // 请使用函数 lr_eval_string。
int lr_save_var (const char * param_value, unsigned long const value_len, unsigned long const options, const char * param_name);
// lr_set_debug_message 函数设置脚本 // 执行的调试消息级别 message_lvl。通过设置 // 消息级别,可以确定发送哪些 // 信息。启用设置的方法是将 LR_SWITCH_ON 作为 on_off 传递, // 禁用设置的方法是传递 LR_SWITCH_OFF。 int lr_set_debug_message (unsigned int message_level, unsigned int on_off);
// lr_set_transaction 函数用于在一次调用中 // 创建事务、其持续时间及 // 状态。如果要在事务中捕获的 // 业务流程不由顺序步骤组成,
// 或者是否要创建事务视 // 只有在测试过程中才可知的条件而定, // 请使用该函数。 int lr_set_transaction(const char *name, double duration, int status);
// lr_set_transaction_instance_status 函数使用 // 事务句柄为 trans_handle 设置打开事务的 // 状态。该句柄由 // lr_start_transaction_instance 返回。
int lr_set_transaction_instance_status (int status, long trans_handle);
125
// lr_set_transaction_status 函数设置 // 那些在其 lr_end_transaction 语句中包含 LR_AUTO 的 // 当前打开事务的状态。 int lr_set_transaction_status (int status);
// lr_set_transaction_status_by_name 函数使用 // 名称 trans_name 设置打开事务的 // 默认状态。该事务的 lr_end_transaction // 语句必须使用自动状态分配,方法是
// 将 LR_AUTO 作为其 status 参数传递。 int lr_set_transaction_status_by_name (int status, const char *trans_name);
// lr_start_transaction 函数标记 // 事务的开始。要指明要分析的 // 事务,请使用函数 lr_start_transaction 和 // lr_end_transaction。应紧接事务前后 // 插入这些函数。 int lr_start_transaction ( const char * transaction_name );
// lr_start_transaction_instance 函数标记 // 事务实例的开始。事务 // 实例是名为 transaction_name 的事务的一次 // 发生。实例由它们的句柄 // 标识,句柄使它们区别于 // 同一事务的其他实例。 long lr_start_transaction_instance ( const char * transaction_name, long handle);
// lr_start_sub_transaction 函数标记 // 子事务的开始。要标记子事务 // 的结束,请使用 lr_end_sub_transaction。 // 请紧接子事务操作前后 // 插入这些函数。 int lr_start_sub_transaction (const char * sub_transaction, const char * parent_transaction);
// 调用 lr_stop_transaction 后, // “get”事务函数返回的统计信息只反映 // 该调用之前的数据,直到调用 lr_resume_transaction // 。指定的事务必须已 // 使用 lr_start_transaction 打开。 double lr_stop_transaction (const char * transaction_name);
// 调用 lr_stop_transaction_instance 后, // “get”事务函数返回的统计信息 // 只反映该调用之前的数据,直到调用 lr_resume_transaction_instance
126
// 。指定的事务实例 // 必须已使用 lr_start_transaction_instance 打开。 double lr_stop_transaction_instance (long parent_handle);
// 通过 lr_think_time 可以在运行期间暂停测试 // 执行。这对于模拟思考时间非常有用, // 思考时间是真实用户在操作之间停下来思考的时间。 void lr_think_time (double time);
// 通过函数 lr_user_data_point,可以记录 // 自己的数据以进行分析。每次要记录一个点 // 时,请使用该函数记录采样名称和 // 值。将自动记录采样的时间。 // 执行后,可以使用用户定义的数据 // 点图形来分析结果。 int lr_user_data_point (const char * sample_name, double value);
// 除附加参数 log_flag 之外,函数 lr_user_data_point_ex // 与 lr_user_data_point 相同。 int lr_user_data_point_ex ( const char *sample_name, double value, int log_flag);
// 除参数 transaction_handle(通过该参数可以 // 将数据点与某个特定事务实例关联起来)之外, // 函数 lr_user_data_point_instance // 与 lr_user_data_point 相似。 long lr_user_data_point_instance (const char * sample_name, double value, long transaction_handle);
// 除附加参数函数 log_flag 之外,函数 // lr_user_data_point_instance_ex 与 // lr_user_data_point_instance 相同。 long lr_user_data_point_instance_ex (const char*sample_name, double value, long transaction_handle, int log_flag);
// lr_vuser_status_message 函数向控制器 // 或优化模块控制台的 Vuser 窗口的“状态”区域 // 发送字符串。它还将该字符串 // 发送到 Vuser 日志。从 VuGen 运行时, // 消息被发送到 output.txt。 int lr_vuser_status_message (const char * format);
// 通过 lr_wasted_time 可以从所有打开事务中 // 减去在偶然或次要的操作上浪费的时间。 void lr_wasted_time (long time);
127
// lr_whoami 函数获取关于 Vuser 的信息。 void lr_whoami (int *vuser_id, char **sgroup, int *scid);
// radius_account 模拟 RAS 或 NAS 服务器,该服务器 // 向 RADIUS 服务器发送记帐信息。 // 请将其插入在 radius_authenticate 调用之后、 // WAP 会话之前或过程中。
int radius_account(const char *AccountName, const char *Action, <List of Arguments>, LAST);
// radius_authenticate 模拟 RAS 或 NAS 服务器,该服务器 // 在允许用户访问 WAP 网关之前, // 向 RADIUS 服务器发送用户的身份验证信息。 // 请将其插入在调用 wap_connect 之前。
int radius_authenticate(<List of Arguments>, LAST);
// radius_get_last_error 返回最近的 RADIUS // 函数调用的错误代码。 int radius_get_last_error ();
// radius_set_timeout 为函数 radius_authenticate // 和 radius_account functions 设置连接超时值。它 // 会覆盖 RADIUS 运行时设置中的超时值 // 设置。参数 Timeout 是以秒为单位的超时值 // 的字符串表示。例如“5”。 int radius_set_timeout (const char *Timeout);
// wap_add_const_header 函数向常量头列表中 // 添加一个头。当建立 CO 类型的连接时,这些头 // 被传送至网关。 int wap_add_const_header ( const char *mpszHeader, const char *mpszValue );
// wap_bearer_down 可以断开与承载网络的连接。 // 载体是 WAP 网络的最底层服务。 // 有关详细信息,请参阅 wap_bearer_up。 int wap_bearer_down();
// wap_bearer_up 可以连接到承载网络。承 // 载体是 WAP 网络的最底层服务。 // 当测试只包括 SMS 消息时该函数非常有用, // 使您不必使用 wap_connect 连接至 // WAP 网关。 int wap_bearer_up();
128
// wap_connect 函数可以连接至 WAP 网关,网关的 // IP 地址和端口在运行时设置中指定。 int wap_connect ( );
// wap_disconnect 函数可以断开与 WAP 网关的连接。 // 连接是通过调用 wap_connect 或 web_url 打开的。 int wap_disconnect ( );
// wap_format_si_msg 函数可以格式化 SI 类型的消息。 int wap_format_si_msg (const char * mpszURL, const char * Slid, const char * mpszCreated, const char * mpszExpires, const char * mpszAction, const char * mpszUserMsg, char * mpsfOutputMsg, unsigned int miOutputMsglen );
// wap_format_sl_msg 函数可以格式化 SL 类型的消息。 int wap_format_sl_msg (const char * mpszURL, const char * mpszAction, char * mpsfOutputMsg, unsigned int miOutputMsglen );
// wap_mms_msg_decode 函数可以将字符串转换为 // MMS 消息对象。通常,该字符串 // 是接收到的 HTTP 消息的正文。 int wap_mms_msg_decode(void **MMSObject, const char *ParamName);
// wap_mms_msg_encode 函数可以将 // wap_mms_msg_create 创建的 MMS 消息对象 (MMSObject) // 转换为字符串,该字符串随后可用于 Web 操作函数。 // 该方法不同于使用 wap_mms_msg_submit // 或 as_wap.h 头文件中的其他宏,后者 // 直接接受 MMS 消息对象。 int wap_mms_msg_encode(void *MMSObject, const char *ParamName);
// wap_mms_msg_get_field 从 MMSObject 中 // 检索指定字段 FieldName 的值, // 并将其存储在参数 ParamName 中。 int wap_mms_msg_get_field(void *MMSObject, const char *FieldName, const char *ParamName);
// wap_mms_msg_get_multipart_entry 从 MMSObject // 中的多部分项 EntryNumber 中 // 检索指定字段 FieldName 的值, // 并将其存储在参数 ParamName 中。
int wap_mms_msg_get_multipart_entry(void *MMSObject, unsigned int EntryNumber, const char *FieldName, const char *ParamName);
// wap_mms_msg_number_multipart_entries 可以检索
129
// MMSObject 中多部分项的数目。 int wap_mms_msg_number_multipart_entries(void *MMSObject, unsigned int *NumberOfEntries);
// wap_pi_push_submit 函数可以向 PPG 提交一个“推”消息。 int wap_pi_push_submit(const char * mpszName, const char * mpszURL, const char * mpszPushID, const char * mpszClientAddress, const char * mpszDeliverBefore, const char * mpszDeliverAfter, const char * mpszMsgSource, const char * mpszMsgType, const char * mpszMsgContent);
// wap_pi_push_submit_ex 函数可以向 PPG 提交一个“推”消息。 int wap_pi_push_submit_ex(const char * mpszName, const char * mpszURL, const char * mpszPushID, const char * mpszClientAddress, const char * mpszDeliverBefore, const char * mpszDeliverAfter, const char * mpszMsgSource, const char * mpszMsgType, const char * mpszMsgContent [, CustomAttributes]);
// wap_pi_push_cancel 函数可以取消一个发送到 PPG 的消息。 int wap_pi_push_cancel(const char * mpszName, const char * mpszURL, const char * mpszPushID, const char * mpszClientAddress);
// wap_radius_connection 已过时。请使用 // radius_authenticate 和 radius_account。 int wap_radius_connection (const char * mpszAction, <List of Arguments>, LAST);
// wap_set_bearer 函数可以设置用于重放 // UDP 或 CIMD2 (SMS) 的载体类型。脚本使用该 // 载体类型,直到脚本结束或 // 再一次调用函数 wap_set_bearer 进行设置。 int wap_set_bearer ( const char *mpszBearer );
// wap_set_capability 函数可以设置网关连接的 // 客户端容量。建立网关连接时, // 将对这些容量进行协商。 int wap_set_capability ( const char *mpszCap );
// wap_set_connection_mode 函数可以设置会话的连接 // 模式和安全级别。需要指明 // 连接的连接模式类型 // 和安全级别。该函数只对以后的
// 连接有效。如果连接已经建立, // 则忽略该函数。 int wap_set_connection_mode( const char * const char * SecurityLevel);
ConnectionMode,
130
// wap_set_connection_options 可以设置:IP 地址和端口 // (通过它们与网关通信)、连接 // 模式、安全级别和载体类型 int wap_set_connection_options( const char *argument_list, ..., LAST);
// wap_set_gateway 函数可以设置 IP 地址和 // 端口,通过它们可以与网关通信。 int wap_set_gateway( const char * GateWayIP, const char * GateWayPort );
// wap_set_sms_user 可以设置 SMS 载体 // 的登录信息。可以在“运行时设置”的 // “网关”选项卡中设置载体的端口和 // 登录信息。该函数必须位于 wap_connect // 或第一个 web_url 函数之前。
int wap_set_sms_user (const char *argument_list, ..., LAST);
// wap_wait_for_push 函数等待一个“推”消息 // 到达。如果超时前有消息到达, // 则解析该消息,以确定其类型和 // 消息属性的值。如果解析成功,
// 客户端会发出一个“拉”消息,以检索 // 相关数据。通过配置运行时设置,可以禁用“拉”事件, // 指明不检索消息 // 数据。在文件 default.cfg 中找到 // WAP 部分。将标志 PushRetrieveMsg 设置为 // 1 可以检索消息(默认),设置为 0 可以 // 禁止消息。 int wap_wait_for_push ( );
// wap_mms_msg_destroy 函数可以销毁 // 使用 wap_mms_msg_create 或 wap_mms_msg_decode 创建的消息。 // 请在已确认消息后将该函数放置在 // 脚本末尾。如果会话结束时 // 不销毁 MMS 消息,它将使用额外 // 资源并影响性能。 int wap_mms_msg_destroy (void * MMSObject );
// wap_mms_msg_create 函数可以创建消息。 // 请在建立与服务器的连接后 // 将该函数放置在脚本开头。 // 在会话结束时,请使用函数 wap_mms_msg_destroy // 销毁该消息。
int wap_mms_msg_create (void **MMSObject );
131
// wap_mms_msg_add_field 函数可以向 MMS 消息添加消息字段, // 添加的内容包括字段名和值。可以 // 在脚本中多次使用该函数。 int wap_mms_msg_add_field (void * MMSObject, const char * FieldName, const char * FieldValue );
// wap_mms_msg_add_multipart_entry 函数可以向 MMS 消息 // 添加多部分项。项 // 可以是字符串(在最后一个参数中指定), // 也可以是外部文件。可以在脚本中
// 多次使用该函数。 int wap_mms_msg_add_multipart_entry (void ** MMSObject, const char *DataSource, const char * ContentType, const char *Headers, const char * Data );
// wap_mms_msg_retrieve 函数可以向 MMS 中心 // 发送请求,以获得 URL 处的消息。MMS // 中心将消息写入 Message。它作为 // 文件 as_wap.h 中的一个宏实现。
void wap_mms_msg_retrieve (Name, URL, Message); /* MACRO (char*, char*, void**) */
// wap_mms_msg_retrieve_by_push 函数等待 // “推”消息到达。收到 // 该消息后,客户端将发出一个“拉”消息, // 以检索相关数据。 void wap_mms_msg_retrieve_by_push (Message); /* MACRO (void**) */
// wap_mms_msg_submit 函数可以向 MMS 服务器 // 发送消息 MMSMessage。它作为 // 文件 as_wap.h 中的一个宏实现。 void wap_mms_msg_submit (Name, URL, Message); /* MACRO (char*, char*, void*) */
// wap_mms_msg_submit 函数使用指定的内容类型 // 向 MMS 服务器发送消息 MMSMessage。它作为 // 文件 as_wap.h 中的一个宏实现。 void wap_mms_msg_submit_enc (Name, URL, Message, EncodingType ); /* MACRO (char*, char*, void*, char*) */
// wap_mms_msg_submit_and_receive_enc 函数使用指定的 // 内容类型向 MMS 服务器发送消息 Message, // 并在返回前同步接收响应 // ReceivedMMS。它作为
// 文件 as_wap.h 中的一个宏实现。 void wap_mms_msg_submit_and_receive_enc (Name, URL, Message, ReceivedMMS, EncodingType ); /* MACRO (char*, char*, void*, void**, char*) */
132
// wap_mms_msg_submit_and_receive 函数向 MMS 服务器 // 发送消息 Message,并在返回前 // 同步接收响应 ReceivedMMS。 // 它作为文件 as_wap.h 中的一个宏实现。
void wap_mms_msg_submit_and_receive(Name, URL, Message, ReceivedMMS); /* MACRO (char*, char*, void*, void**) */
// wap_push_msg_get_field 从最近收到的 // “推”消息中检索字段 FieldName 的值。 // 检索到的值存储在参数 ParamName 中。 int wap_push_msg_get_field(const char *FieldName, const char *ParamName);
// wap_send_sms 函数向指定地址发送一个 SMS // 类型的消息。 int wap_send_sms (const char * List of Arguments, LAST);
// web_add_auto_header 函数是一个服务函数,
// 它向所有后续 HTTP 请求添加头。 int web_add_auto_header (const char *Header, const char *Content );
在接下来的所有请求中都增加该自定义header实例
web_add_auto_header("Cdn-Src-Ip","{ip01}.{ip02}.{ip03}.{ip04}");
特别注意的是带循环的时候 web_add_auto_header的使用
// web_add_cookie 函数可以添加新的 Cookie。如果 // 名称和路径与现有 Cookie 匹配,则现有 // Cookie 被新 Cookie 覆盖。如果已过“过期” // 日期,则删除该 Cookie。
int web_add_cookie (const char *Cookie);
// web_add_filter 指定下载下一个操作函数中的内容时 // 要使用的筛选器。 // 筛选器将包含或排除含有匹配条件的 URL, // 视传递到该函数的 Action 属性
// 而定。默认 // 操作为“Action=Exclude”。 int web_add_filter ( [Action,]< List of Attributes >, LAST ) ;
// web_add_auto_filter 指定下载随后发生的操作函数的内容 // 时要使用的筛选器。 // 调用 web_remove_auto_filter 后,将禁用 // 该筛选器。筛选器将包含或排除含有匹配条件的 URL, // 视传递到该函数的 Action 属性
// 而定。默认 // 操作为“Action=Exclude”。 int web_add_auto_filter ( [Action,]< List of Attributes >, LAST);
133
// web_remove_auto_filter 函数可以禁用 // 上次调用 web_add_auto_filter 时的筛选器设置。 int web_remove_auto_filter ( char *Id, LAST );
// web_add_header 函数是一个服务函数,仅仅在接下来的请求中增加header// 它向下一个 HTTP 请求添加用户定义的头。 int web_add_header (const char *Header, const char *Content );
// web_cache_cleanup 函数是一个服务函数, // 它清除缓存模拟程序中的内容。 // 如果在“浏览器模拟”选项卡上启用运行时 // 设置选项“每次循环时模拟一个新用户”, // 则该函数会在每次循环开始时
// 自动调用。 int web_cache_cleanup();
// web_cleanup_auto_headers 函数是一个 // 服务函数,它会禁止向后续 HTTP 请求 // 添加用户定义的头。 int web_cleanup_auto_headers ( );
// web_cleanup_cookies 函数删除脚本使用的 // 所有当前存储的 Cookie。 int web_cleanup_cookies ( );
// web_concurrent_end 函数可以标记 // 并发组的结束,并开始并发执行所有注册 // 为并发的函数(位于函数 // web_concurrent_start 和 // web_concurrent_end 之间的函数)。 // 单击“并发函数”,以查看并发组中可能 // 包含的函数的列表。 int web_concurrent_end ( reserved );
// // // // // // // // int web_concurrent_start ( [char * ConcurrentGroupName,] NULL );
web_concurrent_start 函数可以 标记并发组的开始。组中的所有函数 均并发执行。组的结束由函数
web_concurrent_end 标记。在并发组 中可以包含操作函数和几个服务函数。 单击“并发函数”,以查看并发组中可能 包含的函数的列表。
loadrunner中web_concurrent_start和web_concurrent_end的作用
http://blog.sina.com.cn/s/blog_6143161901010llv.html
简单的说：
这两个函数是在URL中标记一个页面请求的，注意：这里我说的是页面（page），并不是请求。
在LR请求一个页面里，由于使用URL的方式录制，会把一个页面中的元素分成几个web函数做处理。所以，LR中实现了web_concurrent_start和web_concurrent_end。
实现的作用是：
从web_concurrent_start开始标记，当脚本运行到web_concurrent_start时，后续的脚本都不会立即被执行，直到web_concurrent_end出现。才把这中间的所有的脚本一起执行。所谓并发组也是指把这一组函数一起执行起来。
如果用 lr_start_transaction和 lr_end_transaction来替换，脚本完全可以跑通。中间的脚本是从上到下执行的，而不是一起执行的。
134
// web_convert_param 函数将 HTML 文本 // 转换为纯文本或 URL,或将纯文本转换为 URL。 int web_convert_param (const char *ParamName, [char *SourceString] char *SourceEncoding, char *TargetEncoding, LAST);
// web_create_html_param 函数是一个服务 // 函数,用于在 Web 脚本中关联 HTML 语句。 // 函数 web_create_html_param // 检索重放期间生成的动态信息,然后将 // 第一次出现的动态信息保存在某个 // 参数中。 int web_create_html_param (const char *ParamName, const char *LeftBoundary, *RightBoundary );
const char
// web_create_html_param_ex 函数是一个服务 // 函数,用于在 Web 脚本中关联 HTML 语句。 // 函数 web_create_html_param_ex 检索重放 // 期间生成的动态信息,然后将该动态信息保存在 // 某个参数中。 int web_create_html_param_ex (const char *ParamName, const char *LeftBoundary, *RightBoundary, const char *Instance );
const char
// web_custom_request 函数是一个操作函数, // 通过它可以使用任意方法创建自定义 HTTP 请求 // 或创建正文。默认情况下,VuGen 只为无法 // 用其他 Web 函数解释的请求生成该函数。 // int web_custom_request (const char *RequestName, <List of Attributes>, [EXTRARES, <List of Resource Attributes>,] LAST );
// web_disable_keep_alive 函数是一个服务 // 函数,它禁用 Keep–Alive HTTP 连接。 // 默认情况下,KeepAlive 设置处于启用状态。 int web_disable_keep_alive ( );
// web_dump_cache 保存浏览器缓存。它与 // web_load_cache 一起使用,以实现 Vuser // 持续缓存。脚本始终使用相同的初始缓存运行。 int web_dump_cache ( const char *Name, const char * fileName, [ const char * Replace], LAST );
// web_enable_keep_alive 函数是一个服务 // 函数,它启用 Keep–Alive HTTP 连接。 int web_enable_keep_alive ( );
135
// web_find 函数在 HTML 页中搜索指定的文本字符串。 int web_find (const char *StepName, <Attributes and Specifications list>, char *searchstring, LAST );
// web_get_int_property 函数返回 // 关于上一个 HTTP 请求的指定信息。 int web_get_int_property (const int HttpInfoType);
// // // // // // // int web_global_verification (<List of Attributes>, LAST );
web_global_verification 函数注册 一个请求,以在所有后续操作函数返回的 网页中搜索指定的文本字符串。这与函数
web_reg_find 不同,后者只为下一个 操作函数注册请求。可以搜索页面的正文、 头、HTML 代码或全部内容。
// 操作函数 web_image 模拟 // 鼠标单击由属性定义的图像。 // 该函数只能在上一个操作 // 的上下文中执行。 int web_image (const char *StepName, <List of Attributes>, [EXTRARES, <List of Resource Attributes>,] LAST );
// web_image_check 函数可以验证 HTML 页中 // 包含指定图像。 int web_image_check(const char *CheckName, <List of Attributes>, <"Alt=alt"|| "Src=src">, LAST );
// web_link 函数是一个操作函数, // 它模拟鼠标单击由属性定义的 // 链接。web_link 只能在上一个 // 操作的上下文中执行。
int web_link (const char *StepName, <List of Attributes>, [EXTRARES, <List of Resource Attributes>,] LAST );
// web_remove_cookie 函数从一个对 Vuser // 可用的 Cookie 列表中删除一个 Cookie。该函数 // 指定要删除的 Cookie 的名称。 int web_remove_cookie (const char *Cookie);
// web_load_cache 可以从文件中还原浏览器 // 缓存。它与 web_dump_cache 一起 // 使用,以实现 Vuser 持续缓存。脚本
136
// 始终使用相同的初始缓存运行。 int web_load_cache ( const char *Name, const char * fileName, LAST );
// web_reg_add_cookie 函数注册一个搜索, // 在下一个操作函数(如 web_url)检索到的网页上 // 搜索一个文本字符串。如果 // 找到了字符串,将添加 Cookie。 int web_reg_add_cookie(const char * cookie, const char * searchstring, LAST );
// web_reg_find 函数注册一个请求,以 // 在下一个操作函数(如 web_url)检索到 // 的网页上搜索一个文本字符串。 int web_reg_find (const char *attribute_list, LAST);
// web_reg_save_param 是一个注册类型 // 的函数。它注册一个请求,以在检索到的 // 网页中查找并保存一个文本字符串。只有 // 在执行了下一个操作函数(如 web_url)后 // 才会执行该操作。 int web_reg_save_param (const char *ParamName, <List of Attributes>, LAST);
// web_remove_auto_header 函数是一个服务 // 函数,它停止向后续 HTTP 请求添加特定的用户 // 定义头。该函数将取消由 web_add_auto_header // 启动的指定头的自动头生成。 // int web_remove_auto_header (const char *Header, char *Implicit, LAST);
// web_revert_auto_header 函数是一个服务 // 函数,它停止向后续 HTTP 请求添加特定的用户 // 定义头。该函数将取消由 web_add_auto_header // 启动的指定头的自动头生成。它不断生成隐性头, // 如同不曾调用过函数 web_add_auto_header
// 或 web_remove_auto_header 一样。 int web_revert_auto_header (char *Header);
// web_report_data_point 函数在脚本中 // 定义要包括在测试结果中的数据点。最常见的 // 数据点是步骤超时,它表明上一个步骤是否超时。 // int web_report_data_point ( const char * EventType, const char * EventName , const char * DataPointName , LAST );
// web_save_header 函数将所有随后
137
// 发生的操作函数的主 URL 的请求和 // 响应头保存在参数 param 中。每个头由 // “\r\n”(或仅“\n”)分隔。每个新的 // 请求头将替换参数的当前值。 int web_save_header (const char *type, const char *param );
// web_save_param_length 创建名为 // “<Param>_Length”的新参数(如果尚无该参数), // 并将 Param 的长度保存在参数“<Param>_Length” // 中。该长度采用十六进制格式。 int web_save_param_length( const char *Param, LAST );
// web_save_timestamp_param 保存当前 // 时间戳。在某些应用中,VuGen 用一个参数 // 替换脚本中的所有非空时间戳。为了保存 // 该参数的值,VuGen 自动生成对 // web_save_timestamp_param 的调用。 // 保存的值是自 1970 年 1 月 1 日午夜 // 开始的毫秒数。 int web_save_timestamp_param( const char * tmstampParam, LAST );
// web_set_certificate 指定一个证书在 // 证书列表中的编号。然后,只要某个安全的 // Web 服务器需要客户端提供证书,就使用 // 指定的证书。 int web_set_certificate (const char *CertificateNumber);
// web_set_certificate_ex 设置证书 // 和关键文件属性,如位置、类型和密码。 // 该信息用于需要证书的 HTTPS 请求。 // 所有参数都是以 null 终止的字符串。 // 关键字不区分大小写;但属于关键字 // 的值是区分大小写的。关键字 // // 值的开头和末尾不允许出现 // 空格。注意,只有使用 Internet Explorer // 时才录制该函数。 int web_set_certificate_ex (const char *option_list, LAST);
// web_set_connections_limit 函数是 // 一个服务函数,它设置脚本执行期间可以行 // 同时运的最大请求数。 // 在加载页面资源或加载框架集页面 // 中的框架等情形下,会发出
138
// 多个请求。任何 Vuser 的默认限制为 // 可以同时发出四个请求。 int web_set_connections_limit (const char *Limit );
// web_set_max_html_param_len 函数是 // 一个服务函数,用于关联 HTML 语句。 // 仅当启用“在录制过程中关联”时 // 才录制该函数(请参阅 VuGen 的录制选项)。 int web_set_max_html_param_len (const char *length );
// web_set_max_retries 函数设置操作的 // 最大重试次数。当发生错误时,对于 HTTP // 响应消息 500-599 和网络 API 错误 // (HttpSendRequest 等),会尝试进行 // 重试。对于超时或函数参数错误,不尝试 // 进行重试。 int web_set_max_retries (const char *MaxRetries );
// web_set_option 函数设置 Web 选项。 // 它是一个服务函数,影响其后的所有函数, // 直到指定了新值。vuser_init 部分 // 结束运行时,将保存当前选项值。 // 在每次循环开始之前,这些值将还原为 // 保存的值。 int web_set_option (const char *OptionID, const char * OptionValue, LAST );
// web_set_proxy 函数是一个服务函数, // 它指定将所有后续 HTTP 请求定向 // 到指定的代理服务器。要直接向服务器 // 提交 HTTP 请求(即不使用代理
// 服务器),请使用函数 web_set_proxy // 传递一个空字符串 ("") 作为参数。 int web_set_proxy (const char *proxy_host:port );
// web_set_proxy_bypass 函数是一个服务函数, // 它指定要直接访问的 URL 的列表,该访问会避开 // 代理服务器。可以在避开的 URL 列表中包含 <local>, // 以使所有本地主机(如 Intranet 服务器) // 都避开代理服务器。 int web_set_proxy_bypass (const char *bypass1..n );
// web_set_proxy_bypass_local 函数是 // 一个服务函数,它指定代理服务器是否应 // 避开本地 (Intranet) 地址。该函数会覆盖
139
// 运行时设置代理选项“对本地 (intranet) // 地址不使用代理服务器”。如果代理避开 // 字符串包含 <local>,则该函数 // 和 UI 复选框都将没有以下效果:将
// 始终避开本地地址。 int web_set_proxy_bypass_local ( const char *no_local );
// web_set_secure_proxy 函数是一个服务函数, // 它指定将所有后续 HTTPS 请求 // 定向到指定的安全代理服务器。 int web_set_secure_proxy (const char *secure_proxy_host_port );
// web_set_sockets_option 函数配置 // 客户端上的套接字选项。对于启用或禁用 // 某项功能(如 TRACE_SSL_IO)的选项, // 请指定“1”以启用,指定“0”以禁用。 // 以下列表显示了支持的选项: int web_set_sockets_option( const char *option, const char * value );
// web_set_timeout 函数是一个服务函数,它 // 指定 CONNECT、RECEIVE 或 STEP 操作完成 // 之前等待的最长时间。 int web_set_timeout (const char *Action, const char *TimeOut );
// web_set_user 函数是一个服务函数,它 // 指定 Web 服务器或代理服务器的登录字符串 // 和密码。如果多个代理服务器需要身份验证, // 可以多次调用该函数。web_set_user // 会覆盖运行时代理身份验证的用户名和密码 // 设置。 int web_set_user (const char *username, const char *password, const char *host:port );
// web_sjis_to_euc_param 函数将一个 SJIS 编码的 // 以 null 终止的字符串转换为 EUC 编码的字符串,并将它 // 赋给参数。可以使用函数 lr_eval_string // 确定参数的值。 int web_sjis_to_euc_param (LPCSTR param_name, LPCSTR param_value_in_SJIS);
// web_submit_data 函数是一个操作函数, // 它执行“无条件的”或“无上下文的”表单 // 提交。通过它可以生成 GET 和 POST // 请求,如同由 HTML 表单生成的请求。执行该请求 // 不需要有表单上下文。 int web_submit_data ( const char *StepName, <List of Attributes>, ITEMDATA, <List of data>,
140
[ EXTRARES, <List of Resource Attributes>,] LAST );
// web_submit_form 函数是一个操作函数,它 // 可以提交表单。函数 web_submit_form 只能在上一 // 操作的上下文中执行。 int web_submit_form (const char *StepName, <List of Attributes>, <List of Hidden Fields>, ITEMDATA, <List of Data Fields>, [ EXTRARES, <List of Resource Attributes>,] LAST );
// 通过 web_switch_net_layer 函数,可以在 // 要重放的网络层间切换。通过它可以在同一 // 脚本中混用直接的 HTTP 和 WSP 调用。目前, // 该函数只影响 WAP Vuser。 int web_switch_net_layer (const char *NetName);
// web_url 函数是一个操作函数,它可以加载 // 指定的网页(GET 请求)。函数 web_url // 可以加载 URL 属性指定的 URL。函数 web_url // 不需要上下文。
int web_url (const char *Name, const char * url, <List of Attributes>, [EXTRARES, <List of Resource Attributes>,] LAST );
// web_browser 操作函数直接在打开的 // 浏览器上执行操作。 int web_browser (const char *stepName, [const char *snapShot,] [DESCRIPTION, const char *browser,] ACTION, const char *userAction, LAST );
// web_button 操作函数模拟用户单击按钮。 int web_button (const char *stepName, [const char *snapShot,] DESCRIPTION, [const char *type,] [const char *tag,] [const char *arg1, ... const char *argn,] LAST );
// web_check_box 操作函数选择或清除 // 复选框。如果 setOnOff 为“Set=ON”,则选中复选框。 // 如果 setOnOff 为“Set=OFF”,则清除复选框。 int web_check_box (const char *stepName, [const char *snapShot,] DESCRIPTION, const char *arg1, ... const char *argn, ACTION, const char *setOnOff, LAST );
// web_edit_field 函数在文本或密码输入元素 // 中输入 setValue。 int web_edit_field (const char *stepName, [const char *snapShot,] DESCRIPTION, [const char *type,] [const char *arg1, ... const char *argn,] ACTION, const char *setValue, LAST );
// 永远不录制 web_eval_java_script。 // 可以在脚本中添加该函数,以处理没有 // 标准解决方案的情况。该函数有三种
141
// 用法,语法各不相同。请勿混淆不同语法 // 的参数。请勿在语法 1 或语法 2 中使用 // PrintProperties,勿在语法 2 或语法 3 // 中使用 script,以及勿在语法 1 或语法 3 中使用 // Expression 和 SaveExpressionResult。
int web_eval_java_script ( const char *stepName, const char *script, [DESCRIPTION, const char *arg1, ..., const char *argn,] LAST );
// web_file 在形如 <INPUT TYPE=FILE NAME=”Name”> // 的元素中输入文件名 SetPath。 int web_file ( const char *StepName, DESCRIPTION, [<List of attributes>], ACTION, const char * SetPath, LAST );
// web_image_link 操作函数模拟用户 // 单击图像(该图像是超文本链接)。 int web_image_link (const char *stepName, [const char *snapShot,] DESCRIPTION, const char *arg1, ... const char *argn, [ACTION, const char *clickCoordinates,] LAST );
// web_image_submit 操作函数模拟用户 // 单击类型为“image”的输入元素。 int web_image_submit (const char *stepName, [const char *snapShot,] DESCRIPTION, const char *arg1, ... const char *argn, ACTION, const char *clickCoordinates, LAST );
// web_list 函数模拟用户在列表框 // 中选择一项。选择项可以通过 // 选择项的文本或其位置识别。 // 第一个选项的位置为 1。
int web_list (const char *stepName, [const char *snapShot,] DESCRIPTION, const char *type, [const char *arg1, ... const char *argn,] ACTION, const char *selectAction, [const char *ordinalSelectAction,] LAST );
// web_map_area 函数可以激活客户端映射的一个 // 区域。无论该区域如何激活,都将录制该函数。通常, // 用户单击一个区域会激活该区域。 int web_map_area (const char *stepName, [const char *snapShot,] DESCRIPTION, const char *mapName, const char *arg1, ... const char *argn, LAST );
// web_radio_group 操作函数模拟用户 // 在单选按钮组中选择一个按钮。 int web_radio_group (const char *stepName, [const char *snapShot,] DESCRIPTION, const char *name, const char *arg1, ... const char *argn, ACTION, const char *selection, LAST );
// web_reg_dialog 服务函数可以注册 // Java 脚本使用的信息。
142
int web_reg_dialog (DESCRIPTION, const char *type, [const char *message,][const char *browser,] ACTION, const char *userAction, LAST );
// web_static_image 模拟用户单击图像。 // 如果 IMG 元素被具有 HREF 属性的 <A> 元素 // 围起,则它是一个链接,该函数无效。在这种 // 情况下,请使用 web_image_link。 int web_static_image ( const char *StepName, DESCRIPTION, <List of attributes>, LAST );
// web_text_area 操作函数在文本区域中输入 setText。 int web_text_area (const char *stepName, [const char *snapShot,] DESCRIPTION, const char *arg1, ... const char *argn, ACTION, const char *setText, LAST );
// web_text_link 操作函数模拟 // 用户单击超文本链接。 int web_text_link (const char *stepName, [const char *snapShot,] DESCRIPTION, [const char *text, ][const char *arg1, ... const char *argn,] LAST );
// lrs_accept_connection 函数从 // old_socket 上的挂起连接队列中 // 取出第一个连接,使用相同属性创建 // 新的套接字。原来的套接字对于其他 // 连接仍然可用。 int lrs_accept_connection ( char *old_socket, char *new_socket );
// lrs_ascii_to_ebcdic 函数可以将二进制 // 缓冲区数据从 ASCII 格式转换为 EBCDIC 格式。 // 转换后的缓冲区以 EBCDIC 格式存储在内部缓冲区 // (用户缓冲区)中。要检索缓冲区的内容,请使用 // lrs_get_user_buffer。要确定缓冲区大小, // 请使用 lrs_get_user_buffer_size。 char *lrs_ascii_to_ebcdic ( char *s_desc, char *buff, long length );
// lrs_cleanup 函数终止使用 Windows // Sockets DLL(类似于 WSACleanup) // 和系统资源,如释放文件描述符。请检查 // 返回代码,以验证清理成功。 int lrs_cleanup ( );
// lrs_close_socket 函数释放指定的 // 套接字描述符,以关闭套接字。再次引用 // 该套接字将会导致错误 WSAENOTSOCK。 // 如果这是对基础套接字的最后一次引用, // 将丢弃相关的命名信息和队列数据。
143
// 注意,对于 TCP 套接字,函数 // lrs_close_socket 会将所有尚未发送 // 的数据发送出去。 int lrs_close_socket ( char *s_desc );
// lrs_create_socket 函数初始化一个套接字。 // 它执行 socket 命令,打开新的套接字。 // 如果提供了 LocalHost 参数,它会执行 // bind 命令,以命名该套接字。如果提供了 peer 参数, // 它会执行 connect 命令,以建立与对等端的
// 连接。如果提供了 backlog 参数,它 // 会执行 listen 命令侦听该套接字。 int lrs_create_socket ( char *s_desc, char *type, [ char* LocalHost,] [char* peer,] [char *backlog,] LrsLastArg );
// lrs_decimal_to_hex_string 函数可以将整数 // 转换为十六进制字符串。例如,如果字符串为 // 4,则该函数将它转换为 \x04。 char* lrs_decimal_to_hex_string( char* s_desc, char* buf, long length);
// lrs_disable_socket 函数禁止套接字的一项 // 操作。可以禁止所有的发送和/或接收操作。 int lrs_disable_socket ( char *s_desc, int operation );
// lrs_ebcdic_to_ascii 函数将二进制缓冲区 // 数据从 EBCDIC 格式转换为 ASCII 格式。转换后 // 的缓冲区以 ASCII 格式存储在内部缓冲区 // (用户缓冲区)中。要检索缓冲区的内容, // 请使用 lrs_get_user_buffer。要确定缓冲区 // 的大小,请使用 lrs_get_user_buffer_size。 char *lrs_ebcdic_to_ascii ( char *s_desc, char *buff, long length );
// // // // // // // int lrs_exclude_socket ( char *s_desc );
lrs_exclude_socket 函数排除指定 套接字的所有操作。脚本中从该函数开始 向后的所有使用该指定套接字的函数都 将被忽略。建议将该函数放在脚本的
vuser_init 部分。排除对脚本所有 部分中的套接字函数都有效。
// lrs_free_buffer 函数释放为指定缓冲区分配的 // 内存。内存是在调用函数 lrs_get_buffer_by_name // 或 lrs_get_last_received_buffer 时
144
// 分配的。 int lrs_free_buffer ( char *buffer );
// 对于指定的缓冲区描述符,函数 // lrs_get_buffer_by_name 获取 // 二进制缓冲区以及数据二进制表示的长度。 // 注意,数据缓冲区不是以 NULL 终止的。 int lrs_get_buffer_by_name ( char *buf_desc, char **data, int *size );
// lrs_get_last_received_buffer 函数获取 // 套接字上最后收到的缓冲区及其大小。注意,该 // 函数返回数据二进制表示的长度。数据缓冲区 // 不是以 NULL 终止的。 int lrs_get_last_received_buffer ( char *s_desc, char **data, int *size );
// lrs_get_last_received_buffer_size 函数 // 获取套接字 s_desc 上最后收到的缓冲区的 // 大小。注意,该函数返回数据二进制表示的 // 长度。 int lrs_get_last_received_buffer_size ( char *s_desc );
// lrs_get_received_buffer 函数检索 // 最后一次调用 lrs_receive、lrs_receive_ex // 或 lrs_length_receive 收到的缓冲区的全部 // 或其一部分。请指定要检索的数据的 // 偏移量和长度。 char *lrs_get_received_buffer ( char *s_desc, int offset, int length, char *encoding );
// lrs_get_static_buffer 函数检索 // 来自数据文件的静态缓冲区或其一部分。 // 请指定缓冲区及要检索的数据的偏移量 // 和长度。该缓冲区在发生任何参数替换后 // 返回。 char *lrs_get_static_buffer ( char *s_desc, char *buffer, int offset, int length, char *encoding );
// lrs_get_socket_attrib 函数检索 // 指定的套接字属性。通过它可以获取有关 // 套接字的信息。只能从绑定或连接到某个 // 套接字的套接字检索属性。要将一个套接字 // 绑定到现有套接字,请使用 lrs_create_socket(...LocalPort=...)。 // 要连接到一个套接字,请使用 lrs_create_socket(...RemoteHost=...)。 char *lrs_get_socket_attrib ( char *s_desc , int attribute );
// lrs_get_socket_handler 函数检索指定
145
// 套接字的套接字句柄。检索到套接字句柄后, // 可以在后续函数中使用。 int lrs_get_socket_handler ( char *s_desc );
// lrs_get_user_buffer 函数检索指定套接字的 // 用户数据缓冲区的内容。 char *lrs_get_user_buffer ( char *s_desc );
// lrs_get_user_buffer_size 函数检索指定套接字的 // 用户数据缓冲区的大小。 long lrs_get_user_buffer_size ( char *s_desc );
// lrs_hex_string_to_int 将一个 // 十六进制字符串转换为整数。请指定 // 指向包含要转换字符串的缓冲区的指针 // 及要转换字符串的长度。该函数将转换 // 字符串并赋值给整型引用。 int lrs_hex_string_to_int ( char* buff, long length, int* mpiOutput );
// lrs_length_receive 函数将指定长度的 // 数据从 sock_descriptor 读入缓冲区。 // 长度位于接收到的缓冲区自身内部。用户 // 必须知道该长度值位于缓冲区内何处 // (除非选择了 RecieveOption_None // 选项),其位置通过参数 location_option // 和 locators 指定。lrs_length_receive // 首先获得长度值(下面称为 length), // 再将 length 个字符从 socket_descriptor // 读入缓冲区。 int lrs_length_receive(char *socket_descriptor, char *buffer, int location_option, [char* additional_params], LrsLastArg );
[char* locators],
// lrs_length_send 函数将指定 // 长度的数据从 sock_descriptor 于 // 写入 buffer。它用发送参数化数据, // 每次调用该函数时数据的长度可以 // 不同。使用 lrs_length_send 可以 // 不必每次计算长度,因为 Vugen // 自动将正确的数据长度写入由参数 // locator 和 location_option // 指定的字段。 int lrs_length_send(char *socket_descriptor, char *buffer, int location_option, [char* additional_params], LrsLastArg );
[char* locators],
146
// lrs_receive 函数从数据报或流式套接字 // 读取输入数据。如果套接字上没有输入 // 数据,lrs_receive 将等待数据到达, // 除非套接字是非分块套接字。
int lrs_receive ( char *s_desc, char *bufindex, [char *flags], LrsLastArg );
// lrs_receive_ex 函数从数据报或 // 流式套接字的输入数据中读取指定数目 // 的字节。除了可以指定要接收字节 // 数的功能外,它与函数 lrs_receive // 等价。 int lrs_receive_ex ( char *s_desc, char *bufindex, [char *flags,] [char *size,] *terminator,] [char *mismatch,] [char *RecordingSize,] LrsLastArg );
[char
// lrs_save_param 函数将数据从缓冲区保存 // 到参数中。该函数用于关联或链接脚本中的 // 语句。 int lrs_save_param ( char *s_desc,char *buf_desc, char *param_name, int offset, int param_len);
// lrs_save_param_ex 函数将缓冲区或 // 缓冲区的一部分保存到参数中。参数 type // 指定要保存的缓冲区数据的类型:用户缓冲区、 // 录制缓冲区或最后接收的缓冲区。该函数 // 会覆盖用户数据区。 int lrs_save_param_ex ( char *s_desc, char *type, char *buff, int offset, int length, char *encoding, char *param );
// lrs_save_searched_string 函数将 // 缓冲区的一部分保存到参数中。该函数用于 // 关联或链接脚本中的语句。该函数扩展了 // lrs_save_param 的功能。 int lrs_save_searched_string (char* s_desc, char* buf_desc, char* param_name,
char*
left_boundary, char* right_boundary, int ordinal, int offset,
// lrs_send 函数将输出数据写到已 // 连接的数据报或流式套接字。如果不能 // 成功发送缓冲区中的所有数据,将重复 // 尝试,直到发送超时。如果无法为数据 // 找到可写的套接字,该函数将不断查找 // 套接字,直到发送超时。默认情况下, // 发送超时值为 10 秒。可以使用 // lrs_set_send_timeout 修改超时值。 // 注意,lrs_send 成功完成并不表示 // 数据已成功传递。
int param_len );
147
int lrs_send ( char *s_desc, char *buf_desc, [char *target], [char *flags,] LrsLastArg );
// lrs_set_accept_timeout 函数设置 // 服务器在检测到可读套接字 (select) // 并完成关联 (accept) 之前等待的时间。 // 如果套接字当前正在侦听,并且 // 收到了传入的连接请求,它将被标记为 // 可读。一旦套接字被标记为可读, // 就可以保证完成 accept,不会阻塞。 // 可以为超时值指定秒数和毫秒 // 数。如果套接字在超时时间间隔内 // 未被接受,则脚本执行将终止。 // 默认的超时值为 10 秒。如果您发现 // 默认时间不够,请做相应 // 修改。 void lrs_set_accept_timeout ( long seconds, long u_sec );
// lrs_set_connect_timeout 函数设置连接 // 到套接字的超时值。请将这个可编程(非录制) // 的函数插到连接命令 lrs_create_socket // 之前。 void lrs_set_connect_timeout ( long seconds, long u_sec );
// lrs_set_receive_option 函数为 // lrs_receive 设置套接字接收选项。Option // 指明在出现不匹配或检测到终止字符串时, // 停止接收套接字信息。注意,该选项不会应用 // 于通过 lrs_receive_ex 进行的任何接收 // 操作。该函数设置的选项应用于该函数之后 // 出现的所有 lrs_receive,除非该选项被某个 // 后续 lrs_set_receive_option 调用重置。 int lrs_set_receive_option ( int option, int value, [char * terminator] );
// lrs_set_recv_timeout 函数设置 Vugen 从套接字 // 接收到期望数据之前等待的时间段。 void lrs_set_recv_timeout ( long sec, long u_sec );
// lrs_set_recv_timeout2 函数设置在套接字 // 上接收数据的超时限制。当 lrs_receive 接收 // 到数据缓冲区后,它将其大小与期望数据进行 // 比较。如果缓冲区大小不匹配,它将执行 // 更多的循环,重新读取输入套接字数据, // 直到达到限制值 timeout2。可以在 // 完整日志跟踪中查看这些循环。
148
void lrs_set_recv_timeout2( long sec, long u_sec );
// lrs_set_send_buffer 函数指定下次调用 // lrs_send 时要发送的缓冲区。将发送 // lrs_set_send_buffer 中指定的缓冲区, // 而不是函数 lrs_send 中指定的缓冲区。 int lrs_set_send_buffer ( char *s_desc, char *buffer, int size );
// lrs_set_send_timeout 函数设置向可写 // 套接字发送数据的超时值。可以为超时值指定 // 秒数和毫秒数。 void lrs_set_send_timeout ( long sec, long u_sec );
// lrs_set_socket_handler 函数为指定 // 套接字设置套接字句柄。 int lrs_set_socket_handler ( char *s_desc, int handler );
// lrs_set_socket_options 函数为指定 // 缓冲区设置一个选项。 int lrs_set_socket_options ( char *s_desc, int option, char *option_value );
// lrs_startup 函数初始化 Windows // Sockets DLL。它指定可用于本应用的最高 // Windows Sockets 版本。该函数 // 必须在所有其他 LRS 函数之前执行。 // 通常,它出现于脚本的 vuser_init // 部分。如果该函数失败,执行 // 将立即终止。 int lrs_startup ( int version );
// soap_request 函数执行一个 SOAP // 请求。它向指定的 URL 发送 SOAP 包, // 并接收服务器响应。 int soap_request (const char *StepName, URL, <XMLEnvelope>, LAST]);
// web_service_call 函数调用 Web 服务。 int web_service_call (const char *StepName, URL, <List of specifications>, [BEGIN_ARGUMENTS, Arguments, END_ARGUMENTS,] [BEGIN_RESULT, Results, END_RESULT] LAST );
// lr_xml_get_values 函数在 XML // 输入字符串 XML 中查询匹配查询条件的值。 int lr_xml_get_values ( <List of specifications> [, <List of optional specifications> ] [, LAST]);
149
// lr_xml_set_values 函数在 XML // 输入字符串 XML 中查询匹配查询条件的值, // 并将 Value 或 ValueParam 设置为 // 查询匹配的元素的值。 int lr_xml_set_values ( <List of specifications> [, <List of optional specifications> ] [, LAST]);
// lr_xml_extract 函数查询 XML 输入字符串 // XML,并提取 XML 树中匹配查询条件 // 的片段。输出参数 XMLFragmentParam // 包含提取的片段。
int lr_xml_extract ( <List of specifications> [, <List of optional specifications> ] [, LAST]);
// lr_xml_delete 函数在 XML 输入字符串 // XML 中进行查询,并删除与查询条件匹配 // 的 XML 树片段。可以通过在 XML 查询 // 中指定元素名称或其属性来删除 // 元素。输出参数 ResultParam 包含 // 删除后经修改的 XML 字符串(使用 // 源文档编码)。 int lr_xml_delete ( <List of specifications> [, <List of optional specifications> ] [, LAST]);
// lr_xml_replace 函数在 XML 输入字符串 // XML 中查询与查询条件匹配的值,并 // 用 XmlFragment 或 XmlFragmentParam // 将它们替换为与查询匹配的元素的值。 // 可以通过在 XML 查询中指定元素名称 // 或属性来替换元素。结果字符串
// 放在 ResultParam 中(使用源文档 // 编码)。 int lr_xml_replace ( <List of specifications> [, <List of optional specifications> ] [, LAST]);
// lr_xml_insert 函数在 XML 输入字符串 // XML 中查询与查询条件匹配的值。然后,它在 // 查询返回的 XML 字符串中的一个或多个位置 // 处插入 XmlFragment 或 XmlFragmentParam。 int lr_xml_insert ( <List of specifications> [, <List of optional specifications> ] [, LAST]);
// lr_xml_find 函数在 XML 输入字符串 XML 中 // 查询与条件(Value 或 ValueParam)查询的值, // 并返回出现次数。如果 SelectAll 为“no”, // 则 lr_xml_find 返回 1 或 0。 int lr_xml_find ( <List of specifications> [, <List of optional specifications> ] [, LAST]);
// 函数 lr_xml_transform 使用样式表
150
// 中的可扩展样式表语言 (XSL) 规范转换 // XML 输入字符串 XML,并将作为结果产生 // 的格式化数据保存在 ResultParam 中 // (使用源文档编码)。 int lr_xml_transform ( <List of specifications> ]);
151
loadrunner 处理 HTTPS / ssl / 证书 / cer / pem
loadrunner 那个https的问题解决了 / web_set_sockets_option("SSL_VERSION","TLS");
主站的证书从ssl3.0更换成TLS1.0 , Loadrunner 默认是ssl3.0的；在脚本开始加个函数就解决了
web_set_sockets_option("SSL_VERSION","TLS"); // 有HTTPS请求的需加上这段，还有就是勾选加载静态资源即可。
http://www.51testing.com/html/92/450992-248065.html
Advanced高级的
Winlnet replay instead of sockets（windows only）
勾选这个，调试脚本的时候没有问题，但是场景执行的时候，会报超时的错误 ，
不勾选这个，他们连不上HTTPS的服务器
LoadRunner页面重定向 (2014-04-02 11:05:21)
http://blog.sina.com.cn/s/blog_696665040101hi95.html
我们输入 http://www.51buy.com ，页面会自动跳转到 http://www.yixun.com 。
执行了301重定向。
//是否执行重定向，1表示执行，0表示不执行
web_set_option("MaxRedirectionDepth","1",LAST);
web_custom_request("web_custom_request",
"URL=http://www.51buy.com",
"Method=GET",
"TargetFrame=",
"Resource=0",
"Referer=",
"Mode=HTTP",
"Body=",
LAST);
//输出服务器返回码
lr_output_message("HttpCode: %d",web_get_int_property(HTTP_INFO_RETURN_CODE));
当参数为1时，执行重定向，replaylog输出如下：
Action.c(5): Redirecting "http://www.51buy.com" (redirection depth is 0) [MsgId: MMSG-26694]
Action.c(5): To location "http://www.yixun.com/" [MsgId: MMSG-26693]
Action.c(5): web_custom_request("web_custom_request") was successful, 138457 body bytes, 1350 header bytes, 101 chunking overhead bytes [MsgId: MMSG-26385]
Action.c(14): web_get_int_property was successful [MsgId: MMSG-26392]
Action.c(14): HttpCode: 200
当参数为0时，不执行重定向，replaylog输出如下：
Action.c(18): Warning -26695: Redirection depth (1) exceeds max (0) for "http://www.51buy.com" [MsgId: MWAR-26695]
Action.c(18): web_custom_request("web_custom_request") highest severity level was "warning", 178 body bytes, 272 header bytes [MsgId: MMSG-26388]
Action.c(27): web_get_int_property was successful [MsgId: MMSG-26392]
Action.c(27): HttpCode: 301
end
以上是关于LoadRunner中的Web 函数列表的主要内容，如果未能解决你的问题，请参考以下文章
Loadrunner查询博客列表并循环删除博客列表中的所有博客
LoadRunner web_set_sockets_option（）--常用函数