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

操作函数

在录制 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 （）
lr_rendezvous_ex （）	设置集合点
lr_think_time （）	设置思考时间

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函数大全之中文解释.rar

http://docs.google.com/viewer?a=v&q=cache:_QOnj36OS1wJ:bbs.51cto.com/attachment.php%3Faid%3D74484%26k%3Defb6f7832aea0c5724a0ab398a9ec37a%26t%3D1299980725+loadrunner+%E5%87%BD%E6%95%B0%E9%A1%BA%E5%BA%8F&hl=zh-CN&pid=bl&srcid=ADGEESh2cODJDGJ2S1IsqA8HAfQfdWHgBwZTFsZFz5A4KwGZYGCuwlHfkNy5V-0Y3rWa7gNgXKNeeeEy0tG1hRO6wcV9JGgmeu7VkvHiLWspSmzuFLeAduIMJ6aZWXSZmb2ce4-jSkeV&sig=AHIEtbTMAYXAM4VIz8HCMsr-SwncCnYtuw

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

阿祖总结[email protected]

// 项目可由其逻辑名称指定。 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 函数在对象内的 // 指定坐标处双击鼠标。

阿祖总结[email protected]

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 函数指定脚本执行

阿祖总结[email protected]

// 期间要使用的思考时间范围。运行脚本 // 时,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 );

阿祖总结[email protected]

// 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 函数从指定窗口或 // 窗口区域读取文本。

阿祖总结[email protected]

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 );

阿祖总结[email protected]

// 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);

阿祖总结[email protected]

// 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,

阿祖总结[email protected]

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 客户端中 // 按下非字母数字键。

阿祖总结[email protected]

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 是同步函数,

阿祖总结[email protected]

// 它等待窗口被创建或变为活动的。 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 );

阿祖总结[email protected]

// 有关 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

阿祖总结[email protected]

// 类型。 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 );

阿祖总结[email protected]

// 请不要在脚本中包括操作系统头文件(例如, // 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 );

阿祖总结[email protected]

// 在 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 指向停止扫描的字符。

阿祖总结[email protected]

// 函数 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 个字符连接到另一字符串。

阿祖总结[email protected]

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);

阿祖总结[email protected]

// 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, ...);

阿祖总结[email protected]

// 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 参数并取消调用的 // 注释。

阿祖总结[email protected]

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);

阿祖总结[email protected]

// 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);

阿祖总结[email protected]

// 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”

阿祖总结[email protected]

// 指针引用的货币值保存到字符串参数中。 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);

阿祖总结[email protected]

// 输入表示无符号短整型值的字符串时, // 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 将 // 此函数生成为注释掉的调用。如果要将

阿祖总结[email protected]

// 此值用作参数,可以更改 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 将此函数生成为注释掉的调用。

阿祖总结[email protected]

// 如果要将此值用作参数,可以更改 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 变量类型值保存到字符串参数中。

阿祖总结[email protected]

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 将通过 // 变量中的引用方式存储的值保存为参数。

阿祖总结[email protected]

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 将通过 // 变量中的引用方式存储的值保存为参数。

阿祖总结[email protected]

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 位

阿祖总结[email protected]

// 超级整型值保存到字符串参数中。 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 将

阿祖总结[email protected]

// 此函数生成为注释掉的调用。如果要将此值 // 用作参数,可以更改 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);

阿祖总结[email protected]

// 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);

阿祖总结[email protected]

// 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 值,并且返回包含对某变量(其中 // 包含该值)引用的变量。

阿祖总结[email protected]

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 类型值。

阿祖总结[email protected]

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);

阿祖总结[email protected]

// 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);

阿祖总结[email protected]

// 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);

阿祖总结[email protected]

// 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);

阿祖总结[email protected]

// 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 函数系列

阿祖总结[email protected]

// 返回对由 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 返回对数组的引用

阿祖总结[email protected]

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);

阿祖总结[email protected]

// 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);

阿祖总结[email protected]

// 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);

阿祖总结[email protected]

// 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);

阿祖总结[email protected]

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 );

阿祖总结[email protected]

// 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 函数将带有

阿祖总结[email protected]

// 显式长度的存储区域通过其描述符分配给 // 标量变量,并将变量绑定到占位符。 // 必要时,该值将被转换为变量的类型和 // 长度。该值可以包含嵌入的 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 字符。

