空间管理您的位置: 51Testing软件测试网 » msnshow的个人空间 » 日志

十五年测试老手，长期负责WEB\APP 项目测试，目前主要负责团队管理工作。

loadrunner 函数说明(转载)

上一篇 / 下一篇 2009-06-14 14:11:11 / 个人分类：loadrunner

[qe2^JUC4^6V2dtY)T0// button_press 函数激活指定的推按钮。51Testing软件测试网kWxNVN,|\
int button_press ( LPCSTR button );51Testing软件测试网O'H~uj`9i4L

)z!Ps]jG-Wt0// button_set 函数将按钮状态设置为 ON 或 OFF。
A8dx ]-u v9k4[O0int button_set ( LPCSTR button, int state );

p1Q;W*c~-tx0// close_session 函数关闭所有打开的窗口并结束
// 当前的 Baan 会话。在 Baan 模板中创建的此函数
u#q)U] Y1|t2a2w*o%\D0// 出现在脚本的 vuser_end 部分中。
int close_session();51Testing软件测试网b0Y[&{J

// edit_get_text 函数返回在指定 edit 对象中
ZeQ{H0// 找到的所有文本。若要从特定块中读取文本，
// 请使用 edit_get_block。
int edit_get_text ( LPCSTR edit, char *out_string );

?k4Pu(lJ0// edit_set 函数使用指定的字符串设置 edit 对象的
// 内容。该字符串将替换任何现有字符串。
1dg| S"~0int edit_set ( LPCSTR edit, LPCSTR text );

X0VU"g+T0// edit_set_insert_pos 函数将光标放置
// 在 edit 对象内的指定位置。
int edit_set_insert_pos (LPCSTR edit, int row, int column );

!pY;Mt5x(\(n0// edit_set_selection 函数突出显示指定文本。51Testing软件测试网"]RrT;o q)E
int edit_set_selection ( LPCSTR edit, int start_row, int start_column, int end_row, int end_column );

(w P+p*W)}0A]| }7U0// edit_type 函数将文本字符串输入到 edit
-dD"ubN*BCOAv0// 对象中。该文本字符串不会替换现有字符串；51Testing软件测试网Nu;Mzz6Wt
// 它替换的是位于当前光标位置的指定文本。
int edit_type ( LPCSTR edit, LPCSTR text );51Testing软件测试网S4u _0S-b*R

-?(@E&?z3j;b0// init_session 函数通过指定登录数据和配置51Testing软件测试网!Z.I x7Z4Nv
// 信息打开 Baan 连接。此函数向 Baan 服务器
2MU2G3o8YF#O3@0// 呈现包含在 Baan Configuration 部分中
// 的信息。51Testing软件测试网:tN;s.EUV1E
int init_session ( char * host, char * user, char *password, char *BSE, char *Bshell_name, char * settings );51Testing软件测试网4m'R2rm1m,@o

// list_activate_item 函数双击列表中的项目。51Testing软件测试网lRC8}e w
// 项目可由其逻辑名称指定。
+EgBB8D"x%d`0int list_activate_item ( LPCSTR list, LPCSTR item );

I3fl uv;~0// list_collapse_item 函数隐藏展开的 TreeView
// 列表中的子项，例如文件夹中的各个文件。
int list_collapse_item (LPCSTR list, LPCSTR item );51Testing软件测试网G6Y2~(MA_E*h

_v([5w0u'Uf:Wh!HaX,Z0// list_expand_item 函数显示展开的
Pt}"l{AyQ;L7N0// TreeView 列表中所隐藏的子项，例如
// 文件夹中的各个文件。
int list_expand_item (LPCSTR list, LPCSTR item );

// list_get_selected 函数返回列表中的选定
Z0l3K'~R:[1m4l#jB0// 项目。它既查找标准列表，也查找多选项列表。
Irx8hKw0int list_get_selected (LPCSTR list, LPCSTR out_item, LPCSTR out_num );

// list_select_item 函数从列表中选择项目
h+d*^8Q5B!zT8s0// （在项目上执行一次鼠标单击）。项目可由
"K*_z&gE9c1T0// 其名称或数字索引指定。索引被指定为一个51Testing软件测试网8v3?f@EC
// 字符串，并前置有字符 #。列表中的第一个
// 项目编号为 0。例如，列表中的第三个项目
QR0}*V}^6S'GlvKg0// 将表示为 "#2"。
int list_select_item ( LPCSTR list, LPCSTR item );

// menu_select_item 函数根据菜单
jk T5b}a0// 的逻辑名称和项目名称从菜单中选择51Testing软件测试网 C#yMqs
// 项目。注意，菜单和项目表示为单个51Testing软件测试网gU}2Ph;M
// 字符串，并使用分号分隔。51Testing软件测试网Y,h2ixdO
int menu_select_item ( LPCSTR menu_item );

6G0e.`!f4x,?0// obj_get_info 函数检索指定属性的值，
// 并将其存储在 out_value 中。
cG"L s2T3l1\*{0int obj_get_info ( LPCSTR object, LPCSTR property, char *out_value );51Testing软件测试网 OU#ND/t!Vm

// obj_get_text 函数从指定的对象
*s`+D/\%J0`U0// 或对象区域中读取文本。51Testing软件测试网*j3LJI(z$y'd
int obj_get_text (LPCSTR object, LPCSTR out_text );

_o M2d#M0I3uy0// obj_mouse_click 函数在对象内的
// 指定坐标处单击鼠标。51Testing软件测试网X:q `&f8yE!N
int obj_mouse_click ( LPCSTR object, int x, int y, [mouse_button] );51Testing软件测试网.`h v@KK4{

// obj_mouse_dbl_click 函数在对象内的
9lJH#GU$Z8y$H4G0// 指定坐标处双击鼠标。
5i&Wg8jhX0int obj_mouse_dbl_click ( LPCSTR object, int x, int y, [mouse_button] );

// obj_mouse_drag 函数在 GUI
X\6n-S}iw0SS0// 对象中执行鼠标拖动操作。指定的51Testing软件测试网,s-`a`"M(Y
// 坐标是相对于 GUI 对象（而非
"b2yH,S&P1bHNQl k%M0// 屏幕）的左上角。51Testing软件测试网K:[@0a aE
int obj_mouse_drag (LPCSTR object, int start_x, int start_y, int end_x, int end_y, [ ButtonT mouse_button] );

9o.Z7yo7]:VUZA2V0// obj_type 函数指定将 keyboard_input51Testing软件测试网|2~:~e)A?4s
// 发送到的目标对象。51Testing软件测试网&@,LZ4W1UT+q
int obj_type ( LPCSTR object, unsigned char keyboard_input, [unsigned char modifier ] );

.fV*B7ad4Cpb~0// obj_wait_info 函数等待对象
n,C}X5t[0// 属性达到指定值，然后继续
7CZJ%Y8K|9m~0// 测试运行。如果未达到指定
// 值，则函数将一直等到时间
3K]C)~D/us0// 到期，然后再继续测试。
int obj_wait_info (LPCSTR object, LPCSTR property, LPCSTR value, UINT time );

// scroll_drag_from_min 函数将滚动屏51Testing软件测试网*v|-Y8AM
// 移动到与最小位置相距指定距离的位置。
/r8]N|4blp0int scroll_drag_from_min ( LPCSTR object, [int orientation], int position );

// scroll_line 函数滚动指定行数。51Testing软件测试网L-w#kwjY No
// 此函数可用于滚动栏和滑块对象。
a6~u:J ZW8x^0int scroll_line ( LPCSTR scroll, [ScrollT orientation], int lines );

W;J mj#UuS [ m;|0// scroll_page 函数将滚动屏移动指定页数。51Testing软件测试网P"Yx,uP(j+e
int scroll_page ( LPCSTR scroll, [ScrollT orientation], int pages );

'EDM)K6Ly!bV uj;tU*`0// set_default_timeout 函数设置回放
// 期间 Baan Vuser 函数的超时期间段。51Testing软件测试网W7C6|'Q7K#q*a
// 例如，当脚本执行 set_window 函数51Testing软件测试网Lje ~!su
// 时，如果窗口在指定超时时间段内没有51Testing软件测试网,K^zX Fv*t/u
// 出现，则会生成错误。
void set_default_timeout ( long time );51Testing软件测试网&fzV1t!d,q9q

// set_exception 函数指定在发生异常时
e{8_;W0x%aW0// 应执行的操作。应指定要调用以处理异常
&Sb/Noj!d;x4\3L0// 窗口的函数。
9_'aIf^T(x&N0void set_exception ( LPCSTR title, long function );

// set_think_time 函数指定脚本执行51Testing软件测试网 Y?E0n i^
// 期间要使用的思考时间范围。运行脚本
.b&V|0X:@0// 时，LoadRunner 使用指定范围内的51Testing软件测试网 r8d}yUn&R
// 随机思考时间，并在每个操作完成后
// 暂停该思考时间长度。
void set_think_time ( USHORT start_range, USHORT end_range );

// set_window 函数将输入定向到51Testing软件测试网*}W4@sr@
// 当前应用程序窗口并在 GUI 图中
(c\Y"G,O0// 设置对象标识范围。
int set_window ( LPCSTR window [, int timeout ] );

r8MZde(J5ne(na0// start_session 函数在 Baan51Testing软件测试网Gu+{S-r[q
// 服务器上开始指定的会话。51Testing软件测试网2[0j,V9f5p9li
int start_session ( LPCSTR session );

R6vq8p7Dl9u-z1V1?0// static_get_text 函数返回在指定
// 静态 text 对象中找到的所有文本。51Testing软件测试网 Z1F8vp4o7?0W
int static_get_text ( LPCSTR static_obj, LPCSTR out_string );51Testing软件测试网N?_)sB#Ul

Q.C1z:Q| jiI[0// tab_select_item 函数选择一个选项卡项目。
+meM#Q"hJ7Tz0int tab_select_item ( LPCSTR tab, LPCSTR item );51Testing软件测试网*F*[l8}%^?

// tbl_activate_cell 函数在指定表单元格中
// 按 Enter 键。如果指定了列名，LoadRunner
6Q;?g&`;Y!`0// 将直接从数据库中获取该名称。
we+PeEW7f3Z5N0int tbl_activate_cell (LPCSTR table, LPCSTR row, LPCSTR column );

*h-F!@n8qxxrP6p p'h0// tbl_get_cell_data 函数根据
// 单元格包含的数据类型获取表中51Testing软件测试网?mE$qnq&e
// 指定单元格的内容。如果指定了51Testing软件测试网N C2E3~$b#v7Q
// 列名，将从数据库自身（而非应用
// 程序）中获取该名称。
|;PKt3x:lAJ7]0int tbl_get_cell_data (LPCSTR table, LPCSTR row, LPCSTR column, LPCSTR out_text );51Testing软件测试网$?` _X t

// tbl_get_selected_cell 函数51Testing软件测试网E_wRK7P\3h
// 检索焦点所在的表单元格的行号和
3AQi:iqv)P0// 列名。注意，列名取自数据库自身，51Testing软件测试网Y:X:v G~9f y
// 而非应用程序。
|Fw/^6Q0k0int tbl_get_selected_cell (LPCSTR table, char *out_row, char *out_column );

O%TP$Z!u,k'N]0// tbl_press_zoom_button 函数
+f d%D$R [A0// 激活指定表单元格的缩放窗口。51Testing软件测试网VN]{{:l
int tbl_press_zoom_button ( LPCSTR table, LPCSTR row, LPCSTR column );

// tbl_set_cell_data 函数根据单元格
!t#{ {9n,X Y8s1U!uf\0// 包含的数据类型使用指定数据设置单元格
// 的值。如果指定了列名，LoadRunner
// 将直接从数据库中获取该名称。
9AD zy/m5Y/R0int tbl_set_cell_data (LPCSTR table, LPCSTR row, LPCSTR column, LPCSTR data );

// tbl_set_selected_cell 函数将焦点51Testing软件测试网1?7y-RqL,N
// 设置到表中的指定单元格上。指定列名时，
// LoadRunner 将直接从数据库中获取该名称。
^y{7kS2gB0int tbl_set_selected_cell (LPCSTR table, LPCSTR row, LPCSTR column );51Testing软件测试网*PQi2G%a?

v"]N$pLO3M/Yn1B3f0// tbl_set_selected_row 函数选择表中的指定行。
.HA'|p?T)G]*Jt0int tbl_set_selected_row (LPCSTR table, LPCSTR row );

// tbl_set_selected_rows 函数选择指定行范围。
O-s"|!oS5dKV0int tbl_set_selected_rows(LPCSTR table, LPCSTR from_row , LPCSTR to_row );51Testing软件测试网;K-pTK:ak

+y~J|g0// tbl_wait_selected_cell 函数等待
)E[~h'~~kt l0// 表单元格显示后，再继续脚本执行。
lY f3I8SE1tN0int tbl_wait_selected_cell (LPCSTR table, char *row, char *column, UINT time );

(d?7v8l6I$?,o0// toolbar_button_press 函数激活工具栏中的按钮。
M6TxhC2VV'Zh0int toolbar_button_press (LPCSTR toolbar, LPCSTR button );51Testing软件测试网+Q4w:rw7r }

// type 函数描述发送给用于测试
// 的应用程序的键盘输入。
J9X8l$uE0int type (LPCSTR keyboard_input );

// win_activate 函数通过向指定窗口
C"nh5dk,Q0// 授予焦点并将其升到显示器最上端，51Testing软件测试网])leCUv7L
// 使其成为活动窗口（等价于单击窗口
(Lnr/}{2l1Z0// 标题栏）。所有后续输入都将提交给
H8D"q*O#v\a%} \0// 此窗口。
RY.o7W^-|0int win_activate (LPCSTR window );

// win_close 函数关闭指定窗口。
#Qf h%iTM3w&T*TuS0int win_close ( LPCSTR window );

z%f4h&`(Jsz}0// win_get_info 函数检索指定属性的值
yg#o5F\SL0// 并将其存储在 out_value 中。51Testing软件测试网*K.bw$n/n[e^j
int win_get_info ( LPCSTR window, LPCSTR property, char *out_value );

// win_get_text 函数从指定窗口或
o{A8@Gd0// 窗口区域读取文本。
8l h o{8h7t;O ^(a!E0int win_get_text ( LPCSTR window, LPCSTR out_text );

q5W'U)[1cm2kPa4Z0// win_max 函数将指定窗口
l5O5D"@e0// 最大化以充满整个屏幕。
? aEo.}4@(x'u0int win_max (LPCSTR window );51Testing软件测试网]Ku8Kz1B{

lvX{mN'S0// win_min 函数将指定窗口最小化为图标。
X'V0v/A(J0int win_min (LPCSTR window );

// win_mouse_click 函数在选中窗口51Testing软件测试网VsTl!y(]o
// 的指定坐标处执行鼠标单击操作。
int win_mouse_click (LPCSTR window, int x, int y, ButtonT button );

// win_mouse_dbl_click 函数在选中窗口51Testing软件测试网x2ep xu,q[
// 的指定坐标处执行鼠标双击操作。51Testing软件测试网gY4y#XY"M
int win_mouse_dbl_click (LPCSTR window, int x, int y, ButtonT button );

N'j"b}5rM"nd/z:u&]0// win_mouse_drag 函数在窗口内执行
// 鼠标拖动操作。注意，指定的坐标是
F%`s$A7Ge:b#?0T#r0// 相对于窗口（而非屏幕）的左上角。
int win_mouse_drag (LPCSTR window, int start_x, int start_y, int end_x, int end_y, ButtonT button );51Testing软件测试网wJ^ j:M Ra,z

// win_move 函数将窗口移动到新的绝对位置。51Testing软件测试网{Lar7N8z-yv
int win_move ( LPCSTR window, int x, int y );

-E"N#D6?5M-X!j0// win_resize 函数更改窗口的位置。
?hd*} T4a#E0int win_resize ( LPCSTR window, int width, int height );

}%N~s7pph;^0// win_restore 函数将窗口从图标化
"~6e n(`e0// 或最大化状态还原为其原始大小。
int win_restore (LPCSTR window );

'd3QvK4} ?d0// win_wait_info 函数等待窗口
// 属性达到指定值，然后继续测试
// 运行。如果未达到指定值，则函数
@)VAi6n"z/Us0// 将一直等到时间到期，然后再继
&p'K5Ux?F7l0// 续测试。
int win_wait_info (LPCSTR window, LPCSTR property, LPCSTR value, UINT time );

// win_type 函数指定 keyboard_input51Testing软件测试网(~+m ?~;RHg
// 将发送到的目标窗口。
` ?1sW?[ g(R0int win_type (LPCSTR window, LPCSTR keyboard_input );51Testing软件测试网)mU^j1zpz({

ZCEi[x']0]i0// ctrx_<obj>_get_info 函数系列将属性
// 的值分配给值缓冲区。ctrx_obj_get_info
SyAs}5h5uGG0// 是一般函数，它可以适用于任何由录制器
*NU1?2p"IR,k0// 所标识为对象的对象。
:B'FUhP)q0int ctrx_obj_get_info( const char * window_name, long xpos, long ypos, eObjAttribute attribute, char *value, CTRX_LAST );

A"f GqJ@X%K0// ctrx_<obj>_get_info 函数系列将属性的值
8r;hSld,f?0// 分配给值缓冲区。ctrx_button_get_info
k4nW|L4}0r0// 获取命令按钮的信息。
3_IWN6C)C}0int ctrx_button_get_info( const char * window_name, long xpos, long ypos, eObjAttribute attribute, char *value, CTRX_LAST );51Testing软件测试网)wB$hnP4m

r4r"Ks't0// ctrx_<obj>_get_info 函数系列将属性的值51Testing软件测试网pV]st2C9Yy8p
// 分配给值缓冲区。ctrx_edit_get_info
!PYg/V^gT1V0// 获取文本框的信息。
int ctrx_edit_get_info( const char * window_name, long xpos, long ypos, eObjAttribute attribute, char *value, CTRX_LAST );

// ctrx_<obj>_get_info 函数系列将属性的值51Testing软件测试网!S:RO:G y5qd
// 分配给值缓冲区。ctrx_list_get_info51Testing软件测试网u8Q|uR h)O
// 获取列表框的信息。51Testing软件测试网fwx/i[6j
int ctrx_list_get_info( const char * window_name, long xpos, long ypos, eObjAttribute attribute, char *value, CTRX_LAST );

// ctrx_connect_server 将 Citrix 客户端连接到 Citrix 服务器。
z(B?Y.U0u0W7I0int ctrx_connect_server (char * server_name, char * user_name, char * password, char * domain);

K-~S o]*g"E#j+T z0// ctrx_disconnect_server 断开客户端与 Citrix 服务器的连接。
9AM?8f"fw)Z"eS0int ctrx_disconnect_server (char * server_name);

// ctrx_nfuse_connect 使用 NFUSE 应用
$C3?#D5FGU1Y sv t0// 程序门户建立与 Citrix 服务器的连接。在
M g|`$Bw8K&B7p o0// 定义 NFUSE 门户的个性化规范的 ICA 文件51Testing软件测试网H3Z]&zQK/F
// 中找到的规范将从服务器上下载，在此之后
'S+hz.z9N!f4}}0// 建立连接。51Testing软件测试网,c7Q{ m:si
int ctrx_nfuse_connect(char * url);

0GV_/OJ O3HMt7A0// 使用 ctrx_get_bitmap_value51Testing软件测试网(E4Ss-X)}]
// 检索位图的哈希字符串值以用于您
/b)[A0n|pHD Z0// 的自定义同步函数中。位图坐标由51Testing软件测试网$kwis$Wl$D
// 前四个参数指定。51Testing软件测试网m4b9hM]
int ctrx_get_bitmap_value (long x_start, long y_start, long width, long height, char * buffer);

// ctrx_get_text 将矩形中的文本分配到 text_buffer51Testing软件测试网S5z5me-|{ l0\
// 中。随后，文本可被用于关联。
NlC5edsP0int 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、
0Z9]x:x6o0// ypos、width 和 height 指定区域中
Dl9[/GUQ1vj0// 搜索指定文本。如果找到字符串，当函数51Testing软件测试网5GUCMgP
// 返回后，xpos 和 ypos 即为找到文本的
O3C#a'[0\b,N#uP0// 位置。如果未找到字符串，xpos 和 ypos
/s5U!W ^;_0// 则为零。
int ctrx_get_text_location( LPCSTR window_name, long *xpos, long *ypos, long *width, long *height, LPSTR text, long bMatchWholeWordOnly, LPCSTR filename, CTRX_LAST );

^:@z }z0// ctrx_get_waiting_time 从运行时设置中获取当前等待51Testing软件测试网*oj:u,l })Ek
// 时间，或者通过 ctrx_set_waiting_time 设置的值。51Testing软件测试网]eK7\7~5ig
int ctrx_get_waiting_time ( long * time );

// 使用 ctrx_get_window_name 检索
8{0Oga v2b}|4@0// 当前获得焦点的窗口的名称。
ms2Z Pu2un4eI0int ctrx_get_window_name (LPSTR buffer);

// 使用 ctrx_get_window_position51Testing软件测试网;Z4bQx5[
// 检索名为 title 变量值的窗口的位置。
/@2a&bv8H(u0// 如果 title 为 NULL，则函数将检索
6w-ej2c)l,d^$s0// 当前拥有焦点的窗口的位置。
u` L2gKC"K+^Rm0int ctrx_get_window_position (LPSTR title, long *xpos, long *ypos, long *width, long *height);51Testing软件测试网vY)\s `s

// ctrx_list_select_item 函数从列表中选择项目。
0zF7c3y [;`0// 它支持 ListBox 或 ComboBox 类的列表。
-N&fo2L$Z0int ctrx_list_select_item(char * window_name, long xpos, long ypos, char * item, CTRX_LAST );

// ctrx_menu_select_item 突出显示
// 菜单中的项目，但不激活它。
8]`FtS Q[U0int ctrx_menu_select_item ( char * window_name, char * menu_path, CTRX_LAST) ;

~uo~zq4D0// ctrx_mouse_click 等待窗口 window_name
// 出现，然后执行鼠标单击操作。51Testing软件测试网)xD1iF6x
int ctrx_mouse_click (long x_pos, long y_pos, long mouse_button, long key_modifier, char * window_name);51Testing软件测试网(S_4n-}m.JzE

!bp?R+H-i/o0// ctrx_obj_mouse_click 等待窗口 window_name
2Ht1p3DF1I#?0// 出现，然后执行鼠标单击操作。
P Nz!S8I$G]0int ctrx_obj_mouse_click (const char * obj_desc, long x_pos, long y_pos, long mouse_button, long key_modifier, char * window_name);

/i+Rc P+w/Lo:_,Gakn0// ctrx_mouse_double_click 等待窗口 window_name
// 出现，然后执行鼠标双击操作。
-V fVHa0int 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
// 出现，然后执行按下鼠标按键操作。
C(R;h(AiSq2\H0int ctrx_mouse_down(long x_pos, long y_pos, long mouse_button, long key_modifier, char * window_name);51Testing软件测试网1we%{QnM/e$|:X

9[4X5~lz0// ctrx_obj_mouse_down 等待窗口 window_name
// 出现，然后执行按下鼠标按键操作。
w3X)Fqr[0int ctrx_obj_mouse_down(const char * obj_desc, long x_pos, long y_pos, long mouse_button, long key_modifier, char * window_name);

6])~n2Q ^+V;S(wj0// ctrx_mouse_up 等待窗口 window_name
v#re YG+Y;u)~0// 出现，然后在指定位置执行释放鼠标按键操作。51Testing软件测试网}\K"N8CZ
int ctrx_mouse_up(long x_pos, long y_pos, long mouse_button, long key_modifier, char * window_name );51Testing软件测试网/J1sHDuI;F/m

// ctrx_obj_mouse_up 等待窗口 window_name51Testing软件测试网T0Y0D'Q8nk y
// 出现，然后在指定位置执行释放鼠标按键操作。
7A)zP!Vc1J0int ctrx_obj_mouse_up(const char * obj_desc, long x_pos, long y_pos, long mouse_button, long key_modifier, char * window_name );

'c%I/oV4A*Qt7D:m({A0// ctrx_set_window 是同步函数，它等待51Testing软件测试网nY4@7n9\!br(u
// 窗口出现，然后 Vuser 才在该窗口中模拟
Sp0w!yw!_9a#b`0// 任何键盘或鼠标活动。
;d4{'Fg|v3W&?0}ZA0int ctrx_set_window (char * window_name);51Testing软件测试网q g*Mq^3Kp3V

8s Q#Jl(hL5]s)d(n&e1F0// ctrx_set_window_ex 是同步函数，它至多
L"H-](b M-_0// 等待 time 秒，若窗口出现，Vuser 将在该
7{W%tr"kO8u0// 窗口中模拟任何键盘或鼠标活动。
int ctrx_set_window_ex (char * window_name, long time);

// ctrx_key 模拟用户在 Citrix 客户端中
// 按下非字母数字键。
*@Nr/Y d)t%dY3Tc!`0int ctrx_key (char * key, long int key_modifier);

&eXZ]3x'GJ0// 函数 ctrx_type 模拟用户键入字母数字字符。
Tb2b0fo0OnU0int ctrx_type (char * data);

// ctrx_save_bitmap 将位图保存为文件。
^Lq.U;n m~|+L0// 该文件将保存在 Vuser 结果日志目录中。
2{;ej|9\E2UI0int ctrx_save_bitmap( long x_start, long y_start, long width, long height, const char * file_name );51Testing软件测试网xqg7P)QfB~

// ctrx_set_connect_opt 在建立 Citrix 客户端51Testing软件测试网(\gq F?;zu
// 与 Citrix 服务器的连接之前设置连接选项，然后
!JSl&v&Vw.R0// 执行与服务器的连接。
OF"`b.M0Ilw%chj0int ctrx_set_connect_opt (eConnectionOption option, char * value);51Testing软件测试网m7\C`.y

// ctrx_set_exception 定义当不规则
8k%U-Q+M9Pu0cz }0// 事件发生时要执行的操作。此事件必须
rZD W#}0// 与名为 window_title 的窗口（通常
// 为弹出式对话框）的外观相关联。当窗口
_*N:}@k#bQ Uxe'E0// 出现时，将调用 handler 函数。
void ctrx_set_exception ( char * window_title, long handler, [void *context]);

\)kbx+_2O1E0// ctrx_set_waiting_time 更改51Testing软件测试网M-Eer;z Xe
// 同步函数默认 60 秒的等待时间。51Testing软件测试网zdUk-Lh
int ctrx_set_waiting_time (long time);

// ctrx_sync_on_bitmap 是同步函数，51Testing软件测试网PY"FW:?7L
// 它等待指定位图出现，然后再继续执行。51Testing软件测试网!r)w2@$A+RU
int ctrx_sync_on_bitmap (long x_start, long y_start, long width, long height, char * hash);

)LVS(t1{+]*AE0// ctrx_sync_on_bitmap_change 是同步51Testing软件测试网8k-m `&q.m$w
// 函数，它等待指定位图改变，然后再继续执行。
jn!cF S0// 该函数通常用在窗口改变而窗口名称保持
1VvI_\4oT0// 不变的情况下。如果窗口名称改变，51Testing软件测试网Q)AE4UJ.xQrj
// 则 ctrx_set_window 将被自动
%T6tg.\a1lB c0zF1?3c0// 生成。
w"J|bd0int ctrx_sync_on_bitmap_change (long x_start, long y_start, long width, long height, <extra_args>, CTRX_LAST);

// ctrx_sync_on_obj_info 被调用时，执行将暂停，51Testing软件测试网h$Di3VpN"W
// 直到指定对象的属性具有指定的值。51Testing软件测试网Jm,|id_Z:u
int ctrx_sync_on_obj_info ( char * window_name, long xpos, long ypos, eObjAttribute attribute, char * value, <CTRX_LAST> );

// ctrx_sync_on_window 是同步函数，
]&C0YZgTs)c0// 它等待窗口被创建或变为活动的。
&[\!F)u3fz0int 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 是同步函数，它等待51Testing软件测试网 BR1gV@5{
// 窗口被关闭，然后脚本才继续执行。
int ctrx_unset_window (char * window_name);

j1` T,_#R1Y/D0ke&`0// ctrx_wait_for_event 是同步函数，
T#^ehCkR&I&zCC` i0// 它等待事件发生。
{+N%f:TgW/v!m a0int ctrx_wait_for_event (char * event);

i_H9g7O0// 如果窗口存在，ctrx_win_exist 返回 E_OK（零）。
r"G5ygD(f\+a(g H0// 在 window_name 中可以使用通配符 (*)。51Testing软件测试网b7@#jyg!VA
int ctrx_win_exist (char * window_name, long waiting_time);51Testing软件测试网"J8o2w1rNH,C

// 有关 memchr 的详细信息，请参考 C 语言文档。51Testing软件测试网"z{?!n8Hmh
void *memchr ( const void *s, int c, size_t n );

// 有关 memcmp 的详细信息，请参考 C 语言文档。
Ez9V7kY4YA0int memcmp ( const void *s1, const void *s2, size_t n );51Testing软件测试网V$j*ECkBI

DsAy5Y uG0// memcpy 函数从 src 缓冲区中将 n 个
m MX$Vpo5S0// 字符复制到 dest 缓冲区。
void *memcpy ( void *dest, const void *src, size_t n );

"l8GgJGU0// 函数 memmove（以及所有不返回 integer 类型
M(^zTu2ez'_ {0// 的函数）必须明确在 Vugen 脚本中声明。
[%{G;YI[0void *memmove ( void *dest, const void *src, size_t n );51Testing软件测试网J;FO?-k1_H

// 有关 memset 的详细信息，请参考 C 语言文档。
#^[kg#`0void *memset ( void *buffer, int c, size_t n );

// 有关 getenv 的详细信息，请参考 C 语言文档。
`@Pa {2fU4boT*N0char *getenv ( const char *varname );

// 有关 putenv 的详细信息，请参考 C 语言文档。
Na2L#{;E)lE0int putenv ( const char *envstring );51Testing软件测试网5gekF1B(U

+}oH5Hm;Du NO0// 有关 system 的详细信息，请参考 C 语言文档。
6X7X(j+zxj0int system ( const char *string );

)G6N.D4f(MR|0// 有关 calloc 的详细信息，请参考 C 语言文档。51Testing软件测试网~a`t:D3X
void *calloc ( size_t num elems, size_t elem_size );

bf(m b`*r0s+K{0// 有关 free 的详细信息，请参考 C 语言文档。
void free ( void *mem_address );

_+v@T6J5m~-u0// 有关 malloc 的详细信息，请参考 C 语言文档。
,[,}QP@F0void *malloc ( size_t num_bytes );51Testing软件测试网)f?A0[+_8D

// 有关 realloc 的详细信息，请参考 C 语言文档。
m3mF R%c;i4~l0void *realloc ( void *mem_address, size_t size );51Testing软件测试网q-nz#c.IDE3n

// 有关 abs 的详细信息，请参考 C 语言文档。51Testing软件测试网V3ka/_6U
int abs ( int n );

@,@T+j(C|7c0// 限制：cos 函数在 AIX 平台中无法使用。
H7P sSdb+nPO0double cos ( double x );

// 函数 floor（以及所有不返回 int 值的函数）51Testing软件测试网wP)TA5E3OT
// 必须明确在 Vugen 脚本中声明。限制：此
UeY7I%ZtZ7z0// 函数在 AIX 平台中无法使用。51Testing软件测试网5Mn0w\'d6{6H
double floor ( double x );

// 在调用 rand 前，请调用 srand 以
// 播种伪随机数生成器
(k5J yb(w^0int rand ( void );

// 限制：sin 函数在 AIX 平台中无法使用。
&C aWlVLuy'A0double sin ( double x );

*?4~Z6x)w!b0// 函数 sqrt（以及所有不返回 int 值的
// 函数）必须明确在 Vugen 脚本中声明。51Testing软件测试网*Hs J%A%`
// 限制：sqrt 函数在 AIX 平台中
// 无法使用。
double sqrt ( double x );

0]%y2K$k"k;[g0// 在调用 rand 前，请调用 srand 以
// 播种伪随机数生成器51Testing软件测试网r4}a1C*dhb
int srand ( time );

// 有关 fclose 的详细信息，请参考 C 语言文档。
vu5MzH-\0int fclose ( FILE *file_pointer );

A/u3_2Qt%H0// 请不要在脚本中包括操作系统头文件（例如，stdio.h）。51Testing软件测试网Ge L@n
// 但是，这样将导致某些类型（包括 feof 使用的 FILE
// 类型）未经定义。这时，请使用 long 替代 FILE
et*ve kc M0// 类型。51Testing软件测试网qk%q6CG+ZB
int feof ( FILE *file_pointer );

1p#NjJu0^*vd^0// 有关 ferror 的详细信息，请参考 C 语言文档。51Testing软件测试网k5zKg1p
int ferror ( FILE *file_pointer );51Testing软件测试网,S3N}VoFN

// 请不要在脚本中包括操作系统头文件（例如，
h Bzds0// stdio.h）。但是，这样会导致某些类型
Lf }H+h$T2zdzh0// （包括 fgetc 使用的 FILE 类型）未经定义。
// 这时，请使用 long 替代 FILE 类型。51Testing软件测试网bpo&g*m;N
int fgetc ( FILE *file_pointer );

// 请不要在脚本中包括操作系统头文件（例如，51Testing软件测试网Ze J~!m
// stdio.h）。但是，这样会导致某些类型
// （包括 fgets 使用的 FILE 类型）未经定义。51Testing软件测试网6l V!C8k{\
// 这时，请使用 long 替代 FILE 类型。
A/\%x{({O5LqN[0char *fgets ( char *string, int maxchar, FILE *file_pointer );

// 通过将 t 或 b 字符添加到 fopen 的 access_mode
8cO v:P~?{ [0// 参数，此访问模式字符串还将用于指定打开文件的方式51Testing软件测试网&j.fV2@5H
// （文本还是二进制）。51Testing软件测试网,PhUxa{j@
FILE *fopen ( const char *filename, const char *access_mode );

// 有关 fprintf 的详细信息，请参考 C 语言文档。
#b|jB)Ig4f,l0int fprintf ( FILE *file_pointer, const char *format_string [, args ] );

*L[$l$ZWI%y0// 请不要在脚本中包括操作系统头文件（例如，
zbk B|8u9qm0// stdio.h）。但是，这样会导致某些类型
;_!l8B;S*HyNoh x0S0// （包括 fputc 使用的 FILE 类型）未经定义。51Testing软件测试网J,n8VPl#Jq`t
// 这时，请使用 long 替代 FILE 类型。51Testing软件测试网bE4A^%mbj
int fputc ( int c, FILE *file_pointer );

]#oE!^@LGI`0// 请不要在脚本中包括操作系统头文件（例如，51Testing软件测试网[/nsr.} FiQ&l
// stdio.h）。但是，这样会导致某些类型
Y(NyV2Thy'i0// （包括 fread 使用的 FILE 类型）未经定义。51Testing软件测试网T yuJV@H#NR
// 这时，请使用 long 替代 FILE 类型。
LT1`NC/a[0size_t fread ( void *buffer, size_t size, size_t count, FILE *file_pointer );

"Tf2X0s n.U8i0// 有关 fscanf 的详细信息，请参考 C 语言文档。
!jf#o4r j8p0int fscanf ( FILE *file_pointer, const char *format string [, args] );51Testing软件测试网[&[#v9U N.D

!]q7JE6px9p7[k0// 有关 fseek 的详细信息，请参考 C 语言文档。
AeT&Krf8kcg0int fseek ( FILE *file_pointer, long offset, int origin );

// 请不要在脚本中包括操作系统头文件（例如，
KAoU4h0// stdio.h）。但是，这样会导致某些类型51Testing软件测试网%LYn#Tz ~*R
// （包括 fwrite 使用的 FILE 类型）未经定义。51Testing软件测试网 fS9b8z5w+q;J
// 这时，请使用 long 替代 FILE 类型。51Testing软件测试网0[],Q\f-J
size_t fwrite ( const void *buffer, size_t size, size_t count, FILE *file_pointer );51Testing软件测试网+~D:["A*V&Q

h[-cU0au9[0// 有关 rewind 的详细信息，请参考 C 语言文档。
F'?DN's3ju0void rewind ( FILE *file_pointer );

7r_'X9r&Na&e p0// 有关 sprintf 的详细信息，请参考 C 语言文档。
int sprintf ( char *string, const char *format_string[, args] );

O a_8j vcF0// 有关 sscanf 的详细信息，请参考 C 语言文档。
int sscanf ( const char *buffer, const char *format_string, args );51Testing软件测试网Rylq:`4n.^

// 有关 chdir 的详细信息，请参考 C 语言文档。
`\ k^f5q\g#en'^1g0int chdir ( const char *path );

?wHt}(v$U}_"he%o0// chdrive 将当前工作驱动器更改为 drive（表示新驱动器
LLU7G U0// 的 integer 类型值）。例如，1 = A、2 = B，依此类推。51Testing软件测试网iD#N:`G
int chdrive ( int drive );51Testing软件测试网@1r `(Q9U

// 有关 getcwd 的详细信息，请参考 C 语言文档。51Testing软件测试网'k/FMy3`+Hx
char *getcwd ( char *path, int numchars );

OC0ScG$l!{2QY-e'u O0// getdrive 函数返回表示驱动器字母
#?msE!Zz b"mN'j0// 的 integer 类型值：1 = A、2 = B，依此类推。
int getdrive ( void );

!L {Q-q+A;h0// 有关 mkdir 的详细信息，请参考 C 语言文档。
t8Y;T^UD(yN k l+H0int mkdir ( const char *path );51Testing软件测试网yjO#ItO{

!?}4w Uq+?H `0// 有关 remove 的详细信息，请参考 C 语言文档。
@M)jr(y;A(Ft0int remove ( const char *path );

2ek"}9gL#R$Xe0// 有关 rmdir 的详细信息，请参考 C 语言文档。
!P9j?_;n;Iycd$w0int rmdir ( const char *path );

UT$c9[)i_j3vN0// 根据系统时钟，time 函数返回从世界标准
Arm5BB-h"LM)p0// 时间 1970 年 1 月 1 日子夜 (00:00:00)51Testing软件测试网#V1_}&| x
// 作为开始所经过的秒数。返回值存储在 timeptr51Testing软件测试网V[q p$hs
// 所给出的位置。如果 timeptr 为 NULL，则
0Q)BC.d5Sga*?0// 该值不会被存储。
time_t time ( time_t *timeptr );

e%ElT7p9ff$_7`-Kj#nD0// 在 Unix 下，ctime 不是线程级安全函数。所以，请使用 ctime_r。
6?eR*@&MY%qd0// 有关详细信息，请参阅平台相关文档。51Testing软件测试网,d3p1VQ[8m
char *ctime ( const time_t *time );51Testing软件测试网p3Z5xQ|h:ur

9h#f*j3~[%wL(G$T0// 有关 ftime 的详细信息，请参考 C 语言文档。
void ftime ( struct _timeb *time1 );51Testing软件测试网yJ`qr1R5O

3m1R7BZ![0// 在 Unix 下，localtime 不是线程级安全函数。
_u)fUIQ.l0// 所以，请使用 localtime_r。有关详细信息，请51Testing软件测试网y;B%FG[:N
// 参阅平台相关文档。51Testing软件测试网Z-xn;tyZ2}l
struct tm *localtime ( const time_t *time );51Testing软件测试网x2qF-?3w3~^

v tw,m s}+Z$N0// 在 Unix 下，gmtime 不是线程级安全函数。所以，请使用 gmtime_r。
0E1u{U f7s0// 有关详细信息，请参阅平台相关文档。
struct tm *gmtime ( const time_t *time );51Testing软件测试网(k s[4L cbO1I

// 在 Unix 下，asctime 不是线程级安全函数。所以，请使用 asctime_r。
!S&u#t@&y0// 有关详细信息，请参阅平台相关文档。
char *asctime ( const struct tm *time );51Testing软件测试网a6S:tY__(x

2M?i;\N9L0|T0// 通过停止在第一个非数字字符上，atof 只
// 读取字符串的初始位置。函数 atof（以及
// 所有不返回 integer 类型值的函数）51Testing软件测试网:c"p9c FM.h
// 必须明确在 Vugen 脚本中声明。51Testing软件测试网FUx,R/O V}
double atof ( const char *string );

l/\#ec!T9y4qlWJ0// 通过停止在第一个非数字字符上，atoi 只
.A8`3]"x[I"w:_0// 读取字符串的初始位置。
J7|7G"t.uT0int atoi ( const char *string );51Testing软件测试网Ba3p E`

4zpfP9D-F5yKn z$q0// 通过停止在第一个非数字字符上，atol 只
\Kk6jl+L p0// 读取字符串的初始位置。函数 atol（以及51Testing软件测试网;Nj\[Re8Z
// 所有不返回 integer 类型值的函数）必须
// 明确在 Vugen 脚本中声明。
long atol ( const char *string );

i1S1|5OJ`0// itoa 将 value 的数字转换为以 radix 作为
// 基数的字符串 str。通常，radix 是 10。
A)_X(x`@YC0int itoa ( int value, char *str, int radix );51Testing软件测试网zL-U$I#r]"d

Ox)f!Li C0// 通过停止在第一个非数字字符上，strtol
// 只扫描字符串的初始位置。所有前置空格51Testing软件测试网1S7]2{K(vN
// 都将被去除。endptr 指向停止扫描的字符。
// 函数 strtol（以及所有不返回 integer51Testing软件测试网b D@2k*~.]'[
// 类型值的函数）必须明确在 Vugen 脚本中
// 声明。
long strtol ( const char *string, char **endptr, int radix );

// 有关 tolower 的详细信息，请参考 C 语言文档。51Testing软件测试网R$^;j x7s|
int tolower (int c);51Testing软件测试网J9sv6c"`.O

// 有关 toupper 的详细信息，请参考 C 语言文档。
zH'|*j@b0int toupper ( int c );

// 有关 isdigit 的详细信息，请参考 C 语言文档。51Testing软件测试网we_${/Vp
int isdigit ( int c );51Testing软件测试网~.VgN6q{!a

// 函数 isalpha 检查 c 的值是否51Testing软件测试网#XzD,~ qU
// 处于 A - Z 或 a - z 的范围之内。
`k(YVO Q0int isalpha ( int c );

// strcat 连接两个字符串。51Testing软件测试网tS#^3Py_1jF
char *strcat ( char *to, const char *from );

// strchr 返回指向字符串中51Testing软件测试网L1c0yQ"pT(N
// 第一个匹配字符的指针。51Testing软件测试网3g*_5D(i|
char *strchr ( const char *string, int c );

gwa#zK/q``*R0// strcmp 比较 string1 和 string2 以确定字母排序的次序。
tXX(]al3xG:H Ab0int strcmp ( const char *string1, const char *string2 );

+aV;o-gQu~)r @0// strcpy 将一个字符串复制给另一个。51Testing软件测试网B7\#w;FB7mO
char *strcpy ( char *dest, const char *source );

2Kx#`Nm:d'N0// strdup 复制字符串的副本。
char *strdup ( const char *string );51Testing软件测试网P2j&V{!rZ7}

n(D$M(O/?0// stricmp 对两个字符串进行不区分大小写的比较。51Testing软件测试网Of/[4_.u ~E
int stricmp ( const char *string1, const char *string2 );

// strlen 返回字符串的长度（以字节为单位）。
C7IU+B R6DCl6J,|c$w0size_t strlen ( const char *string );51Testing软件测试网@NhR9ovL

// strlwr 将字符串转换为小写。51Testing软件测试网+[Y/W8e E{4N
char *strlwr ( char *string );51Testing软件测试网#kP&n-bJE

b9g^ u!x-|0// strncat 将一个字符串的 n 个字符连接到另一字符串。51Testing软件测试网6m D*bp/s5K
char *strncat ( char *to_string, const char *from_string, size_t n );

.o W8h3tjX0// strncmp 比较两个字符串的前 n 个字符。51Testing软件测试网']/b3{/LvS
int strncmp ( const char *string1, const char *string2, size_t n );51Testing软件测试网9_$CjRb+itG

// strncpy 将一个字符串的前 n 个字符复制到另一字符串。51Testing软件测试网D5W$F1z Ug
char *strncpy ( char *dest, const char *source, size_t n );51Testing软件测试网1K I*w.saWP'Y

// strnicmp 对两个字符串的 n 个
E4sf2ey0// 字符进行不区分大小写的比较，以
// 确定其字母排序的次序。
int strnicmp ( const char *string1, const char *string2, size_t num);

// strrchr 查找一个字符串中的最后一个匹配字符。
SJ1E!u{)T9m2e0f0char *strrchr ( const char *string, int c );

Y O+jB"u$hP0// strset 使用指定字符填充字符串。51Testing软件测试网RQH]iw]
char *strset( char *string1, int character );51Testing软件测试网t1_|+w$@v6\C

0ti'Qj/B~1mM ]4O0// strspn 返回指定字符串中包含另一
// 字符串起始字符的长度。51Testing软件测试网6f-Cq;LX A
size_t *strspn ( const char *string, const char *skipset );

// strstr 返回一个字符串在另一字符串中第一次发生匹配的指针。
char *strstr ( const char *string1, const char *string2 );51Testing软件测试网.kL6T'WK

// strtok 从由指定的字符分隔的字符串中返回标记。51Testing软件测试网x+j z;y]
// 注意，在 Vugen 文件中，需要明确声明不返回51Testing软件测试网M/tW#q9gw#UL
// integer 类型值的 C 函数。
dc._9~4V.a|0char *strtok ( char *string, const char *delimiters );51Testing软件测试网(je_(@|'z

&hb#{V(q@0// strupr 将字符串转换为大写。51Testing软件测试网(v%Ob(]aq-fG
char *strupr ( char *string );

$n1e]]d6b6\L-E0// lrc_CoCreateInstance 函数在本地系统或为特定
:\D+|`7PL![1S}0// 对象创建的默认主机中创建该对象的单个未初始化实例51Testing软件测试网Ms1F%b7S4Q#q
// 并返回未知接口，该接口可用于获取其他接口。创建
7u"q{)Ye]0// 该实例后，VuGen 调用 lrc_CoGetClassObject
:C*yk _RJ |q)f\0// 以检索接口。如果 COM 对象位于远程计算机中，
// 将使用 lrc_CreateInstanceEx 取代51Testing软件测试网%V8Nw L:t0tf
// lrc_CoCreateInstance。51Testing软件测试网w l,CW5F'ph
HRESULT lrc_CoCreateInstance(GUID * pClsid, IUnknown * pUnkOuter, unsigned long dwClsContext, GUID * riid, LPVOID * ppv, BOOL __CheckResult);

+f.vc]]} Mp0// lrc_CreateInstanceEx 函数在指定的
%Jt,|'N.C6t |c0// 远程计算机上创建未初始化的对象，并且51Testing软件测试网)N x k S*}([g@
// 可以返回任意数量的请求接口。
6d4x5z5I#u@0HRESULT lrc_CreateInstanceEx(char *clsidStr, Iunknown *pUnk, DWORD dwClsCtx, ...);

mm]@_r0// lrc_CoGetClassObject 函数提取
// 指定类的类工厂。
W'Z%G+D2sZ A"e0p0void lrc_CoGetClassObject( REFCLSID rclsid, Long dwClsContext, COSERVERINFO * pServerInfo, REFIID riid, LPVOID * ppv);51Testing软件测试网;^q4O%\%M+e

// lrc_GUID 函数返回命名对象（例如
// COM 接口）的 GUID。VuGen 使用它
D:} hPnS&K{0// 检索标识符，该标识符用于检索接口
%U%{d(l~!G0// 标识符和用于 COM 通信的 COM 对象
y M@Mn]"JF0// 的 PROGID。
h sq+g:j0GUID lrc_GUID(const char *str);

// lrc_GUID_by_ref 函数返回指向命名对象
fw6GC,\0x-`0// （例如 COM 接口）的 GUID 的指针。VuGen51Testing软件测试网h:M!H e)T)s
// 使用它检索标识符，该标识符用于检索接口51Testing软件测试网U qM4\T)M5`^
// 标识符和用于 COM 通信的 COM 对象的
// PROGID。51Testing软件测试网1L@gd5k7Y
GUID* lrc_GUID_by_ref(const char *str);51Testing软件测试网0l2n5y_0T

4S8L$}+cA4g.lF0// lrc_DispMethod 函数使用 IDispatch:Invoke
U} @8n8D:WS)P0// 方法调用接口的方法。lrc_DispMethod 调用
!e-Hz.E#Z \(q,xc6OV0// 将 wflags 设置为 DISPATCH_METHOD。
VARIANT lrc_DispMethod(IDispatch * pDispatch, char *idName, unsigned long locale, ...);

;p8G,f"mr Yg0// lrc_DispMethod1 使用 IDispatch 接口调用51Testing软件测试网*P+?8d nq l9u
// （或获取）同名的方法（或属性）。lrc_DispMethod151Testing软件测试网WXnK+R/O7`m
// 调用将 wflags 设置为 DISPATCH_METHOD 和
O nor9Ol(i z]0// DISPATCH_PROPERTYGET。它可以用在方法与属性
/w@0^)Q8^g9_5M0// 具有同一名称的情况下。51Testing软件测试网Pt2}5?(AG#u(T
VARIANT lrc_DispMethod1(IDispatch * pDispatch, char *idName, unsigned long locale, ...);

Cz6s9e#nqX U0// lrc_DispPropertyGet 调用使用 IDispatch 接口
// 获取属性并将 wflags 设置为 DISPATCH_PROPERTYGET。
3A9V MU2mo4s%eK0VARIANT lrc_DispPropertyGet(IDispatch * pDispatch, char *idName, unsigned long locale, ...);51Testing软件测试网"eC |A3C

// lrc_DispPropertyPut 使用 IDispatch 接口设置属性。51Testing软件测试网b1o1~-h3T.a
// 该调用将设置 DISPATCH_PROPERTYPUT 标志。
void lrc_DispPropertyPut(IDispatch * pDispatch, char *idName, unsigned long locale, ...);51Testing软件测试网7AeI5?u

// lrc_DispPropertyPutRef 使用 IDispatch 接口根据
CgGC@Ow}/i%o0// 引用设置属性，并设置 DISPATCH_PROPERTYPUTREF 标志。
void lrc_DispPropertyPutRef(IDispatch * pDispatch, char *idName, unsigned long locale, ...);

// lrc_CreateVBCollection 函数创建填充安全51Testing软件测试网_:RTyB1E'B
// 数组值的 Visual Basic (VB) Collection 对象，
.r$X"J"`6Q-t0// 并将集合接口指针返回到 pCollection 中。
I!Y0m }\r,re0// VB 集合是由 COM 实现为接口的变量51Testing软件测试网.t,`;D*j-s7|h
// SafeArray。51Testing软件测试网Tp.|.\O\z
HRESULT lrc_CreateVBCollection(SAFEARRAY *items, _Collection** pCollection);

%I[#J5VC`Po{i2H0// lrc_CoObject_from_variant 函数从变量中51Testing软件测试网)Ta5k.x!r;` ~G
// 提取 IUnknown 接口类型指针。51Testing软件测试网9aq]l4pUay
IUnknown* lrc_CoObject_from_variant(VARIANT var);51Testing软件测试网%lCR+a [fT

#j7AV8B1f7as0// lrc_DispObject_from_variant 函数从变量中
M4`WR)V0// 提取 IDispatch 接口类型指针。51Testing软件测试网![H_P_$jb
IDispatch* lrc_DispObject_from_variant(VARIANT var);51Testing软件测试网z:|!n?]z,i

// lrc_CoObject_by_ref_from_variant 函数从指向51Testing软件测试网)RUk%L'Y&t1Cq
// 变量的指针中提取 IUnknown 接口类型指针。
3v$s Bg%V8Vv/w+WE0IUnknown* lrc_CoObject_by_ref_from_variant(VARIANT var);

{Se(F3|3ka0// lrc_DispObject_by_ref_from_variant 函数从指向
// 变量的指针中提取 IDispatch 接口类型指针。
IDispatch* lrc_DispObject_by_ref_from_variant(VARIANT var);

// 输入表示整数的字符串时，lrc_int 函数返回
-tJB2Xu0// integer 类型值。此参数可以是文字字符串、
-w t] i(Hxn#lud0// 变量或参数。
&C|m5E&g,E*Ur0int lrc_int(const char* str);

// 输入表示整数的字符串时，lrc_int_by_ref51Testing软件测试网rfE4y;g{3C
// 函数返回指向 integer 类型值的指针。此参数
// 可以是文字字符串、变量或51Testing软件测试网,a/vK J!qm;Ub
// 参数。
int* lrc_int_by_ref(const char* str);

;?6\?Ce{v[0// lrc_save_int 函数将 integer 值
-Q'Rk|!}M.f0// 保存在指定变量 name 下的字符串中，以便
// 您将其用于参数化。VuGen 将此函数生成
// 为注释掉的调用。如果要将此值用作参数，
UM`'F M0// 可以更改 name 参数并取消调用的51Testing软件测试网)w(|4o0P,~
// 注释。
L2S ~*C0e3QwD%Ba0int lrc_save_int(const char* name, int val);51Testing软件测试网3_@Av D E

o}:kELfkJJ0// lrc_save_int_by_ref 函数将 integer 值
dp*t#Cz(GpmO/C0// 保存在字符串中，并将 val 设置为指向该字符串。
!BFhdj+C.Ow0// VuGen 将此函数生成为注释掉的调用。如果要51Testing软件测试网YS {0I5|p x
// 将此值用作参数，可以更改 name 并取消调用51Testing软件测试网~t OI ByZ$}
// 的注释。
,p6MBM@Bg/d*f0int lrc_save_int_by_ref(const char* name, int *val);

*Z]a"{y0// lrc_get_bstr_length 返回 BSTR 类型字符
// 串的长度。BSTR 字符串可以包括 null。
int lrc_get_bstr_length(BSTR str);

// lrc_get_bstr_sub 从输入字符串 str 的开始处
oN.sf8Wik%[0// 返回 size 个字符的子集。51Testing软件测试网GB ?$c\ n
BSTR lrc_get_bstr_sub(BSTR str, int size);

?3`z(W/y}\0// lrc_print_bstr 将 BSTR 字符串输出到
// 用于调试目的的标准输出上。
cTkL}(z s0int lrc_print_bstr(BSTR str);

z-d%E k[h7RQ0// lrc_BSTR1 创建长度为 len 的 BSTR 字符串，它可以包括 null。
BSTR lrc_BSTR1 (const char* str, long len);

// lrc_save_BSTR1 函数将 BSTR str 保
4YVx9HaJ,G0// 存到字符串 name 中。
int lrc_save_BSTR1 (const char* name, BSTR str);

// 输入表示无符号整数的字符串时，lrc_uint 函数
;PSlH(NHD0// 返回无符号 integer 类型值。51Testing软件测试网 \7{9BrG3wk
unsigned int lrc_uint(const char* str);

ncqtwi1z6_0// 输入表示无符号整数的字符串时，lrc_uint_by_ref51Testing软件测试网H#j?e/A:d
// 函数返回指向无符号 integer 类型值的
/? ?~K!V:Q9B0// 指针。
%H"d(D7^1cBOaj0unsigned int* lrc_uint_by_ref(const char* str);

#Np2KZA+{0// lrc_save_uint 函数将无符号 integer 值51Testing软件测试网m4eJ-h7W-q
// 保存在指定变量 name 下的字符串中，以便51Testing软件测试网&e;rJ;si.C
// 您将其用于参数化。VuGen 将此函数生
6H#p.kxn'Z4E7`;]0// 成为注释掉的调用。如果要将此值用作
// 参数，可以更改 name 参数并取消调用的
R8_~pn!]/|0// 注释。
int lrc_save_uint(const char* name, unsigned int val);51Testing软件测试网[Fv;dct

// lrc_save_uint_by_ref 函数将
L ?h E5p0// 无符号 integer 类型值保存在字符串中，
_I~2}%q d0// 并将 val 设置为指向该字符串。VuGen 将此
L5y$d_NO-x:o0// 函数生成为注释掉的调用。如果要将此值
S7vzo5q0// 用作参数，可以更改 name 并取消调用的注释。51Testing软件测试网D~UKA
int lrc_save_uint_by_ref(const char* name, unsigned int *val);

}4`f}2e;J3C0// 输入表示 long 类型的字符串时，lrc_long 函数
SX-B3o)RJ0// 返回长整型值。51Testing软件测试网#\;UC/{t7E c
long lrc_long(const char* str);51Testing软件测试网5a}@?/O1KB

d4M v#s~q0// 输入表示 long 类型的字符串时，lrc_long_by_ref 函数
// 返回指向长整型值的指针。51Testing软件测试网E]2NGOX
long* lrc_long_by_ref(const char* str);

// lrc_save_long 函数将长整型值
P-TY&L5u9d a)YO"o0// 保存在指定变量 name 下的字符串中，
QpiL IA*h0// 以便您可以将其用于参数化。VuGen
// 将此函数生成为注释掉的调用。如果
r5ju-NE(`#\9L.Eb0// 要将此值用作参数，可以更改 name
.`w;d0AIzt"[*U0// 并取消调用的注释。51Testing软件测试网k!GE3a^+D&mm
int lrc_save_long(const char* name, long val);

n`Lr$w0// lrc_save_long_by_ref 函数将长整型值保存在字符串中，51Testing软件测试网Dw4ZA)HQ
// 并将 val 设置为指向该字符串。
]H0z1}$M5c_e b0int lrc_save_long_by_ref(const char* name, long *val);

// 输入表示无符号 long 类型值的字符串时，
)H a{U~0// lrc_ulong 函数返回无符号长整型值。
unsigned long lrc_ulong(const char* str);51Testing软件测试网`VB] K1o*\

// 输入表示无符号 long 类型值的字符串时，
// lrc_ulong_by_ref 函数返回指向无符号长整型值
6v5E:Z'^,bu0// 的指针。
unsigned long* lrc_ulong_by_ref(const char* str);

,GQm[7b'O2k0// lrc_save_ulong 函数将无符号
Aqc%v\G6Y0// 长整型值保存在指定变量 name 下51Testing软件测试网W0V9MU2x S&w
// 的字符串中，以便您可以将其用于参数化。51Testing软件测试网)@ sp2DV1n
// VuGen 将此函数生成为注释掉的调用。
7vo([g+i0// 如果要将此值用作参数，可以更改 name
Gp+_F`;|3wHM-S ~Z0// 并取消调用的注释。51Testing软件测试网7oC@nh{2W
int lrc_save_ulong(const char* name, unsigned long val);

8_jH(t R IV0// lrc_save_ulong_by_ref 函数将无符号长整型值保存为字符串，
e([eFt0// 并将 val 设置为指向该字符串。
4DJExq1D!T0int lrc_save_ulong_by_ref(const char* name, unsigned long *val);

// 输入表示短整型值的字符串时，lrc_short 函数
D#CC%FO)p G(w C+}+L0// 返回短整型值。51Testing软件测试网5l1Y1o)jlr
short lrc_short(const char* str);

v,J-g%`EP j1bx0// 输入表示短整型值的字符串时，lrc_short_by_ref 函数
al6O'jslm!a7Q0// 返回指向短整型值的
// 指针。
\.GF3r t-f8U{$Et0c0short* lrc_short_by_ref(const char* str);51Testing软件测试网jx#msj![

// lrc_save_short 函数将短整型值保存
otj%a-E(].i2P0// 在指定变量 name 下的字符串中，以便
j2~)S,j1n;ACw0// 您可以将其用于参数化。VuGen 将此
// 函数生成为注释掉的调用。如果要将此值51Testing软件测试网'J-Z%Lt/X/EO8m
// 用作参数，可以更改 name 并取消调用的
%L,Vw6vO0// 注释。
q%E+gQWn$A0int lrc_save_short(const char* name, short val);

4?j9B*T"GKB0// lrc_save_short_by_ref 函数将短整型值保存在字符串中，
HpR*g(dpcZc A0// 并将 val 设置为指向该字符串。
p-lh5e1{r0q9xE$J*`0int lrc_save_short_by_ref(const char* name, short *val);51Testing软件测试网3ot4Yc,v

// 输入表示货币值的字符串时，lrc_currency 函
^%Po:dK0// 数返回货币值。51Testing软件测试网r2a0E~mX
CY lrc_currency(const char* str);51Testing软件测试网;X?iq-S

2HI(Hj^_0// 输入表示货币值的字符串时，
Yc_m|o0// lrc_currency_by_ref 函数返回指向
?VRI(h7nDh-rR B0// 货币结构的指针。51Testing软件测试网 Ml;m"D7[&CN+V
CY* lrc_currency_by_ref(const char* str);

// lrc_save_currency 函数将货币 (CY) 值
// 保存在指定变量 name 下的字符串中，以便您
// 可以将其用于参数化。VuGen 将此函数51Testing软件测试网Q3bq3O-b
// 生成为注释掉的调用。如果要将此值51Testing软件测试网(oZ0qR%z
// 用作参数，可以更改 name 并取消调用的
// 注释。
int lrc_save_currency(const char* name, CY val);51Testing软件测试网?3ov+@n"L4?

// lrc_save_currency_by_ref 函数将由“val”
6|$z-Ke4S#I5i(t?0// 指针引用的货币值保存到字符串参数中。
T$q&Q6UY#OHcq0int lrc_save_currency_by_ref(const char* name, CY *val);

4N0L;EIv`0u&J0// 输入表示 date 类型值的字符串时，
"w0X2hOqd%w#J&c0// lrc_date 函数返回 DATE 类型值。
N+? Pjm}i0DATE lrc_date(const char* str);

dv\ Xd0@N0// 输入表示 date 类型值的字符串时，lrc_date_by_ref 函数
?d7P0~WF'om0// 返回指向 DATE 的指针。
)O O*i*UHOmn D0DATE* lrc_date_by_ref(const char* str);

// lrc_save_date 函数将 date 类型值保存
$fk"Q#JY5e0Q8C0// 为字符串。VuGen 将此函数生成为注释掉的调用。51Testing软件测试网N3];I&D&Ke8e
// 如果要将此值用作参数，可以更改 name 并取消
// 调用的注释。
int lrc_save_date(const char* name, DATE val);51Testing软件测试网S F^9n$D5x

// lrc_save_date_by_ref 函数将 date 类型值保存为字符串。
int lrc_save_date_by_ref(const char* name, DATE *val);

// 输入包含“true”或“false”的字符串时，
// lrc_bool 函数返回 Boolean 类型值。
$gS%T un;gc0VARIANT_BOOL lrc_bool(const char* str);51Testing软件测试网}:rt dg.x`

vq`q*UnA0// 输入包含“true”或“false”的字符串时，
)~YNb)[LV(d+~.O0// lrc_bool_by_ref 函数返回指向 Boolean
// 类型值的指针。
VARIANT_BOOL* lrc_bool_by_ref(const char* str);

e'SD%?yE+iUk5D0// lrc_save_bool 函数将 Boolean 类型值
// 保存为字符串参数。VuGen 将此函数生成为51Testing软件测试网 Wov;ue
// 注释掉的调用。如果要将此值用作参数，可以
s7xL'K,eD0// 更改 name 并取消调用的注释。
int lrc_save_bool(const char* name, VARIANT_BOOL val);

$a[N?r J(nZ0// lrc_save_bool_by_ref 函数将 Boolean 类型值
$i_\5h/`+a8X'Wk m0// 保存到字符串参数中。51Testing软件测试网t@A4Qz,W
int lrc_save_bool_by_ref(const char* name, VARIANT_BOOL *val);51Testing软件测试网/J|NBF~N8Q

;|%EcTU"^P'J0// 输入表示无符号短整型值的字符串时，51Testing软件测试网B,MW{0c
// lrc_ushort 函数返回无符号
/pI{$n'sR5uy/G"]4i0// 短整型值。51Testing软件测试网6ghS.c}5^
unsigned short lrc_ushort(const char* str);

// 输入表示无符号短整型值的字符串时，51Testing软件测试网HU-lCY]*k[
// lrc_ushort_by_ref 函数返回指向无符号短整型值
3i+Zqd)l5x6V-i|/p0// 的指针。51Testing软件测试网#w.m"Z$y9\w'g
unsigned short* lrc_ushort_by_ref(const char* str);

// lrc_save_ushort 函数将无符号
// 短整型值保存在参数中。
0]o`S!O0int lrc_save_ushort(const char* name, unsigned short val);

tA,jI"Nyx!o0// lrc_save_ushort_by_ref 函数将无符号短整型值
I}I&b,k)a0// 保存到参数中。
int lrc_save_ushort_by_ref(const char* name, unsigned short *val);51Testing软件测试网.~1\.R)w_'z

// 输入包含浮点数的字符串时，
// lrc_float 函数返回浮点数。
5n D@%JbmM}0vo0float lrc_float(const char* str);

// 输入包含浮点数的字符串时，
/`fs8nd!z:J0// lrc_float_by_ref 函数返回指向浮点数51Testing软件测试网ZW]v$S
// 的指针。
7j.i0J-\:c8d&y8f'y0float* lrc_float_by_ref(const char* str);

r D8Xd!Sr7|'[.t${W0// lrc_save_float 函数将浮点类型
6E v/hMj$Z#yJZ0// 浮点值保存在字符串参数中。VuGen 将此
Yre%i{x#d Y!k0// 函数生成为注释掉的调用。如果要使用
vq*cC1n"T S]t2J/G0// 该参数，可以更改 name 并取消调用的
g:n6n Jk'Dj4FLh0// 注释。
!I v{[7bJ7}]9\0int lrc_save_float(const char* name, float val);

// lrc_save_float_by_ref 函数将浮点
i g9KCKF0// 类型浮点值保存在字符串参数中。
int lrc_save_float_by_ref(const char* name, float *val);

0w'IR0D2?!F0// 输入包含 double 类型值的字符串时，
/Ty+u4K,]-]!H;u0// lrc_double 函数返回 double 类型值。
double lrc_double(const char* str);51Testing软件测试网$SX8[ p]f7H

n$i0M5Y|0// 输入包含 double 类型值的字符串时，lrc_double_by_ref
6H/Mn"}2WX4E$\s~5i0// 函数返回指向 double 类型值的指针。
Ne)@I.M'z PG0double* lrc_double_by_ref(const char* str);

2|u-X(D.\)g;M%~0// lrc_save_double 函数将双精度浮点
?iLoD U9B0// 类型值保存在字符串参数中。VuGen 将51Testing软件测试网ys5h%Z7z
// 此函数生成为注释掉的调用。如果要将51Testing软件测试网5kv8ov+aDt
// 此值用作参数，可以更改 name 并取消
!lQ:U/[-k3}5C0// 调用的注释。
.Pb4x|2wM0int lrc_save_double(const char* name, double val);51Testing软件测试网#{'txR!r

e+\tg(D2~#n1Tqz0// lrc_save_double_by_ref 函数将双精度浮点
,b vmR9?/cZBU't0// 类型值保存在字符串参数中。
P6` Nk@#A(B'\0int lrc_save_double_by_ref(const char* name, double *val);

// 输入包含 dword 类型值的字符串时，lrc_dword 函数51Testing软件测试网mF`2__g-yM
// 返回双字类型值。
V T SNs9s'G[0DWORD lrc_dword(const char* str);51Testing软件测试网'xn1mUj

// lrc_save_dword 函数将双字类型值
:T%N.\y$`x8fa5i!D0// 保存在字符串参数中。VuGen 将此函数
0a_ `cJ*@M^z4P0// 生成为注释掉的调用。如果要将此值用作
~]"iiTv0// 参数，可以更改 name 并取消调用的注释。
int lrc_save_dword(const char* name, DWORD val);

-T.}ZaFl+CF0// lrc_BSTR 函数将任何字符串转换为 BSTR。
w6kh[4Km0BSTR lrc_BSTR(const char* str);

// lrc_save_BSTR 函数将 BSTR 值保存
// 为字符串参数。VuGen 将此函数生成为
wS{syjprZ*MX{0// 注释掉的调用。如果要将此值用作参数，
.E}w9gu:d{b0// 可以更改 name 并取消调用的注释。
int lrc_save_BSTR(const char* name, BSTR val);51Testing软件测试网x&o8ZYvlmS

// lrc_ascii_BSTR 函数将字符串51Testing软件测试网c B4pZcx D
// 转换为 ascii_BSTR。
(N@$f#S:B7d#v0BSTR lrc_ascii_BSTR(const char* str);

// lrc_ascii_BSTR_by_ref 函数将字符串转换
// 为 ascii_BSTR，并返回指向该 BSTR 的指针。
a9fxg!e0BSTR* lrc_ascii_BSTR_by_ref(const char* str);

Z"@\z{0// 当不再使用 COM 对象时，51Testing软件测试网L'R!_/wbm7u(B
// lrc_Release_Object 函数释放该对象。
// 释放对象后，对象的引用计数将减 1
,Jg)cvV["B9S0// （例如，IUnknown_1 到 IUnknown_0）。
//
Z'P5mJ)PB[^0int lrc_Release_Object(const char* interface);51Testing软件测试网,YV],}W6[$yI

hjM3\@zt[(c0// lrc_save_ascii_BSTR 函数将 ascii BSTR 保存51Testing软件测试网v0h8s-w#a
// 到字符串参数中。VuGen 将此函数生成为注释掉的调用。
f%BPx8W0// 如果要将此值用作参数，可以更改 name 并取消调用的
EM"_2A&ET0// 注释。
vU$k9n;du0JG7{6_0int lrc_save_ascii_BSTR(const char* name, BSTR val);51Testing软件测试网(NYKc&q"^B L

// lrc_save_ascii_BSTR_by_ref 函数将 ascii BSTR 保
!p~3L|1Di7Cr2r0// 存到字符串参数中。
H|Ca M X5Q^0int lrc_save_ascii_BSTR_by_ref(const char* name, BSTR *val);

)gg s&^^7H$A)Zt0// lrc_save_VARIANT 函数将任何数据类型的值51Testing软件测试网BFJu`2CE
// 保存到字符串参数中。
t3OU-rq'I$z uP0int lrc_save_VARIANT(const char* name, VARIANT val);51Testing软件测试网Q7E&[$DR

[.b9d'I*{a!h+d7r0// lrc_save_variant_<Type-Name> 函数系列51Testing软件测试网2uD\(E&i0N
// 由 VuGen 生成，用于将指定的 <Type-Name>
-g[BW8L1g:EX-Y0// 变量保存为字符串参数。VuGen 将这些代码行
4Tb?)@8Q1q0// 生成为注释掉的调用。如果要将此值用作参数，
4P;X?k)YS0// 可以更改 name 并取消调用的
// 注释。
_c8C6C~0int lrc_save_variant_<Type-Name>(const char* name, VARIANT val);51Testing软件测试网$V]s]c(fy

// lrc_save_variant_short 将 short 变量类型值保存到字符串参数中。
int lrc_save_variant_short(const char* name, VARIANT val);

// lrc_save_variant_ushort 将 short 变量类型值保存到字符串参数中。51Testing软件测试网 H3B8h3X pw+rB
int lrc_save_variant_ushort(const char* name, VARIANT val);

// lrc_save_variant_char 将 short 变量类型值保存到字符串参数中。
(w'rNZ$^}f5h0int lrc_save_variant_char(const char* name, VARIANT val);

// lrc_save_variant_int 将 int 变量类型值保存到字符串参数中。
yo*f}'Qnh H0Z0int lrc_save_variant_int(const char* name, VARIANT val);51Testing软件测试网:T!]/b\;TjP&E

_1c*F'E+Tw0// lrc_save_variant_uint 将无符号 integer 变量51Testing软件测试网E U"s9|f'd$~b
// 类型值到字符串参数中。51Testing软件测试网4x3[:YK0uA2x
int lrc_save_variant_uint(const char* name, VARIANT val);

// lrc_save_variant_ulong 将无符号 long 变量
8i6Af"hJj z7UEx.K0// 类型值保存到字符串参数中。51Testing软件测试网~~e\)d:`u
int lrc_save_variant_ulong(const char* name, VARIANT val);

7i_1r;nj@!D8@0// lrc_save_variant_BYTE 将 BYTE 变量类型值保存到字符串参数中。
ly`4KjK0int lrc_save_variant_BYTE(const char* name, VARIANT val);

#Q|~ bAl3cPd5J0// lrc_save_variant_long 将 long 变量类型值保存到字符串参数中。51Testing软件测试网sMrsRD1v
int lrc_save_variant_long(const char* name, VARIANT val);51Testing软件测试网/`(o%z]yhr

`bL&t%H:X7J d0// lrc_save_variant_float 将 float 变量类型值保存到字符串参数中。
*vf4K6\?@6d0int lrc_save_variant_float(const char* name, VARIANT val);

:q o,_R"wG_,C0// lrc_save_variant_double 将 double 变量
// 类型值保存到字符串参数中。
D{y[;y*F/?0int lrc_save_variant_double(const char* name, VARIANT val);51Testing软件测试网8M\BF8N4wb

.Bbi |-NqM^_Vq`0// lrc_save_variant_bool 将 boolean 变量类型值保存到字符串参数中。
?4_)Uw i5W0int lrc_save_variant_bool(const char* name, VARIANT val);51Testing软件测试网N8?8~Vn#HI

G_2GKL](p0// lrc_save_variant_scode 将 scode 变量类型值保存到字符串参数中。
int lrc_save_variant_scode(const char* name, VARIANT val);

// lrc_save_variant_currency 将 currency 变量
// 类型值保存到字符串参数中。
D"e8OElh:@0int lrc_save_variant_currency(const char* name, VARIANT val);

// lrc_save_variant_date 将 DATE 变量类型值保存到字符串参数中。51Testing软件测试网m/wm(my0o5i
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 函数
?I(M~[4n;y0// 系列由 VuGen 生成，以便将通过变量中的引用方式
\%T6O!eI:e_-B0// 存储的、指定了 <Type-Name> 的变量保存为字符串51Testing软件测试网"^iK.l)v7P
// 参数。VuGen 将这些代码行生成为注释掉的调用。
"S:[&J3L9R5Ff7|0// 如果要将此值用作参数，可以更改 name 并取消调用的
// 注释。
//51Testing软件测试网.m/b!q;]8[$yX
int lrc_save_variant_<Type-Name>_by_ref(const char* name, VARIANT val);

// lrc_save_variant_short_by_ref 将通过变量中
:P1d'Y8G9L/{f H j d0// 的引用方式存储的值保存为参数。
6u0S%O(H\.Ri0int lrc_save_variant_short_by_ref(const char* name, VARIANT val);

// lrc_save_variant_ushort_by_ref 将51Testing软件测试网&Pb8ag1n5J\l
// 通过变量中的引用方式存储的值保存为参数。51Testing软件测试网Xl"a~7]A:k
int lrc_save_variant_ushort_by_ref(const char* name, VARIANT val);

y6R/Jkx4qG p0// lrc_save_variant_char_by_ref 将通过
// 变量中的引用方式存储的值保存为参数。
%pvR C}6a0int lrc_save_variant_char_by_ref(const char* name, VARIANT val);51Testing软件测试网"Mq4plBp

3| D'Knz7Rk0// lrc_save_variant_int_by_ref 将通过
^0hSA~b J0// 变量中的引用方式存储的值保存为参数。
^!n&ml&DEw5m0int lrc_save_variant_int_by_ref(const char* name, VARIANT val);

!yn sgY/l I,Z9P"uad0// lrc_save_variant_uint_by_ref 将通过
[~a6xQ$b*}0// 变量中的引用方式存储的值保存为参数。
int lrc_save_variant_uint_by_ref(const char* name, VARIANT val);

X.^n!Qb3}x J5`0// lrc_save_variant_ulong_by_ref 将通过51Testing软件测试网p f@)O%E]
// 变量中的引用方式存储的值保存为参数。
JYyj_:A*o#v0int lrc_save_variant_ulong_by_ref(const char* name, VARIANT val);

// lrc_save_variant_BYTE_by_ref 将通过
// 变量中的引用方式存储的值保存为参数。51Testing软件测试网[B3BRxF%c
int lrc_save_variant_BYTE_by_ref(const char* name, VARIANT val);

r9n'Jhvn0// lrc_save_variant_long_by_ref 将
T}F!S*y8bE0// 变量中的引用方式存储的值保存为参数。
int lrc_save_variant_long_by_ref(const char* name, VARIANT val);

// lrc_save_variant_float_by_ref 将通过
// 变量中的引用方式存储的值保存为参数。
y~ {)E{0int lrc_save_variant_float_by_ref(const char* name, VARIANT val);

// lrc_save_variant_double_by_ref 将通过
// 变量中的引用方式存储的值保存为参数。
!v,`C x"o4~t0int lrc_save_variant_double_by_ref(const char* name, VARIANT val);

3K;b)HCmF3D'm0// lrc_save_variant_bool_by_ref 将通过
D\|q9baW cd _D0// 变量中的引用方式存储的值保存为参数。
1Ic2X/|P%bn6i!B'r0int lrc_save_variant_bool_by_ref(const char* name, VARIANT val);51Testing软件测试网gk vJ }d

%F1_[,_ f&G+B0// lrc_save_variant_scode_by_ref 将通过
8M)D-Y*Z6B?0// 变量中的引用方式存储的值保存为参数。
int lrc_save_variant_scode_by_ref(const char* name, VARIANT val);51Testing软件测试网:q9g(}2Sj?C\

$@Lm7tMH,L$~0// lrc_save_variant_currency_by_ref 将通过51Testing软件测试网 LL:L^9M~
// 变量中的引用方式存储的值保存为参数。51Testing软件测试网Kn6cRm
int lrc_save_variant_currency_by_ref(const char* name, VARIANT val);51Testing软件测试网vMx _k

// lrc_save_variant_date_by_ref 将通过
l5S z:C f&{q N^0// 变量中的引用方式存储的值保存为参数。
aqk*sH `5C0int lrc_save_variant_date_by_ref(const char* name, VARIANT val);51Testing软件测试网dlC$]2A!m(S

8I.^cUwWn0// lrc_save_variant_BSTR_by_ref 将通过
5W"H^o p g0// 变量中的引用方式存储的值保存为参数。
u ^+? C;q7Hx%Z0int lrc_save_variant_BSTR_by_ref(const char* name, VARIANT val);

F-rc7D'Myr#o0// lrc_BYTE 函数将字符串转换
(m Gc,]KgB#iu0// 为无符号字符（字节）数值。
o2XNq6k8G!iS0BYTE lrc_BYTE(const char* str);

w%Z _#B:F0// lrc_BYTE_by_ref 函数将字符串转换
g!rE]"iM)Yy0// 为无符号字符（字节）数值，并返回指向该字节51Testing软件测试网|"K|*o.aFI
// 的指针。
char * lrc_BYTE_by_ref(const char* str);51Testing软件测试网T_b{v3xs{

!Hic X+Gs/w0// lrc_save_BYTE 函数将 byte 类型值保存为参数。
Q1xPx5i0D-d o2d0// VuGen 将此函数生成为注释掉的调用。如果要将此值
// 用作参数，可以更改 param_name 并取消调用的
// 注释。
mug.u8O$jP-r0int lrc_save_BYTE(const char* param_name, BYTE val);

%|wzy+m+Z5[W0// lrc_save_BYTE_by_ref 函数将 byte51Testing软件测试网(tC@w'E3@
// 类型值保存为参数。VuGen 将此函数生成为
g9T1a` s8^:C'D#b0// 注释掉的调用。如果要将此值用作参数，可以51Testing软件测试网&{2i.w6D }3vM
// 更改 param_name 并取消调用的注释。
J9ZU bp YD#X0int lrc_save_BYTE_by_ref(const char* param_name, BYTE *val);

// 输入表示超级整型值的字符串时，lrc_hyper 函
H:AR3A1i(}p-H$g@0// 数返回超级（64 位）整型值。
@0hl:t%k.H0\v8u0hyper lrc_hyper(const char* str);51Testing软件测试网"p3n'bmt.o.Z

;tj5}5O.o(^8t4G0// 输入表示超级整型值的字符串时，51Testing软件测试网2nO$\?k s[
// lrc_hyper_by_ref 函数返回指向
// 超级（64 位）整型值的指针。51Testing软件测试网~/h)n9m Vky
hyper* lrc_hyper_by_ref(const char* str);

// lrc_save_hyper 函数将 64 位超级51Testing软件测试网m#L(s#|;CNxW
// 整型值保存在字符串参数中。VuGen 将
{ie/|9f0// 此函数生成为注释掉的调用。如果要将51Testing软件测试网%ED9d!aIH:^ t
// 此值用作参数，可以更改 name 并取消51Testing软件测试网m8W9_$G/P A2O$~
// 调用的注释。
int lrc_save_hyper(const char* name, hyper val);51Testing软件测试网z lc'lPW3x

P@c2i-mF:X?0// lrc_save_hyper_by_ref 函数将 64 位51Testing软件测试网&q)e)o;xV
// 超级整型值保存到字符串参数中。51Testing软件测试网"^"u!h~T1]n
int lrc_save_hyper_by_ref(const char* name, hyper *val);

AD&w$[ U0// 输入表示无符号超级整型值的字符串时，
// lrc_uhyper 函数返回无符号超级51Testing软件测试网 ]3nUN0f5Cq
// （64 位）整型值。
x/BD4DP3^,r0uhyper lrc_uhyper(const char* str);

// 输入表示无符号超级整型值的字符串时，
// lrc_uhyper_by_ref 函数返回指向51Testing软件测试网 Q1D(VXk3V"b
// 无符号超级（64 位）整型值。
3Y:l9LD,G*q1xm0uhyper* lrc_uhyper_by_ref(const char* str);51Testing软件测试网 Tz&b9j_~*|7{

N\D'@Z2jH$XX0// lrc_save_uhyper 函数将无符号 64 位51Testing软件测试网!o]yN$d-h
// 超级整型值保存在字符串参数中。VuGen 将51Testing软件测试网:?K&m&V:K&CI
// 此函数生成为注释掉的调用。如果要将此值51Testing软件测试网@ I R@K$b^
// 用作参数，可以更改 name 并取消调用的
!vm&u}6W Rq0// 注释。
Z9?Ff'}*v@0int lrc_save_uhyper(const char* name, uhyper val);

G+U3L8C$|O#y0// lrc_save_uhyper_by_ref 函数将无符号
// 64 位超级整型值保存到字符串参数中。VuGen
T(_;P(~KG(XJ;?0// 将此函数生成为注释掉的调用。如果要将此值
// 用作参数，可以更改 name 并取消调用的
$L ^H%rw#P1Vok0// 注释。
2i-[6CY7BB'@0j0int lrc_save_uhyper_by_ref(const char* name, uhyper *val);

// lrc_char 函数将包含 char 类型数值
JaG(fI3}O~0// 的字符串转换为 char 变量。
char lrc_char(const char* str);

// lrc_char_by_ref 函数将包含 char 类型数值的
opXh(?!FwfhG0// 字符串转换为 char 变量。
%\5F`w%R0char* lrc_char_by_ref(const char* str);

*~2N+Aq/h4Cf"r z.s0// lrc_save_char 函数将 char类型
8BTc&c~0// (0 - 127) 保存到字符串参数中。
// VuGen 将此函数生成为注释掉的调用。
$|+~u$p,ve5w;}K't0// 如果要将此值用作参数，可以更改 name
PZ7C:TR%l0// 并取消调用的注释。
P:VPB!e"E0int lrc_save_char(const char* name, char val);

\ tg%q_ JQ4`-\(R0// lrc_save_char_by_ref 函数将 char 类型
// (0 - 127) 保存到字符串参数中。VuGen 将
// 此函数生成为注释掉的调用。如果要将此值51Testing软件测试网6o9iRC6PV(X
// 用作参数，可以更改 name 并取消调用的
I Co5ze#k0// 注释。51Testing软件测试网O:_:x^(\~
int lrc_save_char_by_ref(const char* name, char *val);

// lrc_variant_empty 函数返回空变量。
7E8]D m%h-_}%L6k\:z ?3w0VARIANT lrc_variant_empty();

sq!Q?\0// lrc_variant_empty_by_variant 返回
9_;~9hg*mu W0// 包含对空变量引用的变量。51Testing软件测试网+m A+w)s(@2T5w
VARIANT lrc_variant_empty_by_variant();

(||/j[mV.?9g0// lrc_variant_null 函数返回 null 变量。
!_f \W-K9hS`K0VARIANT lrc_variant_null();

// lrc_variant_null_by_variant 返回51Testing软件测试网L;p(\1g&W^
// 包含对 null 变量引用的变量。
2Fr x"O@yJ0VARIANT lrc_variant_null_by_variant();

// lrc_variant_short 函数将字符串转换为
x0wCYa+jLW0// 短整型值，并在变量中将其返回。
%K5Ms&p7Gm0VARIANT lrc_variant_short(const char* str);

&^/wi` A/nku'zV0// lrc_variant_short_by_variant 函数将字符串
"]%M^IRs7gT0// 转换为短整型值，并返回包含对某变量（其中包含
YFP&r#z0// 该短整型值）引用的变量。
6O;jr[Ev%bj0VARIANT lrc_variant_short_by_variant(const char* str);

// lrc_variant_ushort 函数将字符串转换为51Testing软件测试网 i ` FVo!T#i
// 无符号短整型值，并在变量中将其返回。
5A!x han7?mh0VARIANT lrc_variant_ushort(const char* str);51Testing软件测试网siUH:B {\Z

,j1i;JP'it0// lrc_variant_char 函数将字符串转换为
*Q9`3V,G6Z0// char 类型值，并在变量中将其返回。
6\9G8Gwt:^n0VARIANT lrc_variant_char(const char* str);

// lrc_variant_int 函数将字符串转换为整型
'n3nU,T/Xn0// 值，并在变量中将其返回。
6|$|R)RFT?4`Y!W%U^0VARIANT lrc_variant_int(const char* str);

/O`wr*Y+g0K9Q3v F0// lrc_variant_uint 函数将字符串转换为
iO_0Bj d0L0// 无符号整型值，并将其存储在变量中返回。
tnsno j0VARIANT lrc_variant_uint(const char* str);

XsR9e:Koz2Up/n0// lrc_variant_ulong 函数将字符串转换为
w3JIt^nbR7o0// 无符号长整型值，并将其存储在变量中返回。
I4q iV9})n|~0VARIANT lrc_variant_ulong(const char* str);51Testing软件测试网'jcb-|u

// lrc_variant_BYTE 函数将字符串转换为
// 无符号 char (byte) 类型值并存储于变量中。
VARIANT lrc_variant_BYTE(const char* str);

// lrc_variant_BYTE_by_variant 函数将字符串51Testing软件测试网(B\5r&u,p`
// 转换为无符号 char (byte) 类型值，并返回包含51Testing软件测试网f"x.Y{0ga
// 对某变量（包含该 byte）引用的变量。51Testing软件测试网s c5N7w Mj U
VARIANT lrc_variant_BYTE_by_variant(const char* str);

?;y4c$N)f7[0// lrc_variant_long 函数将字符串
!T;I-YD!{ oZf0// 转换为存储于变量中的长整型值。51Testing软件测试网q$m"_Dl
VARIANT lrc_variant_long(const char* str);51Testing软件测试网-g\Uu LQzq

// lrc_variant_long_by_variant 函数将
m ?UCg f0// 字符串转换为存储于变量中的长整型值，并且
,V2a H2Lp%s3c0// 返回包含对某变量（其中包含该长整型值）
// 引用的变量。51Testing软件测试网C9n9EIKq
VARIANT lrc_variant_long_by_variant(const char* str);

// lrc_variant_float 函数将字符串转换为51Testing软件测试网B`jLf_
// 存储于变量中的浮点类型值。
O6N+|'{h0VARIANT lrc_variant_float(const char* str);

ubU ~g'hag#Y+pz&i!v0// lrc_variant_float_by_variant 函数将
NS PW!H0// 字符串转换为浮点类型值，并且返回包含对某
// 变量（其中包含该值）引用的变量。
VARIANT lrc_variant_float_by_variant(const char* str);51Testing软件测试网I.c*ug2ESF4G

0VL8sOCu~3k uN0// lrc_variant_double 函数将字符串转换为
aCj(ijI0// 存储于变量中的双精度型浮点值。
[P ^3FV5IH0VARIANT lrc_variant_double(const char* str);

%gH_4c8ma6E0// lrc_variant_double_by_variant 函数将
(Gb6puR"}WS/]|0Hz0// 字符串转换为双精度型值，并且返回包含对某变量
// （其中包含该值）引用的变量。
2ov7m%Z}nc0VARIANT lrc_variant_double_by_variant(const char* str);

// lrc_variant_bool 函数将包含“true”或“false”
1s PQ+o zA0// 的字符串转换为存储于变量中的 Boolean 类型值。
VARIANT lrc_variant_bool(const char* str);

2E5P#s%x5q%i{0// lrc_variant_bool_by_variant 函数将51Testing软件测试网"O"M"]0E#jZ!UE
// 包含“true”或“false”的字符串转换为
*r(o+taK2T)m0|-r0// Boolean 值，并且返回包含对某变量（其中51Testing软件测试网:X:V;FpV
// 包含该值）引用的变量。51Testing软件测试网dJCA*HnQj
VARIANT lrc_variant_bool_by_variant(const char* str);

// lrc_variant_scode 函数将包含系统错误代码值的。
// 字符串转换为存储于变量中的错误代码51Testing软件测试网8zPJ"xh:gh
VARIANT lrc_variant_scode(const char* errcode);

// lrc_variant_scode_by_variant 函数将51Testing软件测试网T#s}C _'~T
// 包含系统错误代码值的字符串转换为错误代码，51Testing软件测试网:wqw:na"Gf l
// 并且返回包含对某变量（其中包含该值）引用51Testing软件测试网"AC*i+Hs0ON7L
// 的变量。
VARIANT lrc_variant_scode_by_variant(const char* errcode);

d8G9j V}0// lrc_variant_currency 函数将包含货币值
// 的字符串转换为存储于变量中的货币值。
J/jF-[P3~'`.fFh0VARIANT lrc_variant_currency(const char* str);51Testing软件测试网'?u-ZhY)Lv

'Y3_&a&im|D0// lrc_variant_currency_by_variant 函数
// 将包含货币值的字符串转换为货币值，并且
// 返回包含对某变量（其中包含该值）引用的51Testing软件测试网pd&Xt4M g4?
// 变量。51Testing软件测试网)IY"_#M-K*u
VARIANT lrc_variant_currency_by_variant(const char* str);51Testing软件测试网` A-R~G%?QM

// lrc_variant_date 函数将包含 date 类型值的
]ll)F-V0// 字符串转换为存储于变量中的 date 类型值。
dXh-Y1yN0VARIANT lrc_variant_date(const char* str);51Testing软件测试网^[?%S&\;Y

"jY:@1Y;r0// lrc_variant_date_by_variant 函数将
/\^8w:\rv0// 包含 date 类型值的字符串转换为 date 类型值，
Fg9~0s$d5T{0// 并且返回包含对某变量（其中包含该 date 类型值）51Testing软件测试网Iw.h{8D6P
// 引用的变量。51Testing软件测试网%QEEc0@me-z
VARIANT lrc_variant_date_by_variant(const char* str);

%A&r4vG(uc;G0// lrc_variant_BSTR 函数将字符串转换为
tR A5aV%?;f{9A+Hx0// 存储于变量中的 BSTR 类型值。51Testing软件测试网`uxITB5e
VARIANT lrc_variant_BSTR(const char* str);

!|;SH1wIf;Ib|]0// lrc_variant_BSTR_by_variant 函数将字符串
z]A3I}0// 转换为 BSTR 值，并且返回包含对某变量（其中51Testing软件测试网 F OCT(j3P2\
// 包含该值）引用的变量。
zef(P.q#]0VARIANT lrc_variant_BSTR_by_variant(const char* str);51Testing软件测试网Y$DSY!N0eju

9~^w8]6Hrgh*e0// lrc_variant_ascii_BSTR 函数将字符串分配给
)s%ROc-G&rX'B0// 存储于变量中的 ASCII BSTR 值
VARIANT lrc_variant_ascii_BSTR(const char* str);

// lrc_variant_CoObject 函数将 IUnknown 接口51Testing软件测试网y"kPua:@
// 指针分配给变量。51Testing软件测试网|5]IEg
VARIANT lrc_variant_CoObject(IUnknown* pUnknown);

P f \CY(}3z0// lrc_variant_CoObject_by_variant 函数将
*ym6rb9{$f0// IUnknown 接口指针分配给变量，并且返回
S-U%zO Tw}&A0// 包含对某变量（其中包含 IUnknown 引用）
MqC;@0a*]x0// 引用的变量。
Fl0u9~P0_!WY:ovw0VARIANT lrc_variant_CoObject_by_variant(IUnknown* pUnknown);

(k'])ISY3J%x };jI0// lrc_variant_DispObject 函数将
A1]Y.?!TW7h0|6G0// IDispatch 接口指针分配给变量。51Testing软件测试网Y(H[U:@Y
VARIANT lrc_variant_DispObject(IDispatch* pDispatch);

8} p{#d&j"d9Y0// lrc_variant_DispObject_by_variant 函数
// 将 IDispatch 接口指针分配给变量，并且返回包含51Testing软件测试网 H#Hv Bo |
// 对某变量（其中包含 IDispatch 引用）引用的
// 变量。
VARIANT lrc_variant_DispObject_by_variant(IDispatch* pDispatch);

:yU g0x$|0// lrc_variant_short_by_ref 函数将字符串
#LU)ay.xW'l2m0// 分配给通过变量中的引用方式存储的短整型值。
0DK1^!t'kU5Q L0VARIANT lrc_variant_short_by_ref(const char* str);

// lrc_variant_ushort_by_ref 函数将字符串
"d2I,H*?q`GA#x0// 分配给通过变量中的引用方式存储的无符号短整型值。51Testing软件测试网!EG]N:vE1]
VARIANT lrc_variant_ushort_by_ref(const char* str);

// lrc_variant_char_by_ref 函数将字符串分配51Testing软件测试网'yb:bE{%f
// 给通过变量中的引用方式存储的 char 类型值。
1v0B#Z\B(@#m}G0VARIANT lrc_variant_char_by_ref(const char* str);51Testing软件测试网 C*O?n5p&|T

f$g-s;YRd0// lrc_variant_int_by_ref 函数将字符串分配给51Testing软件测试网 QO:_SBnF
// 通过变量中的引用方式存储的 integer 类型值。
~b$v4[!}$P0VARIANT lrc_variant_int_by_ref(const char* str);

// lrc_variant_uint_by_ref 函数将字符串分配给
M dB)j#g!hr"R0// 通过变量中的引用方式存储的无符号 integer 类型值。
L@/Af%K0VARIANT lrc_variant_uint_by_ref(const char* str);51Testing软件测试网%g"im-q(]^

6S8N6Q1q5]"nb0// lrc_variant_ulong_by_ref 函数将字符串分配给
fhQI\hZ"g0// 通过变量中的引用方式存储的长整型值。
8{N5Pp@ n%tKW0VARIANT lrc_variant_ulong_by_ref(const char* str);

9XW\-w9a J/|6_+f$U0// lrc_variant_BYTE_by_ref 函数将字符串分配给51Testing软件测试网1F,aR~c1y
// 通过变量中的引用方式存储的 char (byte) 类型值。51Testing软件测试网.a,~1g"b;ez/H.y
VARIANT lrc_variant_BYTE_by_ref(const char* str);51Testing软件测试网 G6DJ&W*k

/z(T+US\3Uqq+D0// lrc_variant_long_by_ref 函数将字符串分配给
_[!EeI-O0// 通过变量中的引用方式存储的长整型值。51Testing软件测试网;qA8i!o q
VARIANT lrc_variant_long_by_ref(const char* str);

// lrc_variant_float_by_ref 函数将字符串分配给
Fj+u-k4J$I^!} N.U0// 通过变量中的引用方式存储的浮点型浮点值。
VARIANT lrc_variant_float_by_ref(const char* str);51Testing软件测试网HO-S)K5fl

5E3z4zF"E/@_4\kv3h.h|0// lrc_variant_double_by_ref 函数将字符串分配给
// 通过变量中的引用方式存储的双精度型值。51Testing软件测试网cN8p5Y*B&aw!c
VARIANT lrc_variant_double_by_ref(const char* str);

*W+}8e4g9OEz0// lrc_variant_bool_by_ref 函数将包含“true”
0q$H8ri^'f)n^0// 或“false”的字符串分配给通过变量中的
.Z@hx$f0// 引用方式存储的 Boolean 类型值。51Testing软件测试网2U,Q&JcD}
VARIANT lrc_variant_bool_by_ref(const char* str);51Testing软件测试网`'v'Pp1pN1E

// lrc_variant_scode_by_ref 函数将包含
5u;S)m%M0{:o(L zfd0D0// 系统错误代码值的字符串分配给通过变量中的
zHfQ;y's&F0// 引用方式存储的错误代码中。
*Rb)FWF"JP0VARIANT lrc_variant_scode_by_ref(const char* str);

// lrc_variant_currency_by_ref 函数将字符串51Testing软件测试网1UStP7JSv
// 分配给通过变量中的引用方式存储的货币类型值。51Testing软件测试网C;wr(U4l
VARIANT lrc_variant_currency_by_ref(const char* str);

// lrc_variant_date_by_ref 函数将字符串
|8G @9OMqi0// 分配给通过变量中的引用方式存储的 date 类型值。
VARIANT lrc_variant_date_by_ref(const char* str);51Testing软件测试网(u'YM?Yb"G.F

B8g*tT#VUK0// lrc_variant_BSTR_by_ref 函数将字符串分配给的
3y5te,dP0// 通过变量中引用方式存储的 BSTR 值。
VARIANT lrc_variant_BSTR_by_ref(const char* str);

&T!yut8T0// lrc_variant_ascii_BSTR_by_ref 函数将字符串
z2V%KG }a-|R0// 分配给通过变量中的引用方式存储的 ascii BSTR 值。
?@ M:X?0VARIANT lrc_variant_ascii_BSTR_by_ref(const char* str);

// lrc_variant_CoObject_by_ref 函数将指针
NxC7z1]\#V:J0// 分配给变量中的 IUnknown 接口。
VARIANT lrc_variant_CoObject_by_ref(IUnknown* pUnknown);

~[9F:xm7~h [0// lrc_variant_DispObject_by_ref 函数将指针51Testing软件测试网%D!{SY e(ZZH
// 转换为变量中的 IDispatch 接口。
6b}+xL9Vo8[#|#e_0VARIANT lrc_variant_DispObject_by_ref(IDispatch* pDispatch);

// lrc_variant_variant_by_ref 函数创建包含现有
f(OVf!L'F0// 变量的新变量。
-R9Li~5nO:S!O0VARIANT lrc_variant_variant_by_ref(VARIANT * pVar);51Testing软件测试网h3];KxOd

@i jw0y*tE0// lrc_variant_from_variant_by_ref 函数从51Testing软件测试网Q8ROk$[I+~
// 另一个变量引用中获取变量。
#|#ixie&~3Y0VARIANT lrc_variant_from_variant_by_ref(VARIANT var);

Bb| R+Iyu.c0// Create<n>D<Type-Name>Array 函数系列
]K3Gj-R*t0// 创建由 Type-name 指定的类型的 n 维数组。
// 对于每一维，该调用必须指定 lower_bound
// 和 upper_bound。
&D K7p sJ|1z0<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 函数系列销毁
-yzsW"M$i0// 由 Type-name 指定的类型的数组。对于在
YH%n&R6h0// 脚本中（而非由 VuGen）创建的数组，可以使用51Testing软件测试网$nB)f]?FC
// 它们恢复内存。51Testing软件测试网7h]%m h|
void Destroy<Type-Name>Array(<Type-Name>Array Array);

F)CQN(M0// DestroyBoolArray 释放由数组占用的内存。51Testing软件测试网?#nA-|w]nm
// 该函数用于恢复由脚本为数组分配的内存。
-H cxR^N`EL P0void DestroyBoolArray(BoolArray Array);

y0J1W'u1OAo0// DestroyBstrArray 释放由数组占用的内存。
iV#M)X a'o*_D7n0// 该函数用于恢复由脚本为数组分配的内存。51Testing软件测试网`M~$]+Y5sT
void DestroyBstrArray(BstrArray Array);

!C,c3z-IP&Y9@0// DestroyByteArray 释放由数组占用的内存。51Testing软件测试网CH/tn$l+Vf
// 该函数用于恢复由脚本为数组分配的内存。51Testing软件测试网3M8[f1dr!s1tS
void DestroyByteArray(ByteArray Array);

OaJWP0Q_E2z0// DestroyCharArray 释放由数组占用的内存。51Testing软件测试网oq+G.e} I
// 该函数用于恢复由脚本为数组分配的内存。
void DestroyCharArray(CharArray Array);

// DestroyCoObjectArray 释放由数组占用的内存。51Testing软件测试网l"[4`_6@V"i
// 该函数用于恢复由脚本为数组分配的内存。
f0@ue8l}0void DestroyCoObjectArray(CoObjectArray Array);51Testing软件测试网T1f+^.z0T

3X*n_IO)t"A/x0// DestroyCurrencyArray 释放由数组占用的内存。于
cKrIzeI)e4R0// 该函数用恢复由脚本为数组分配的内存。
.I;v"QyX@0void DestroyCurrencyArray(CurrencyArray Array);

\)B4~*DOs-gA8C } ~0// DestroyDateArray 释放由数组占用的内存。
4bZTO+H1[q1pd0// 该函数用于恢复由脚本为数组分配的内存。
&T/r"rJA/f(CQ0void DestroyDateArray(CurrencyArray Array);51Testing软件测试网:[x_(Y.?:w } n

// DestroyDispObjectArray 释放由数组占用的内存。
J(~if'\F6e0// 该函数用于恢复由脚本为数组分配的内存。
+y6t6tju\Q0void DestroyDispObjectArray(DispObjectArray Array);

gL'P;koA0W*MY0// DestroyDoubleArray 释放由数组占用的内存。
'Vc`7V.R;G,IM0// 该函数用于恢复由脚本为数组分配的内存。
void DestroyDoubleArray(DoubleArray Array);

// DestroyErrorArray 释放由数组占用的内存。51Testing软件测试网$C)Lc*u%|#r/@*{
// 该函数用于恢复由脚本为数组分配的内存。
#j&ZD Gs`z's7p0void DestroyErrorArray(ErrorArray Array);

// DestroyFloatArray 释放由数组占用的内存。
// 该函数用于恢复由脚本为数组分配的内存。51Testing软件测试网w'\*k'T3K$C
void DestroyFloatArray(FloatArray Array);

J Qf5Vd [0// DestroyIntArray 释放由数组占用的内存。
db`4uD"Q ]0// 该函数用于恢复由脚本为数组分配的内存。
void DestroyIntArray(IntArray Array);

// DestroyLongArray 释放由数组占用的内存。
D*Vry&b0// 该函数用于恢复由脚本为数组分配的内存。
C H"@J+^/yn0void DestroyLongArray(LongArray Array);

o!sUs0r8j0// DestroyShortArray 释放由数组占用的内存。
vedE5GlNa\0// 该函数用于恢复由脚本为数组分配的内存。
jcF8G&BH&[d!{q0void DestroyShortArray(ShortArray Array);

1Wd yh!^!F[5]0// DestroyUIntArray 释放由数组占用的内存。51Testing软件测试网B'm1^X%L
// 该函数用于恢复由脚本为数组分配的内存。
void DestroyUIntArray(UIntArray Array);

x$LM MS5OMt1R0// DestroyULongArray 释放由数组占用的内存。
// 该函数用于恢复由脚本为数组分配的内存。
void DestroyULongArray(ULongArray Array);

vrI#s]n9V%i$I4W0// DestroyUShortArray 释放由数组占用的内存。
// 该函数用于恢复由脚本为数组分配的内存。
5S n+|Vx8H/{,E0void DestroyUShortArray(UShortArray Array);

// DestroyVariantArray 释放由数组占用的内存。51Testing软件测试网-^m$q7Y2?u
// 该函数用于恢复由脚本为数组分配的内存。51Testing软件测试网U Es*B@$X3^
void DestroyVariantArray(VariantArray Array);

// GetBufferFrom<n>DByteArray 函数系列从 n 维51Testing软件测试网f q!F9E5c)o$]
// byte 类型数组的最后一维中提取缓冲区。此函数
2DI])En q |us0// 的返回值是一个指向 byte 类型的缓冲区的指针。51Testing软件测试网c? w}rx6o7d
// 缓冲区的大小返回到 *plinesize 所指定的51Testing软件测试网A#s4PL"Ih'^
// 地址中。51Testing软件测试网h1pvcJ5Q8F
char * GetBufferFrom<n>DByteArray(ByteArray Array, int ind1...indn-1, size_t *pLineSize);

// Fill<n>DByteArray 函数系列将 n 维 byte 数组
? W1a m oj+mq1E0// 的最后一维中填充缓冲区的内容。51Testing软件测试网 s3i;c2xN#l }:a
char * Fill<n>DByteArray(ByteArray Array, int ind1...indn-1, const char* buffer, size_t buff_size);51Testing软件测试网1VH`xMz

uSAL0FHS5dy0// lrc_variant_<Type-Name>Array 函数系列将在
-U%?E7gGo5aCz*i0// Type-Name 中指定的类型的数组分配给变量。51Testing软件测试网1Jhd C,\Y
VARIANT lrc_variant_<Type-Name>Array(<Type-Name>Array array);51Testing软件测试网-Sb:Q/S&c2Y6m

// lrc_variant_BoolArray 将数组分配给变量。51Testing软件测试网2@Hwr2v#Qs\
VARIANT lrc_variant_BoolArray(BoolArray array);

// lrc_variant_BstrArray 将数组分配给变量。51Testing软件测试网 lT[,m-Wi
VARIANT lrc_variant_BstrArray(BstrArray array);

// lrc_variant_ByteArray 将数组分配给变量。51Testing软件测试网v MI%d!SqW
VARIANT lrc_variant_ByteArray(ByteArray array);51Testing软件测试网H&^%BIk

// lrc_variant_CharArray 将数组分配给变量。51Testing软件测试网^:qppiT5Iq
VARIANT lrc_variant_CharArray(CharArray array);

B1TU;Y+RH v&\5r0// lrc_variant_CoObjectArray 将数组分配给变量。
{[%sr^2FuX1@0VARIANT lrc_variant_CoObjectArray(CoObjectArray array);

)hR8@Aqn4DWCG;@0// lrc_variant_CurrencyArray 将数组分配给变量。51Testing软件测试网|8B[eg3@
VARIANT lrc_variant_CurrencyArray(CurrencyArray array);

// lrc_variant_DateArray 将数组分配给变量。
0y%y E0]yL1@0VARIANT lrc_variant_DateArray(DateArray array);51Testing软件测试网8P9w aZh@'P

// 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);51Testing软件测试网o+GZ m\M%|

// lrc_variant_FloatArray 将数组分配给变量。51Testing软件测试网g-R1x,GAa4f
VARIANT lrc_variant_FloatArray(FloatArray array);51Testing软件测试网:rM$C"{4oT5_~

uwaSL@&_0// lrc_variant_IntArray 将数组分配给变量。
r'k$Ons0VARIANT lrc_variant_IntArray(IntArray array);

// lrc_variant_LongArray 将数组分配给变量。51Testing软件测试网}Ub wd|c:E
VARIANT lrc_variant_LongArray(LongArray array);

@)Ri3Cvl2c0// lrc_variant_ShortArray 将数组分配给变量。
_P+W2h,j^*KS-p0VARIANT lrc_variant_ShortArray(ShortArray array);

8Y{|6s\Z0// lrc_variant_UintArray 将数组分配给变量。51Testing软件测试网)H/s"rnr#aD
VARIANT lrc_variant_UintArray(UintArray array);

// lrc_variant_UlongArray 将数组分配给变量。
VARIANT lrc_variant_UlongArray(UlongArray array);51Testing软件测试网0ST*h)J"H-eB

// lrc_variant_UshortArray 将数组分配给变量。
9Y_[d.m3i$fBT0VARIANT lrc_variant_UshortArray(UshortArray array);

)zcp%|Z?0// lrc_variant_VariantArray 将数组分配给变量。51Testing软件测试网j'BO7CR!c`[
VARIANT lrc_variant_VariantArray(VariantArray array);

// lrc_variant_<Type-Name>Array_by_ref 函数系列51Testing软件测试网-XOEqB1Q]!o
// 返回对由 Type-name 指定的类型的数组的引用。返回类型
A#Rf7zC)M0// 为变量。
)ZW.UR{G:k'K&{0lH0VARIANT lrc_variant_<Type-Name>Array_by_ref( <Type-Name>Array array );

;po^~"Ooz0// lrc_variant_BoolArray_by_ref 返回对数组的引用
7VB+f a*CNw R+r0VARIANT lrc_variant_BoolArray_by_ref(BoolArray array);

// lrc_variant_BstrArray_by_ref 返回对数组的引用
!bdxy2\!T0VARIANT lrc_variant_BstrArray_by_ref(BstrArray array);51Testing软件测试网N5qizU/l x

)_1f%m+N-F_C,xKxU0// lrc_variant_ByteArray_by_ref 返回对数组的引用
OV{W PY0O7m ?h0VARIANT lrc_variant_ByteArray_by_ref(ByteArray array);51Testing软件测试网]/l6_4Z^S7u

// lrc_variant_CharArray_by_ref 返回对数组的引用
K }'g},Kna,iG3wV0VARIANT lrc_variant_CharArray_by_ref(CharArray array);

#{rV} iXR0// lrc_variant_CoObjectArray_by_ref 返回对数组的引用
0sG E k,eq0VARIANT lrc_variant_CoObjectArray_by_ref(CoObjectArray array);51Testing软件测试网^l5`.Wb Y,a6b

// lrc_variant_CurrencyArray_by_ref 返回对数组的引用
VARIANT lrc_variant_CurrencyArray_by_ref(CurrencyArray array);

// lrc_variant_DateArray_by_ref 返回对数组的引用
hP0r"\O9sn3l|N0VARIANT lrc_variant_DateArray_by_ref(DateArray array);51Testing软件测试网D5Q6jFm9g"X

// lrc_variant_DispObjectArray_by_ref 返回对数组的引用
Db:`JL`"[S'V'y H0VARIANT lrc_variant_DispObjectArray_by_ref(DispObjectArray array);

(U!HO)P(g0// 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 返回对数组的引用
2@:t{[ D0VARIANT lrc_variant_FloatArray_by_ref(FloatArray array);

// lrc_variant_IntArray_by_ref 返回对数组的引用
VARIANT lrc_variant_IntArray_by_ref(IntArray array);

*p Sw2PQ Q,dn3LIj0// lrc_variant_LongArray_by_ref 返回对数组的引用
VARIANT lrc_variant_LongArray_by_ref(LongArray array);

// lrc_variant_ShortArray_by_ref 返回对数组的引用
VARIANT lrc_variant_ShortArray_by_ref(ShortArray array);51Testing软件测试网;Vb1n-G,Oi(j

J L]$aTG0// lrc_variant_UintArray_by_ref 返回对数组的引用
4u,@2],R5eU1n ?x0VARIANT lrc_variant_UintArray_by_ref(UintArray array);51Testing软件测试网'y Fmh`,iL(N

UzAV2I8U/Z6E/ZX0// lrc_variant_UlongArray_by_ref 返回对数组的引用51Testing软件测试网l9FP9K8v C J
VARIANT lrc_variant_UlongArray_by_ref(UlongArray array);51Testing软件测试网2~ Ky|f

// lrc_variant_UshortArray_by_ref 返回对数组的引用
VARIANT lrc_variant_UshortArray_by_ref(UshortArray array);

|1E&_-`IQ5^0// lrc_variant_VariantArray_by_ref 返回对数组的引用51Testing软件测试网.r*w*CBn
VARIANT lrc_variant_VariantArray_by_ref(VariantArray array);

// lrc_Get<Type-Name>ArrayFromVariant 函数系列从变量中
2O5Dk3I0D/M&U1f:S0// 提取由 Type-name 指定的类型的数组。
<Type-Name> lrc_Get<Type-Name>ArrayFromVariant const VARIANT* var);51Testing软件测试网!QqJ(K(Ra.{w

// lrc_GetBoolArrayFromVariant 从变量中提取数组。51Testing软件测试网#N,jA~;F1~j
VARIANT lrc_GetBoolArrayFromVariant(const VARIANT* var);

// lrc_GetBstrArrayFromVariant 从变量中提取数组。
;M&l.pJ R'D&q0VARIANT lrc_GetBstrArrayFromVariant(const VARIANT* var);

// lrc_GetByteArrayFromVariant 从变量中提取数组。
6F7j4vPl Lf4b7|0VARIANT lrc_GetByteArrayFromVariant(const VARIANT* var);

1MU}8v^*g*c0// lrc_GetCharArrayFromVariant 从变量中提取数