阿祖总结[email protected]

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 函数 // 关闭与数据库的指定连接。

阿祖总结[email protected]

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 函数为数据库光标、 // 上下文或连接设置选项。

阿祖总结[email protected]

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

阿祖总结[email protected]

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 );

阿祖总结[email protected]

// 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 并且不创建任何与数据库的新的连接。

阿祖总结[email protected]

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

阿祖总结[email protected]

**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) 描述符已从数据库中提取后,从该

阿祖总结[email protected]

// 描述符中读取字符。注意,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 );

阿祖总结[email protected]

// 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 );

阿祖总结[email protected]

// 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 );

阿祖总结[email protected]

// 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 函数将变量

阿祖总结[email protected]

// 或数组元素转换为可打印字符串。 // 在录制期间,将在脚本目录的 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);

阿祖总结[email protected]

// 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 命令

阿祖总结[email protected]

// 的净传输时间。净传输持续时间不包括 // 连接开销。 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);

阿祖总结[email protected]

// 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 函数选择邮箱 // 以访问其邮件。调用此函数将修改 // 邮箱状态(未读邮件数、邮件总数,

阿祖总结[email protected]

// 等等)。若要检索邮箱属性, // 请调用 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 函数列出

阿祖总结[email protected]

// 对客户端声明为订阅或活动的邮箱。 // 回复中包含名称属性、层次结构分隔符和 // 邮箱名称。 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 函数更改与当前

阿祖总结[email protected]

// 邮箱中的指定邮件相关的标志。 // 可以更改所有标志、在现有标志上添加 // 标志或删除标志。 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 函数搜索邮箱

阿祖总结[email protected]

// 以查找与搜索标准匹配的邮件。搜索标准 // 可以由一个或多个搜索项组成。 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);

阿祖总结[email protected]

// 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 会话

阿祖总结[email protected]

// 属性的值作为 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

阿祖总结[email protected]

// 当前条目的属性值。既可以 // 指定属性的索引,也可以指定 // 属性的名称。默认情况下, // 如果不指定任何值,函数将 // 返回第一个属性的值。可选的 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

阿祖总结[email protected]

*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。搜索范围可以是

阿祖总结[email protected]

// 基础自身 (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

阿祖总结[email protected]

// 协议)执行登录。 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 时(流传输尚未完成),播放器会话 // 才会处于活动状态。

阿祖总结[email protected]

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);

阿祖总结[email protected]

// 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

阿祖总结[email protected]

// 剪辑。只有播放持续时间为无限(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 );

阿祖总结[email protected]

// 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 窗口中的“值列表”按钮,

阿祖总结[email protected]

// 以便显示活动字段的值列表。 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);

阿祖总结[email protected]

// 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 函数输入一个字母 // 来指明要从值列表中选择的项目的第一个 // 字符。以指定字母开头的项目 // 被选中。如果存在多个以该字母 // 开头的项目,那么所有匹配的值都将显示在列表中, // 您需要从新列表中选择一个

阿祖总结[email protected]

// 项目。 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 函数按 // 消息窗口中的指定按钮。该按钮通过其索引指定, // 通常是从左到右 // 的按钮顺序。例如,如果消息框包含 // 三个按钮:“是”、“否”和“取消”,那么相应的

阿祖总结[email protected]

// 索引可能为 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 函数向“响应”框中 // 的单元格中插入数据。应指定“响应”对象的名称、 // 单元格的名称以及数据。

阿祖总结[email protected]

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 时,可能会出现

阿祖总结[email protected]

// 这种情况。 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 函数选择选项卡项目。

阿祖总结[email protected]

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,]

阿祖总结[email protected]

// 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 服务器 // 检索邮件。您可以指定邮件范围或 // 所有邮件。默认情况下,它在检索邮件之后

阿祖总结[email protected]

// 将其从服务器中删除。 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 );

阿祖总结[email protected]

// 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 );

阿祖总结[email protected]

// 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 函数等待客户端 // 应用程序静默指定的时间。当终端仿真器 // 未接到任何字符时,认为客户端处于 // 静默状态。如果客户端应用程序 // 由于过了超时时间(以秒为单位)

阿祖总结[email protected]

// 而未静默认指定的时间,该函数将 // 返回错误。 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 从大的

阿祖总结[email protected]

// 父级对象中选择对象。嵌入的 // 对象由属性 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 );

阿祖总结[email protected]

// 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 );

阿祖总结[email protected]

// “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 );

阿祖总结[email protected]

// 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 );

阿祖总结[email protected]

// 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 选择与当前选择

阿祖总结[email protected]

// 位于同一列但位于不同行的单元格。 // 它在同一列中向上或向下移动选择,以便移动到 // 由参数 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

阿祖总结[email protected]

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);

阿祖总结[email protected]

// 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 模拟用户打开 // 菜单并选择菜单项目。

阿祖总结[email protected]

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

阿祖总结[email protected]

*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 );

阿祖总结[email protected]

// 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 从组合框中

阿祖总结[email protected]

// 选择项目 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 );

阿祖总结[email protected]

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 将

阿祖总结[email protected]

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 );

// 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 );

阿祖总结[email protected]

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 之后, // “-”符号将替换为“+”符号, // 而且子节点不可见。

阿祖总结[email protected]

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 模拟用户 // 右键单击树标题以打开上下文相关菜单。

阿祖总结[email protected]

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 ) ;

阿祖总结[email protected]

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 将取消选中

阿祖总结[email protected]

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

阿祖总结[email protected]

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

阿祖总结[email protected]

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 服务器

阿祖总结[email protected]

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 服务器 // 转换消息。应指定源文件和目标文件、 // 内容标题和编码类型。

阿祖总结[email protected]

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 );

阿祖总结[email protected]

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 );

阿祖总结[email protected]

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 事务。这意味着事务的

阿祖总结[email protected]

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 之前使用,

阿祖总结[email protected]

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。

阿祖总结[email protected]

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 错误

阿祖总结[email protected]

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 结合使用。

阿祖总结[email protected]

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( );

阿祖总结[email protected]

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 函数标记事务的 // 结束,并录制执行事务

阿祖总结[email protected]

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. );

阿祖总结[email protected]

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 都

阿祖总结[email protected]

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);

阿祖总结[email protected]

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);

阿祖总结[email protected]

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);

阿祖总结[email protected]

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);

阿祖总结[email protected]

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

阿祖总结[email protected]

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);

阿祖总结[email protected]

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();

阿祖总结[email protected]

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 可以检索

阿祖总结[email protected]

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,

阿祖总结[email protected]

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 );

阿祖总结[email protected]

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*) */

阿祖总结[email protected]

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);

阿祖总结[email protected]

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来替换，脚本完全可以跑通。中间的脚本是从上到下执行的，而不是一起执行的。

阿祖总结[email protected]

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 ( );

阿祖总结[email protected]

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 持续缓存。脚本

阿祖总结[email protected]

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 函数将所有随后

阿祖总结[email protected]

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 函数是 // 一个服务函数,它设置脚本执行期间可以行 // 同时运的最大请求数。 // 在加载页面资源或加载框架集页面 // 中的框架等情形下,会发出

阿祖总结[email protected]

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) 地址。该函数会覆盖

阿祖总结[email protected]

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>,

阿祖总结[email protected]

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。 // 可以在脚本中添加该函数,以处理没有 // 标准解决方案的情况。该函数有三种

阿祖总结[email protected]

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 脚本使用的信息。

阿祖总结[email protected]

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。 // 如果这是对基础套接字的最后一次引用, // 将丢弃相关的命名信息和队列数据。

阿祖总结[email protected]

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 时

阿祖总结[email protected]

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 函数检索指定

阿祖总结[email protected]

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],

阿祖总结[email protected]

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 );

阿祖总结[email protected]

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。可以在 // 完整日志跟踪中查看这些循环。

阿祖总结[email protected]

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]);

阿祖总结[email protected]

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 使用样式表

阿祖总结[email protected]

150

阿祖总结[email protected]

// 中的可扩展样式表语言 (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

时间： 2024-10-06 13:13:36

LoadRunner中的Web 函数列表

LoadRunner中的Web 函数列表的相关文章

LoadRunner中自定义C函数实现字符串替换

PHP中的安全函数

LoadRunner中如何验证下载的文件大小、统计下载时间、度量下载速度

Loadrunner中对中文进行UTF-8转码

LoadRunner中常用函数参考手册

Loadrunner中web_reg_save_param函数的除关联外的使用方法，检查点找不到内容

在LoadRunner中转换字符串大小写的C语言函数

LoadRunner中的C Vuser函数

[python] 字典和列表中的pop()函数