loadrunner 函数说明(转载)

g%dH|\:@C`1WJ0// button_press 函数激活指定的推按钮。
5LjkUT
`,G8cGE0int button_press ( LPCSTR button );

// button_set 函数将按钮状态设置为 ON 或 OFF。
;A,s-k8pr$d@0int button_set ( LPCSTR button, int state );

&}|cd9d2@
s Cg0// close_session 函数关闭所有打开的窗口并结束51Testing软件测试网+j!?K9x,S
// 当前的 Baan 会话。在 Baan 模板中创建的此函数
v"es7Nj R,i S0// 出现在脚本的 vuser_end 部分中。
!kVGq m&onp
r9P0int close_session();51Testing软件测试网j_l D@0`E

A#xaN5t5gcQ.q0// edit_get_text 函数返回在指定 edit 对象中
:rw$^!q1oa7A.e t0// 找到的所有文本。若要从特定块中读取文本，51Testing软件测试网(Jk:ZOg
// 请使用 edit_get_block。51Testing软件测试网'P+S{
[(Y"GB
e.g1L
int edit_get_text ( LPCSTR edit, char *out_string );

// edit_set 函数使用指定的字符串设置 edit 对象的
-HBd:Ixl0// 内容。该字符串将替换任何现有字符串。51Testing软件测试网5E _]4s.F
int edit_set ( LPCSTR edit, LPCSTR text );51Testing软件测试网4D#X | T(`6_1~%q4Ch

+v'i+E W'pM,Rj Vd0// edit_set_insert_pos 函数将光标放置
nwd'U(c+P0// 在 edit 对象内的指定位置。51Testing软件测试网tm;o+U3Ht;A
int edit_set_insert_pos (LPCSTR edit, int row, int column );

// edit_set_selection 函数突出显示指定文本。
w|}lb-p@0int edit_set_selection ( LPCSTR edit, int start_row, int start_column, int end_row,  int end_column );

KVb0O!]0// edit_type 函数将文本字符串输入到 edit
wXr(Xv z0// 对象中。该文本字符串不会替换现有字符串；51Testing软件测试网g0Dj}7Di5|i1c&]
// 它替换的是位于当前光标位置的指定文本。
T$Z1\ @{ [;lZ0int edit_type ( LPCSTR edit, LPCSTR text );

#Z/\jHX~!L0// init_session 函数通过指定登录数据和配置
(yD5\N eu0Gg3`F0// 信息打开 Baan 连接。此函数向 Baan 服务器
Tl%_4}:U1F*l!Z9o$}0// 呈现包含在 Baan Configuration 部分中
X]c ` l1\0// 的信息。

nu
O6A%al8Ty0int init_session ( char * host, char * user, char *password, char *BSE,  char *Bshell_name, char * settings );

// list_activate_item 函数双击列表中的项目。
"_A4y[n"RY Z
yT
[n0// 项目可由其逻辑名称指定。51Testing软件测试网!A!],Sx2@'z`u
int list_activate_item ( LPCSTR list, LPCSTR item );

// list_collapse_item 函数隐藏展开的 TreeView
!v{*HzP!?6|-ON0// 列表中的子项，例如文件夹中的各个文件。51Testing软件测试网,X U6jFg_n0W Z&RF
int list_collapse_item (LPCSTR list, LPCSTR item );51Testing软件测试网J)[z-?.|0`E7e7G^,}

// list_expand_item 函数显示展开的51Testing软件测试网$n| N*p
|f x9c
// TreeView 列表中所隐藏的子项，例如
.PH)eJda"s.n0// 文件夹中的各个文件。51Testing软件测试网R'_pmM ci E#\
int list_expand_item (LPCSTR list, LPCSTR item );51Testing软件测试网X$u [{ {#m0Wkl$`v g

YVSY$?Q0// list_get_selected 函数返回列表中的选定51Testing软件测试网&ns1M[4w
// 项目。它既查找标准列表，也查找多选项列表。
8]\D u$w1h9n0int list_get_selected (LPCSTR list, LPCSTR out_item, LPCSTR out_num );

;?i)A:}9j p1Cs0// list_select_item 函数从列表中选择项目
+cJ3OF"C0// （在项目上执行一次鼠标单击）。项目可由
#LN c
x2N ]0// 其名称或数字索引指定。索引被指定为一个
9xLW6R\ Z
XV0// 字符串，并前置有字符 #。列表中的第一个51Testing软件测试网5xxe NN~ ^
// 项目编号为 0。例如，列表中的第三个项目
5C$f'v3j$@Wo0k0// 将表示为 "#2"。51Testing软件测试网hr(Q6G:g
int list_select_item ( LPCSTR list, LPCSTR item );

3\;R%p7Y+q8hF0// menu_select_item 函数根据菜单
;t!A\~,^,OS0// 的逻辑名称和项目名称从菜单中选择51Testing软件测试网;_zZ'W:I(J
// 项目。注意，菜单和项目表示为单个51Testing软件测试网,W Z$I&|;p:|-AX7r"_
// 字符串，并使用分号分隔。
$s"yo p@&y\0int menu_select_item ( LPCSTR menu_item );51Testing软件测试网D4bt]7?)P5I$An#{

// obj_get_info 函数检索指定属性的值，51Testing软件测试网3c+E5ge6c1c%CL2A W m
// 并将其存储在 out_value 中。51Testing软件测试网N`\qz
int obj_get_info ( LPCSTR object, LPCSTR property, char *out_value );51Testing软件测试网t!D$P
}b vGv!_

// obj_get_text 函数从指定的对象
~ [7u~wE0// 或对象区域中读取文本。51Testing软件测试网^2o|u/~j4RZ
int obj_get_text (LPCSTR object, LPCSTR out_text );

DN)g,_+^`]1p0// obj_mouse_click 函数在对象内的51Testing软件测试网4f,x3U+H8GH5~(E4]S4d
// 指定坐标处单击鼠标。51Testing软件测试网O,LT^Clg0}
int obj_mouse_click ( LPCSTR object, int x, int y, [mouse_button] );51Testing软件测试网[rx^dp.?a

// obj_mouse_dbl_click 函数在对象内的
?'J6e{:Nn+q0// 指定坐标处双击鼠标。
e&m h.N^o3O0int obj_mouse_dbl_click ( LPCSTR object, int x, int y, [mouse_button] );51Testing软件测试网SR'Mpl8m

// obj_mouse_drag 函数在 GUI
"H\ fc8}0// 对象中执行鼠标拖动操作。指定的51Testing软件测试网f
o5M@!P\Z9Y
// 坐标是相对于 GUI 对象（而非

G0k MI'FZp,f0// 屏幕）的左上角。51Testing软件测试网R s)w9m5b
`c
int obj_mouse_drag (LPCSTR object, int start_x, int start_y, int end_x, int end_y, [ ButtonT mouse_button] );

k%s4wT(w{"E6OS0// obj_type 函数指定将 keyboard_input51Testing软件测试网-ZzF%w0G]{?
// 发送到的目标对象。51Testing软件测试网)RrSu$V
int obj_type ( LPCSTR object, unsigned char keyboard_input, [unsigned char modifier ] );51Testing软件测试网)E_(oQuCI&d

wR+{_*Vj!\\0// obj_wait_info 函数等待对象
(W:l;U4G@0// 属性达到指定值，然后继续
Gv!D(o/B0// 测试运行。如果未达到指定
Q4b7Z5UgX0// 值，则函数将一直等到时间51Testing软件测试网3{f1a C/i;AL
// 到期，然后再继续测试。51Testing软件测试网geVk5i Ld t
}(E
int obj_wait_info (LPCSTR object, LPCSTR property, LPCSTR value, UINT time );

// scroll_drag_from_min 函数将滚动屏

r7vVYE"U0// 移动到与最小位置相距指定距离的位置。51Testing软件测试网&l~!a*G)r$p
int scroll_drag_from_min ( LPCSTR object, [int orientation], int position );51Testing软件测试网Jdn6fM1P8ldITJZ

J)o9v0n b x:O Wn-sB*{0// scroll_line 函数滚动指定行数。
)t5bbmzag0// 此函数可用于滚动栏和滑块对象。51Testing软件测试网!]s
f lS0x;u
int scroll_line ( LPCSTR scroll, [ScrollT orientation], int lines );51Testing软件测试网9h5NqmPJ9O js

// scroll_page 函数将滚动屏移动指定页数。51Testing软件测试网Z%KZ0f ZF
int scroll_page ( LPCSTR scroll, [ScrollT orientation], int pages );

%D6N,a^
X5s+^0// set_default_timeout 函数设置回放
-Q] Ed
^nWr0{s$S#H0// 期间 Baan Vuser 函数的超时期间段。51Testing软件测试网xj$P+u7R.\({
// 例如，当脚本执行 set_window 函数
4f&J4T5_Jh.z"]0// 时，如果窗口在指定超时时间段内没有51Testing软件测试网j[9K dU|N0F*`
// 出现，则会生成错误。51Testing软件测试网:Vu'[B V1h&hYu}
void set_default_timeout ( long time );51Testing软件测试网H&vsQ+oILWgY

// set_exception 函数指定在发生异常时
-rya2v:ur|0// 应执行的操作。应指定要调用以处理异常51Testing软件测试网c?+@b!PT&qIH
// 窗口的函数。51Testing软件测试网2E:eGqY3M6^QU,x7o
void set_exception ( LPCSTR title, long function );

// set_think_time 函数指定脚本执行51Testing软件测试网I*eY!as
// 期间要使用的思考时间范围。运行脚本
)J ^
QCq.R)~n0// 时，LoadRunner 使用指定范围内的
5V*G#Py*k)l4gr0// 随机思考时间，并在每个操作完成后51Testing软件测试网,UI;C5S8r
Ge*`6@y
// 暂停该思考时间长度。
E,O+W3? {(|1l0void set_think_time ( USHORT start_range, USHORT end_range );

// set_window 函数将输入定向到
ib*V x~0// 当前应用程序窗口并在 GUI 图中
#@@M2g2A G%c9n0// 设置对象标识范围。
g3b*e^ }0int set_window ( LPCSTR window [, int  timeout ] );

p+grzePL&k
WH0// start_session 函数在 Baan
g$u+@9k0m3Y"Od0// 服务器上开始指定的会话。
0ZK6IZd#\#ToM0int start_session ( LPCSTR session );

// static_get_text 函数返回在指定51Testing软件测试网W5x5SJ2or#?
// 静态 text 对象中找到的所有文本。51Testing软件测试网/Wji6n!hR1U
int static_get_text ( LPCSTR static_obj, LPCSTR out_string );

// tab_select_item 函数选择一个选项卡项目。51Testing软件测试网!uD'p cFb9T R X
int tab_select_item ( LPCSTR tab, LPCSTR item );

&`0l!bN)eis0// tbl_activate_cell 函数在指定表单元格中
7jn,{uiL0// 按 Enter 键。如果指定了列名，LoadRunner51Testing软件测试网4\(]#a%h(Q
// 将直接从数据库中获取该名称。
|4W!h3S-V*S:{0int tbl_activate_cell (LPCSTR table, LPCSTR row, LPCSTR column );

// tbl_get_cell_data 函数根据
n2L-a$uAQ3\0// 单元格包含的数据类型获取表中
Ej)GUG;h0// 指定单元格的内容。如果指定了
gj#u+PG'N9B5r0// 列名，将从数据库自身（而非应用51Testing软件测试网(c)bJ bE5?geW
// 程序）中获取该名称。51Testing软件测试网k(Noe7{5p"dg
int tbl_get_cell_data (LPCSTR table, LPCSTR row, LPCSTR column, LPCSTR out_text );51Testing软件测试网,[ X]9mg:d

// tbl_get_selected_cell 函数51Testing软件测试网n$v,r%{$U&q,AX
// 检索焦点所在的表单元格的行号和
0PY
jCCmg6mi0// 列名。注意，列名取自数据库自身，
%N!Z!M`Rs%r0// 而非应用程序。51Testing软件测试网]&Bg
~+~a.c4Sq(k
int tbl_get_selected_cell (LPCSTR table, char *out_row, char *out_column );51Testing软件测试网TR??5MO/W#jf,Y

// tbl_press_zoom_button 函数
oQt6~%f^;i,kf0// 激活指定表单元格的缩放窗口。51Testing软件测试网m8`/V!P'|~
int tbl_press_zoom_button ( LPCSTR table, LPCSTR row, LPCSTR column );51Testing软件测试网9Zo:b$[1p

Q&SO8dG-G,U6P0// tbl_set_cell_data 函数根据单元格
t W'j!a3reT8Py0// 包含的数据类型使用指定数据设置单元格51Testing软件测试网.Pu?)ql l5jWw8Z4P
// 的值。如果指定了列名，LoadRunner
1o8baN!D0// 将直接从数据库中获取该名称。
tJ ^t"S6G%mu0int tbl_set_cell_data (LPCSTR table, LPCSTR row, LPCSTR column, LPCSTR data );51Testing软件测试网#D1P$Wj"z

// tbl_set_selected_cell 函数将焦点
!sNH`*M2yl_7w s|T0// 设置到表中的指定单元格上。指定列名时，
O&h H'Dr g~0// LoadRunner 将直接从数据库中获取该名称。51Testing软件测试网mZ'mC5s yt
int tbl_set_selected_cell (LPCSTR table, LPCSTR row, LPCSTR column );

&xF`L q0// tbl_set_selected_row 函数选择表中的指定行。51Testing软件测试网qL(]R)b]&\
int tbl_set_selected_row (LPCSTR table, LPCSTR row );51Testing软件测试网7\y#X$?,?)dP&\9Kkl

s PcyYX:E0// tbl_set_selected_rows 函数选择指定行范围。
/SO|3Pu R!G;JL_#{0int tbl_set_selected_rows(LPCSTR table, LPCSTR from_row , LPCSTR to_row );51Testing软件测试网?AkC+LaLM

7CTHVUm-O^4d0// tbl_wait_selected_cell 函数等待51Testing软件测试网:Pl"~?EGb
// 表单元格显示后，再继续脚本执行。51Testing软件测试网La(A(PS U
int tbl_wait_selected_cell (LPCSTR table, char *row, char *column, UINT time );

// toolbar_button_press 函数激活工具栏中的按钮。51Testing软件测试网'xD~)d-F&xgVF
int toolbar_button_press (LPCSTR toolbar, LPCSTR button );

t k^pWO,^V#wZ)T0// type 函数描述发送给用于测试51Testing软件测试网Ek](t&V&}z
// 的应用程序的键盘输入。
u!c]5U4z'CC3I0int type (LPCSTR keyboard_input );

P)shi6^@@X2o!@~q0// win_activate 函数通过向指定窗口51Testing软件测试网1qGxH"WR(`q
// 授予焦点并将其升到显示器最上端，51Testing软件测试网A x4c5NNP-TL6r
// 使其成为活动窗口（等价于单击窗口51Testing软件测试网\h A~a_,lN|.g
// 标题栏）。所有后续输入都将提交给
'k"K'P?&^;eB0// 此窗口。51Testing软件测试网7h4H Oq4Zg9A{0W
int win_activate (LPCSTR window );51Testing软件测试网 f BQ;@)z~;oA*z%V

// win_close 函数关闭指定窗口。
V8['t4i.c?m'`(s0int win_close ( LPCSTR window );

QtDT8uI1Fk,^0// win_get_info 函数检索指定属性的值51Testing软件测试网4HsQ(d\~E
// 并将其存储在 out_value 中。
c"d*]pP]_ _&k0int win_get_info ( LPCSTR window, LPCSTR property, char *out_value );51Testing软件测试网Kxkaa8c

*ZVC3OQ0x
va:U0// win_get_text 函数从指定窗口或
A W#G zk&{$Y+C/[I0// 窗口区域读取文本。
w~Z8eir^a0int win_get_text ( LPCSTR window, LPCSTR out_text );

// win_max 函数将指定窗口
R;cGK1^)K6\0// 最大化以充满整个屏幕。
%}"c%]{-\ r7pC0int win_max (LPCSTR window );

P.@].^4BYt e0// win_min 函数将指定窗口最小化为图标。51Testing软件测试网
PDK`T8EH
int win_min (LPCSTR window );51Testing软件测试网B${$||5ey;xM B%U(EDx

// win_mouse_click 函数在选中窗口
v$T%qnrB+U`u0// 的指定坐标处执行鼠标单击操作。51Testing软件测试网6CZ"nC)x/qX"{h
int win_mouse_click (LPCSTR window, int x, int y, ButtonT button );51Testing软件测试网NJ-Q4m&j/e4~v?/L0s

R]F+JjG)DE] EG0// win_mouse_dbl_click 函数在选中窗口51Testing软件测试网 eoU:?Z
Uc
// 的指定坐标处执行鼠标双击操作。
[y#t,y C0int win_mouse_dbl_click (LPCSTR window, int x, int y, ButtonT button );

// win_mouse_drag 函数在窗口内执行51Testing软件测试网k5b&R9q7HY0p%t
TM
// 鼠标拖动操作。注意，指定的坐标是51Testing软件测试网e#^)Ev
GO
// 相对于窗口（而非屏幕）的左上角。51Testing软件测试网TK"IJ]KPO
int win_mouse_drag (LPCSTR window, int start_x, int start_y, int end_x, int end_y, ButtonT button );51Testing软件测试网$JD5`1I a3[2eSZ|

:F:d1a!w#B*m"@K[0// win_move 函数将窗口移动到新的绝对位置。
&p0i6zC S5n1R2\0int win_move ( LPCSTR window, int x, int y );51Testing软件测试网#?9i!d/j~

(RHtpBu o6I0// win_resize 函数更改窗口的位置。51Testing软件测试网o aW-dC&~r@
int win_resize ( LPCSTR window, int width, int height );

|.@lc"AJ;D0// win_restore 函数将窗口从图标化
,^)O+RLe_8?wDy0// 或最大化状态还原为其原始大小。
;LL&GSW(K
R/}1B0int win_restore (LPCSTR window );

P|+n%K7`;v@0// win_wait_info 函数等待窗口51Testing软件测试网-eme:K#E#a
// 属性达到指定值，然后继续测试51Testing软件测试网yDt yp
// 运行。如果未达到指定值，则函数
'A)ox
]}
N0// 将一直等到时间到期，然后再继51Testing软件测试网M9L \.ZP!@7s,@\t
// 续测试。
^T[`!zb0int win_wait_info (LPCSTR window, LPCSTR property, LPCSTR value, UINT time );51Testing软件测试网:~3_2{PR%@ x)h?:b8O

6j|+]t?v0// win_type 函数指定 keyboard_input51Testing软件测试网Qu7M,Hz-i)|ydX+Gh
// 将发送到的目标窗口。
#[9P US3zq/YX{Y0int win_type (LPCSTR window, LPCSTR keyboard_input );

// ctrx_<obj>_get_info 函数系列将属性51Testing软件测试网V7V'sO b
// 的值分配给值缓冲区。ctrx_obj_get_info51Testing软件测试网bEIJJ!X5Sv
// 是一般函数，它可以适用于任何由录制器
/w5p y]f!nBh0// 所标识为对象的对象。
9|)W2nV;@wc"TU%T!o0int ctrx_obj_get_info( const char * window_name, long xpos, long ypos, eObjAttribute attribute, char *value, CTRX_LAST );

`c#EK,[0// ctrx_<obj>_get_info 函数系列将属性的值
E%a}I)}k6N0b0// 分配给值缓冲区。ctrx_button_get_info
p*^;W)t+Z5E0// 获取命令按钮的信息。51Testing软件测试网V0? {&uB5f,W
int ctrx_button_get_info( const char * window_name, long xpos, long ypos, eObjAttribute attribute, char *value, CTRX_LAST );

:K+lf.G er7{\"R4D0// ctrx_<obj>_get_info 函数系列将属性的值51Testing软件测试网+tsE3f*q:S5}1m
// 分配给值缓冲区。ctrx_edit_get_info
8K$x#r-c"}0z0// 获取文本框的信息。51Testing软件测试网#R,~#@&_h&R,gJ!`
int ctrx_edit_get_info( const char * window_name, long xpos, long ypos, eObjAttribute attribute, char *value, CTRX_LAST );51Testing软件测试网:pA,VEH;O*X

3g&Q-nH6bev0// ctrx_<obj>_get_info 函数系列将属性的值51Testing软件测试网$};aIu%Z0E[6U
// 分配给值缓冲区。ctrx_list_get_info51Testing软件测试网[$z,zP
^\
// 获取列表框的信息。51Testing软件测试网EG2v R)a'U
int ctrx_list_get_info( const char * window_name, long xpos, long ypos, eObjAttribute attribute, char *value, CTRX_LAST );

// ctrx_connect_server 将 Citrix 客户端连接到 Citrix 服务器。51Testing软件测试网&R*[]4x(@
int ctrx_connect_server (char * server_name, char * user_name, char * password, char * domain);

// ctrx_disconnect_server 断开客户端与 Citrix 服务器的连接。
Y@&Ri E0int ctrx_disconnect_server (char * server_name);

5B%`Q-`4`#G;q {:o G0// ctrx_nfuse_connect 使用 NFUSE 应用51Testing软件测试网*M9E)DE3J!|
// 程序门户建立与 Citrix 服务器的连接。在51Testing软件测试网'oGm;L)ViC
// 定义 NFUSE 门户的个性化规范的 ICA 文件51Testing软件测试网9N+s%y#e{ a q.]
// 中找到的规范将从服务器上下载，在此之后
,N%R#Y6i+v P8]0// 建立连接。51Testing软件测试网s1c1k,P+[ WbS
int ctrx_nfuse_connect(char * url);51Testing软件测试网 _ S9kze#H*YU9V \U?s

// 使用 ctrx_get_bitmap_value51Testing软件测试网
n:x7ku(Z
// 检索位图的哈希字符串值以用于您
OWpG3Zx0^0// 的自定义同步函数中。位图坐标由
Y@g EdAe8C4S:V0// 前四个参数指定。51Testing软件测试网(RX%Z4D5ib
int ctrx_get_bitmap_value (long x_start, long y_start, long width, long height, char * buffer);51Testing软件测试网Sy+JtdtC3z

// ctrx_get_text 将矩形中的文本分配到 text_buffer51Testing软件测试网2S5^2I,?] L`2a-i
// 中。随后，文本可被用于关联。51Testing软件测试网 K&|z-p l ?
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、
|Y*t W k0// ypos、width 和 height 指定区域中
3|p3b`f C ^N|m0// 搜索指定文本。如果找到字符串，当函数51Testing软件测试网ob,ZX E9@
// 返回后，xpos 和 ypos 即为找到文本的51Testing软件测试网)p.NM(m CR&kk*C;e:|F
// 位置。如果未找到字符串，xpos 和 ypos51Testing软件测试网?&UP#B:jCl
// 则为零。51Testing软件测试网|-H9CD"z d#N2U
int ctrx_get_text_location( LPCSTR window_name, long *xpos, long *ypos, long *width, long *height, LPSTR text, long bMatchWholeWordOnly, LPCSTR filename, CTRX_LAST );51Testing软件测试网\lr[I2J

// ctrx_get_waiting_time 从运行时设置中获取当前等待
(^vBv*Ad0N*P^0// 时间，或者通过 ctrx_set_waiting_time 设置的值。51Testing软件测试网p1p-p B&Ma3hM|I:G)m
int ctrx_get_waiting_time ( long * time );

// 使用 ctrx_get_window_name 检索51Testing软件测试网!K8l3F4p]9O
// 当前获得焦点的窗口的名称。
A EZx)~7]Bn0int ctrx_get_window_name (LPSTR buffer);

k.K0xT)C%[s0// 使用 ctrx_get_window_position51Testing软件测试网I:~J$WZ`1[
// 检索名为 title 变量值的窗口的位置。51Testing软件测试网ezw%_#jN4U{1_-E
// 如果 title 为 NULL，则函数将检索
\7P&Ds,y n0// 当前拥有焦点的窗口的位置。
C#H;J$o8W/wH#V0int ctrx_get_window_position (LPSTR title, long *xpos, long *ypos, long *width, long *height);

// ctrx_list_select_item 函数从列表中选择项目。51Testing软件测试网%U5ByyI3nC)l
// 它支持 ListBox 或 ComboBox 类的列表。51Testing软件测试网/],W7nDpM8]F~(Q
int ctrx_list_select_item(char * window_name, long xpos, long ypos, char * item, CTRX_LAST );

// ctrx_menu_select_item 突出显示51Testing软件测试网
Wn0f0YjMry2O
// 菜单中的项目，但不激活它。
I0`p!Z:i0int ctrx_menu_select_item ( char *  window_name, char *  menu_path, CTRX_LAST) ;

.L2T*v{;\ y0// ctrx_mouse_click 等待窗口 window_name
0e)G z,a;Y8n$Wq0// 出现，然后执行鼠标单击操作。51Testing软件测试网5x:NO
rO6Bm
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
D:Px8R#z]]"{RmT0// 出现，然后执行鼠标单击操作。51Testing软件测试网H/f%J9[,G4dc+J,?
int ctrx_obj_mouse_click (const char * obj_desc, long x_pos, long y_pos, long mouse_button, long key_modifier, char * window_name);51Testing软件测试网}v5Q(`x;Y[R

k)a rxJ[0// ctrx_mouse_double_click 等待窗口 window_name
9y8BSJ v0// 出现，然后执行鼠标双击操作。
2`\}knQ0int ctrx_mouse_double_click (long x_pos, long y_pos, long mouse_button, long key_modifier, char * window_name);

)f:](tfZ7AO0// ctrx_obj_mouse_double_click 等待窗口 window_name
#Ki/x+p.nq"Ub-z0// 出现，然后执行鼠标双击操作。
v`tb2vr0int ctrx_obj_mouse_double_click (const char * obj_desc, long x_pos, long y_pos, long mouse_button, long key_modifier, char * window_name);51Testing软件测试网8O-ED/]+IQEl

,B.UX!E`5r0// ctrx_mouse_down 等待窗口 window_name51Testing软件测试网pN
t1xq!h,n:Tzf{
// 出现，然后执行按下鼠标按键操作。
rU1m2hV*H0FqJ0int ctrx_mouse_down(long x_pos, long y_pos, long mouse_button, long key_modifier, char * window_name);

7L;R2kw#Z,h;M$t0// ctrx_obj_mouse_down 等待窗口 window_name51Testing软件测试网l&f3Lm&G9Wu(E!j
// 出现，然后执行按下鼠标按键操作。51Testing软件测试网(y B/Z/r&Wm0GI
int ctrx_obj_mouse_down(const char * obj_desc, long x_pos, long y_pos, long mouse_button, long key_modifier, char * window_name);51Testing软件测试网f\Nu!G"^:w

KYQ;c A @CU0// ctrx_mouse_up 等待窗口 window_name51Testing软件测试网+kCo{K
// 出现，然后在指定位置执行释放鼠标按键操作。51Testing软件测试网r(c1]~7ni,R8no
int ctrx_mouse_up(long x_pos, long y_pos, long mouse_button, long key_modifier, char * window_name );

k6vTpKzL5vp&N0// ctrx_obj_mouse_up 等待窗口 window_name51Testing软件测试网k'FN8I x6UD
// 出现，然后在指定位置执行释放鼠标按键操作。51Testing软件测试网l$Z WG+P/c
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 是同步函数，它等待
'C5K,p$wcj\7E O0// 窗口出现，然后 Vuser 才在该窗口中模拟
vlil)C"{0// 任何键盘或鼠标活动。
S2s!^3@"@L0int ctrx_set_window (char * window_name);51Testing软件测试网uAUW$U#@

// ctrx_set_window_ex 是同步函数，它至多51Testing软件测试网FZ+Fi2T8qr-T.X;l
// 等待 time 秒，若窗口出现，Vuser 将在该51Testing软件测试网#qW{9n\0G
zU
// 窗口中模拟任何键盘或鼠标活动。51Testing软件测试网T4x e-j RBc
int ctrx_set_window_ex (char * window_name, long time);51Testing软件测试网x&M2^H$[xpneHw

// ctrx_key 模拟用户在 Citrix 客户端中
7QW h K^&Yh3a0// 按下非字母数字键。
UO z"cS;Ay0int ctrx_key (char * key, long int key_modifier);51Testing软件测试网CLPt!gA'I

// 函数 ctrx_type 模拟用户键入字母数字字符。
kho~M5J6F0int ctrx_type (char * data);51Testing软件测试网J[0`)N/tCw

R5M0^8`%f&\0// ctrx_save_bitmap 将位图保存为文件。51Testing软件测试网7b%~q2@"i8x
`+Q(U\'c
// 该文件将保存在 Vuser 结果日志目录中。51Testing软件测试网 t5oY)N'u@
int ctrx_save_bitmap( long x_start, long y_start, long width, long height, const char * file_name );51Testing软件测试网w+nw(ex8_

// ctrx_set_connect_opt 在建立 Citrix 客户端51Testing软件测试网R_l!];h1h'arL
// 与 Citrix 服务器的连接之前设置连接选项，然后51Testing软件测试网7r6{+t oKe
V\x}9d
// 执行与服务器的连接。51Testing软件测试网A+aE7x~;k
int ctrx_set_connect_opt (eConnectionOption option, char * value);

// ctrx_set_exception 定义当不规则51Testing软件测试网g:g PW0S8pB
// 事件发生时要执行的操作。此事件必须51Testing软件测试网ns+A2kT sQ/M8\
// 与名为 window_title 的窗口（通常
$v D ^i$G0// 为弹出式对话框）的外观相关联。当窗口51Testing软件测试网 U?{3Q(l\ l
// 出现时，将调用 handler 函数。51Testing软件测试网![!I/P5B&Q$\sf \QU
void ctrx_set_exception ( char * window_title, long handler, [void *context]);

.fs5x
`t0oq Y0// ctrx_set_waiting_time 更改
R3_!d,j*g&}0// 同步函数默认 60 秒的等待时间。51Testing软件测试网v;e}+}4\,XV"~-Xo
int ctrx_set_waiting_time (long time);

1a'a&Qf$sA0// ctrx_sync_on_bitmap 是同步函数，
m [,K#R*O+V0// 它等待指定位图出现，然后再继续执行。
C"bU cw)}R.c*e0int ctrx_sync_on_bitmap (long x_start, long y_start, long width, long height, char * hash);

4g|[!m3u5CTij0// ctrx_sync_on_bitmap_change 是同步51Testing软件测试网7|"A$IP:v7ec3_6y
// 函数，它等待指定位图改变，然后再继续执行。51Testing软件测试网8\/aO4vgFq;\
// 该函数通常用在窗口改变而窗口名称保持51Testing软件测试网:G8v'ry`!Cf m
// 不变的情况下。如果窗口名称改变，51Testing软件测试网#ca x|{N
// 则 ctrx_set_window 将被自动51Testing软件测试网GbFd_/l
// 生成。
3Y8w2Z/p,lZ0int ctrx_sync_on_bitmap_change (long x_start, long y_start, long width, long height, <extra_args>, CTRX_LAST);

^/UKT6Z0// ctrx_sync_on_obj_info 被调用时，执行将暂停，
.vUt1C`:sm6K0// 直到指定对象的属性具有指定的值。51Testing软件测试网/e2u$B4H4S.W
int ctrx_sync_on_obj_info ( char * window_name, long xpos, long ypos, eObjAttribute attribute, char * value, <CTRX_LAST> );

// ctrx_sync_on_window 是同步函数，
;SeX6[d7qR]r0// 它等待窗口被创建或变为活动的。51Testing软件测试网(A:LE*P xA8[
int ctrx_sync_on_window (char * window_name, eWindowEvent event, long x_start, long y_start, long width, long height, char * filename, <CTRX_LAST>);51Testing软件测试网7^8C[-A&V/VP

// ctrx_unset_window 是同步函数，它等待51Testing软件测试网|6fJ4Z[
// 窗口被关闭，然后脚本才继续执行。
}:r*Gw+`1Bk7N/l0int ctrx_unset_window (char * window_name);51Testing软件测试网!ysbFx o

// ctrx_wait_for_event 是同步函数，51Testing软件测试网-zW)U-K4ID*b]y2f
// 它等待事件发生。51Testing软件测试网{Z9{ p\RC$eM
int ctrx_wait_for_event (char * event);

// 如果窗口存在，ctrx_win_exist 返回 E_OK（零）。
sH a TS9No&Fd0// 在 window_name 中可以使用通配符 (*)。51Testing软件测试网"o ~Uh!n)?
int ctrx_win_exist (char * window_name, long waiting_time);51Testing软件测试网di$e7B G`m

M?ZY3p$Gj0// 有关 memchr 的详细信息，请参考 C 语言文档。
?!^#["RHq4G;EA0void *memchr ( const void *s, int c, size_t n );51Testing软件测试网.G"nM/W2k^]e

// 有关 memcmp 的详细信息，请参考 C 语言文档。51Testing软件测试网P~c:b-O6d
int memcmp ( const void *s1, const void *s2, size_t n );

!kuUaG0// memcpy 函数从 src 缓冲区中将 n 个
g*B'PYM1l5v0// 字符复制到 dest 缓冲区。
g:m+@Wd(`^0void *memcpy ( void *dest, const void *src, size_t n );51Testing软件测试网#?"HK!O2T3z1G6_O

// 函数 memmove（以及所有不返回 integer 类型51Testing软件测试网&^WuRj
// 的函数）必须明确在 Vugen 脚本中声明。
:R(p&w dh6D1OEB0void *memmove ( void *dest, const void *src, size_t n );51Testing软件测试网i7KaA!j

// 有关 memset 的详细信息，请参考 C 语言文档。51Testing软件测试网p8B|-oh Iht
void *memset ( void *buffer, int c, size_t n );

7Z9]^O+PT0// 有关 getenv 的详细信息，请参考 C 语言文档。
,V)ALX&xs0char *getenv ( const char *varname );51Testing软件测试网K3S|
sU`

6pq9A.Px+v0// 有关 putenv 的详细信息，请参考 C 语言文档。51Testing软件测试网:wO
A6A`:X5X
int putenv ( const char *envstring );

Se8|`%L%Ru `0// 有关 system 的详细信息，请参考 C 语言文档。
u@{L/Mi0int system ( const char *string );

// 有关 calloc 的详细信息，请参考 C 语言文档。51Testing软件测试网&a*Lp1J'q!UX%d BP
void *calloc ( size_t num elems, size_t elem_size );

// 有关 free 的详细信息，请参考 C 语言文档。
O6xp }y/G0void free ( void *mem_address );51Testing软件测试网Oez8Cv(}U)jI4nc(s

i5b+n:`%dM|n0// 有关 malloc 的详细信息，请参考 C 语言文档。
M"yh$nz5g0void *malloc ( size_t num_bytes );51Testing软件测试网B!g r6}&i\M
BUb,G

// 有关 realloc 的详细信息，请参考 C 语言文档。51Testing软件测试网^1bo1q7Q D2t
void *realloc ( void *mem_address, size_t size );

// 有关 abs 的详细信息，请参考 C 语言文档。
IkK)r2s o5z0int abs ( int n );51Testing软件测试网h`$yp.m`[

fv@:I+em_;^[*b0// 限制：cos 函数在 AIX 平台中无法使用。
%Kj)q1m,T-[B0double cos ( double x );51Testing软件测试网/eV y lp-sH

z9^$`e/}XMg0// 函数 floor（以及所有不返回 int 值的函数）51Testing软件测试网8YKI1p$p"qa
// 必须明确在 Vugen 脚本中声明。限制：此51Testing软件测试网~f~8z0{h
// 函数在 AIX 平台中无法使用。
&PeFN z6pA,K3mQ0double floor ( double x );

// 在调用 rand 前，请调用 srand 以51Testing软件测试网~(m(rM\9L-O
// 播种伪随机数生成器51Testing软件测试网u6LJm\}!M
int rand ( void );

r#}i.M L E2U2_]0// 限制：sin 函数在 AIX 平台中无法使用。51Testing软件测试网Mb2Jk6z^
double sin ( double x );

// 函数 sqrt（以及所有不返回 int 值的51Testing软件测试网:y0cD/Ei[
// 函数）必须明确在 Vugen 脚本中声明。51Testing软件测试网fTZ)\!]
x:~G'qk"_!^
// 限制：sqrt 函数在 AIX 平台中
OR,WK R0// 无法使用。
L g/R qxaR&B2Uv0double sqrt ( double x );51Testing软件测试网o2xb+Wj

%S kl:u;HX0// 在调用 rand 前，请调用 srand 以51Testing软件测试网Bs:t8v5A#~
// 播种伪随机数生成器51Testing软件测试网votYT@fK"yR
int srand ( time );

4EC,YBmk0// 有关 fclose 的详细信息，请参考 C 语言文档。
@.qAY!B,P"GoALT0int fclose ( FILE *file_pointer );

// 请不要在脚本中包括操作系统头文件（例如，stdio.h）。
kjZD+M$Fg0// 但是，这样将导致某些类型（包括 feof 使用的 FILE51Testing软件测试网s9S%r(J9K#u(x.\H Ih
// 类型）未经定义。这时，请使用 long 替代 FILE
zY'B
H)ht0// 类型。
.Uh$|J_0int feof ( FILE *file_pointer );

// 有关 ferror 的详细信息，请参考 C 语言文档。
5k\IPJa0int ferror ( FILE *file_pointer );

.y cXuD*Z7V'b0// 请不要在脚本中包括操作系统头文件（例如，

k1J7A:{1d%x_0// stdio.h）。但是，这样会导致某些类型
[+G5{3I i0e$g [0// （包括 fgetc 使用的 FILE 类型）未经定义。
1R+`-vAD%@)U!F]0// 这时，请使用 long 替代 FILE 类型。
MmAE2O {)F{0int fgetc ( FILE *file_pointer );

// 请不要在脚本中包括操作系统头文件（例如，
MNXbB p2nt0// stdio.h）。但是，这样会导致某些类型51Testing软件测试网hxsWgE1{Hm
// （包括 fgets 使用的 FILE 类型）未经定义。51Testing软件测试网7vVd-P4GY:w\SNu
// 这时，请使用 long 替代 FILE 类型。
-Sbr-U$~Z%Q0char *fgets ( char *string, int maxchar, FILE *file_pointer );51Testing软件测试网LJ0XqFPm ]P

brw*jI^3y`&m2Q0// 通过将 t 或 b 字符添加到 fopen 的 access_mode
NQDiL0// 参数，此访问模式字符串还将用于指定打开文件的方式51Testing软件测试网gq+zsY*u/s ]
// （文本还是二进制）。51Testing软件测试网&WQu;tkI:W
FILE *fopen ( const char *filename, const char *access_mode );

;T"f&Z(s:h3oV0// 有关 fprintf 的详细信息，请参考 C 语言文档。51Testing软件测试网qb[9DtY-If
int fprintf ( FILE *file_pointer, const char *format_string [, args ] );

// 请不要在脚本中包括操作系统头文件（例如，51Testing软件测试网?lws%|]iZc(A5~
// stdio.h）。但是，这样会导致某些类型
-a0?Cf6B$E:D'y)EC0// （包括 fputc 使用的 FILE 类型）未经定义。
Wm-fV%U0// 这时，请使用 long 替代 FILE 类型。51Testing软件测试网%gl'|$k ^3~.{}
int fputc ( int c, FILE *file_pointer );51Testing软件测试网xW+k'f\h~`

"\ E&U
YtW6UL0// 请不要在脚本中包括操作系统头文件（例如，51Testing软件测试网%} L e8j }$`'P ~#lA
// stdio.h）。但是，这样会导致某些类型51Testing软件测试网0Q(RO*J%ty4i C
// （包括 fread 使用的 FILE 类型）未经定义。
j:H
p%Y!Q!OB0// 这时，请使用 long 替代 FILE 类型。
/@~^0VERO4]0size_t fread ( void *buffer, size_t size, size_t count, FILE *file_pointer );51Testing软件测试网8x[*R9[`
q;p

A!Y'?6CP"D_,H0// 有关 fscanf 的详细信息，请参考 C 语言文档。51Testing软件测试网w+},q8y"p2U
int fscanf ( FILE *file_pointer, const char *format string [, args] );

// 有关 fseek 的详细信息，请参考 C 语言文档。
4~} K/Ge*xuD1v0int fseek ( FILE *file_pointer, long offset, int origin );

// 请不要在脚本中包括操作系统头文件（例如，
r.kK&dUY0// stdio.h）。但是，这样会导致某些类型
C A#\d$u'B0// （包括 fwrite 使用的 FILE 类型）未经定义。
AA$\fqV6Y3}0// 这时，请使用 long 替代 FILE 类型。51Testing软件测试网U%vb;k/?8@'K0f HJ/C
size_t fwrite ( const void *buffer, size_t size, size_t count, FILE *file_pointer );51Testing软件测试网
~(bzAz

// 有关 rewind 的详细信息，请参考 C 语言文档。
(d#Z*WEo:S2B(L RNu0void rewind ( FILE *file_pointer );

'?SGS1y i0// 有关 sprintf 的详细信息，请参考 C 语言文档。
jp Uwh;r p^\0int sprintf ( char *string, const char *format_string[, args] );51Testing软件测试网1m
Q U"w
bK

xm%UK\~h p0// 有关 sscanf 的详细信息，请参考 C 语言文档。51Testing软件测试网 CO&i ~@&qUK
int sscanf ( const char *buffer, const char *format_string, args );

3tz{Le0// 有关 chdir 的详细信息，请参考 C 语言文档。
j:i&dPDG6?0int chdir ( const char *path );51Testing软件测试网iOLa-t
`0Z9qPh

// chdrive 将当前工作驱动器更改为 drive（表示新驱动器
)T ul%?N;L%G'B3Q0// 的 integer 类型值）。例如，1 = A、2 = B，依此类推。
T%k3z` hp6`X)jp0int chdrive ( int drive );

L'K3\[]?K4nP%C0// 有关 getcwd 的详细信息，请参考 C 语言文档。
1KNaT/dr F
[]JpG0char *getcwd ( char *path, int numchars );51Testing软件测试网7pI1R#V0J

// getdrive 函数返回表示驱动器字母
K.]-Ln
V9Z0// 的 integer 类型值：1 = A、2 = B，依此类推。51Testing软件测试网f/^z`D-Vjj
int getdrive ( void );51Testing软件测试网]S6R
fn4O+ay

2_V2bGI K0// 有关 mkdir 的详细信息，请参考 C 语言文档。
^4`;tb1C rl0int mkdir ( const char *path );

$Ny+?:s[ E0// 有关 remove 的详细信息，请参考 C 语言文档。
#N(F&Z!X,^^l0int remove ( const char *path );51Testing软件测试网)MfzL-m^

// 有关 rmdir 的详细信息，请参考 C 语言文档。51Testing软件测试网 dM q8C Mp,]qVu%L
int rmdir ( const char *path );51Testing软件测试网R3T)I%|!h
x&q6Rq-~(S

// 根据系统时钟，time 函数返回从世界标准51Testing软件测试网4u*ai8m9uOp
// 时间 1970 年 1 月 1 日子夜 (00:00:00)
J,p'Ib5V2l;|D0// 作为开始所经过的秒数。返回值存储在 timeptr51Testing软件测试网]F*B1O6s:p"]b
// 所给出的位置。如果 timeptr 为 NULL，则
,TC[rp0// 该值不会被存储。
Y6X/Od/F0time_t time ( time_t *timeptr );51Testing软件测试网'i.Ak!U Q n5z/~

// 在 Unix 下，ctime 不是线程级安全函数。所以，请使用 ctime_r。
A(lv0E^8C0// 有关详细信息，请参阅平台相关文档。
s)p@6_P/[vn0char *ctime ( const time_t *time );51Testing软件测试网_\2C9qO*h
`

n0@^$mc5M*lCq0// 有关 ftime 的详细信息，请参考 C 语言文档。51Testing软件测试网VK([0@I0Ri+j'C
void ftime ( struct _timeb *time1 );

myoRZ Z*BP0// 在 Unix 下，localtime 不是线程级安全函数。
ROEZ[RS9G~0// 所以，请使用 localtime_r。有关详细信息，请51Testing软件测试网)q({#f'O:A/a]$V
// 参阅平台相关文档。
o5a/o)n-G3?0struct tm *localtime ( const time_t *time );

+e8^;P"M7p0// 在 Unix 下，gmtime 不是线程级安全函数。所以，请使用 gmtime_r。
acda@gj$^0// 有关详细信息，请参阅平台相关文档。
.Zg|i5\F.X3C%Z0struct tm *gmtime ( const time_t *time );51Testing软件测试网Y9i'A3A
\

// 在 Unix 下，asctime 不是线程级安全函数。所以，请使用 asctime_r。
8U7xIGO.c\9G5w0// 有关详细信息，请参阅平台相关文档。
4oSvNE(\[VT0char *asctime ( const struct tm *time );

(Dk0D`u7r0hskI0?7F0// 通过停止在第一个非数字字符上，atof 只
6G`;N N5DLh0// 读取字符串的初始位置。函数 atof（以及
h?W kj C0// 所有不返回 integer 类型值的函数）
@`YXv m:_0// 必须明确在 Vugen 脚本中声明。51Testing软件测试网k$p k3^ _QY)}
double atof ( const char *string );

$t~/PQz$K0// 通过停止在第一个非数字字符上，atoi 只51Testing软件测试网xD\,av}-b5@B-I
// 读取字符串的初始位置。
O
pxU/p@/K4?0int atoi ( const char *string );51Testing软件测试网2F)qp5XBV/i

// 通过停止在第一个非数字字符上，atol 只
T&M,QWA[s kT0// 读取字符串的初始位置。函数 atol（以及51Testing软件测试网 GF"?+r:q TQ
// 所有不返回 integer 类型值的函数）必须51Testing软件测试网V8pR&o;lH
// 明确在 Vugen 脚本中声明。51Testing软件测试网#RXf%bL/i?
long atol ( const char *string );

Pwv-FS$\\0// itoa 将 value 的数字转换为以 radix 作为
BHQ@"EF8E0// 基数的字符串 str。通常，radix 是 10。51Testing软件测试网fR[6O H9D6gs
int itoa ( int value, char *str, int radix );

// 通过停止在第一个非数字字符上，strtol
$o0EK&V|rX0// 只扫描字符串的初始位置。所有前置空格51Testing软件测试网.] TUksH6|K
// 都将被去除。endptr 指向停止扫描的字符。
5Xu1WA*g#Q-G NM0// 函数 strtol（以及所有不返回 integer
,J#psVD;f0// 类型值的函数）必须明确在 Vugen 脚本中51Testing软件测试网's9r;MJ6V`6o0X
// 声明。51Testing软件测试网:crDJ J|
long strtol ( const char *string, char **endptr, int radix );51Testing软件测试网3pa&Q7dk"ALi

// 有关 tolower 的详细信息，请参考 C 语言文档。
i%F$T]T0int tolower (int c);51Testing软件测试网@&\:j0Y w+O,p

,Lw4O2kn0// 有关 toupper 的详细信息，请参考 C 语言文档。51Testing软件测试网m;Hj3^Xvx2Y
int toupper ( int c );

// 有关 isdigit 的详细信息，请参考 C 语言文档。
F&q:S8pbR,r0int isdigit ( int c );51Testing软件测试网&ZjD+|-cIS g,]

4wo$D6MX k$k0// 函数 isalpha 检查 c 的值是否
s;o-xN*_AzeU0// 处于 A - Z 或 a - z 的范围之内。
;x
c-ggk'q0int isalpha ( int c );

// strcat 连接两个字符串。51Testing软件测试网\N\p7t+xn
char *strcat ( char *to, const char *from );51Testing软件测试网q$W1]Z[D+u(Q

g#E0ds2d0// strchr 返回指向字符串中51Testing软件测试网{6~2T7n
Y l*^W
// 第一个匹配字符的指针。51Testing软件测试网n!B/iDJ;Dr*V$[H
char *strchr ( const char *string, int c );51Testing软件测试网 n#c1re9O {

2L] R$m4FW0// strcmp 比较 string1 和 string2 以确定字母排序的次序。
/U/D3r&v(Y6Rs6{0int strcmp ( const char *string1, const char *string2 );51Testing软件测试网)q9w0n1OYK

// strcpy 将一个字符串复制给另一个。51Testing软件测试网
M&b.@'z.G? Uwd
char *strcpy ( char *dest, const char *source );51Testing软件测试网3MZ.M0^vW\+j

// strdup 复制字符串的副本。
/t(NlP Ix8_0char *strdup ( const char *string );

q"H.A"a2Pg0// stricmp 对两个字符串进行不区分大小写的比较。51Testing软件测试网4d*Q Rd2kf[mufd8~
int stricmp ( const char *string1, const char *string2 );51Testing软件测试网 Gv F4M4K

?X%Q)Hv&|C0// strlen 返回字符串的长度（以字节为单位）。

tqX6^L$u1R!Hq0size_t strlen ( const char *string );51Testing软件测试网+IcWE?_+W

1]zz.A+h0// strlwr 将字符串转换为小写。
O O%ak5q~WA:o&P&C0char *strlwr ( char *string );51Testing软件测试网{.K.mB](@L'J/|

ZC,g`wX6BR0// strncat 将一个字符串的 n 个字符连接到另一字符串。51Testing软件测试网)Z \%p\/d
char *strncat ( char *to_string, const char *from_string, size_t n );

a.H.V.Q%}'P:w0// strncmp 比较两个字符串的前 n 个字符。
K\E[o2Mg0int strncmp ( const char *string1, const char *string2, size_t n );

// strncpy 将一个字符串的前 n 个字符复制到另一字符串。51Testing软件测试网u-V2X2Y2|_@%pI%r
char *strncpy ( char *dest, const char *source, size_t n );51Testing软件测试网+|C/h/U8UiX

// strnicmp 对两个字符串的 n 个51Testing软件测试网cEt^0`8o
// 字符进行不区分大小写的比较，以
wW"d2F!B8e{*yU0// 确定其字母排序的次序。

\?T7W^0int strnicmp ( const char *string1, const char *string2, size_t num);51Testing软件测试网%_.M
U9p"G~A

A4a3F.i:r0// strrchr 查找一个字符串中的最后一个匹配字符。51Testing软件测试网it#e;?;e@$W6\.A
char *strrchr ( const char *string, int c );

// strset 使用指定字符填充字符串。51Testing软件测试网I,V;{N"gn9f
char *strset( char *string1, int character );51Testing软件测试网 ^"QJ5Y/Zm

// strspn 返回指定字符串中包含另一51Testing软件测试网9D5H6D T1lv$h
// 字符串起始字符的长度。
(wwO/^@)R9^,R0size_t *strspn ( const char *string, const char *skipset );

// strstr 返回一个字符串在另一字符串中第一次发生匹配的指针。51Testing软件测试网2uk,pd[#f ? pw'eC3Z
char *strstr ( const char *string1, const char *string2 );

dUH3],q;N0// strtok 从由指定的字符分隔的字符串中返回标记。51Testing软件测试网U?{"|q%k
// 注意，在 Vugen 文件中，需要明确声明不返回
GN\.WPZjH0// integer 类型值的 C 函数。
&@;CAZ`prHsZ0char *strtok ( char *string, const char *delimiters );51Testing软件测试网;gD3?1v J q GtF$]

// strupr 将字符串转换为大写。51Testing软件测试网n"VVN7dc0X+O/P3?B
char *strupr ( char *string );

kg5@*|?)q2[Nz0// lrc_CoCreateInstance 函数在本地系统或为特定
N4M9T1|([iJ0// 对象创建的默认主机中创建该对象的单个未初始化实例51Testing软件测试网3tX+Ks/txC'G
// 并返回未知接口，该接口可用于获取其他接口。创建
|CJy3f;k0// 该实例后，VuGen 调用 lrc_CoGetClassObject
9zs[ q]p q0// 以检索接口。如果 COM 对象位于远程计算机中，51Testing软件测试网$M?0@+W{5B[/sq
// 将使用 lrc_CreateInstanceEx 取代
!VbN/k_~E]6If0//  lrc_CoCreateInstance。51Testing软件测试网z#P4A
n)C{
HRESULT lrc_CoCreateInstance(GUID * pClsid, IUnknown * pUnkOuter, unsigned long dwClsContext, GUID * riid, LPVOID * ppv, BOOL __CheckResult);51Testing软件测试网,Q kI'Ja\

%R0uvh%J6sW D0// lrc_CreateInstanceEx 函数在指定的51Testing软件测试网{9vb
`n
// 远程计算机上创建未初始化的对象，并且
"g~!h'n WahL0// 可以返回任意数量的请求接口。

O&A.Fz]MQ Y0HRESULT lrc_CreateInstanceEx(char *clsidStr, Iunknown *pUnk, DWORD dwClsCtx, ...);51Testing软件测试网h
Nv(Zi7OkTc

/xws9c+x+LB9[U0// lrc_CoGetClassObject 函数提取
+b#le3@pv0// 指定类的类工厂。
s_%@"reDc8c0void lrc_CoGetClassObject( REFCLSID rclsid, Long dwClsContext, COSERVERINFO * pServerInfo, REFIID riid, LPVOID * ppv);

// lrc_GUID 函数返回命名对象（例如
n(C Nb4R0m*x0// COM 接口）的 GUID。VuGen 使用它
;u?*I8w-]2`4P0// 检索标识符，该标识符用于检索接口
je-eDXf d@@8m0// 标识符和用于 COM 通信的 COM 对象
7?JF/AA#s"c0// 的 PROGID。51Testing软件测试网B8H0{-I9R4~
GUID lrc_GUID(const char *str);

!ot-g)~@)hZWC$O0// lrc_GUID_by_ref 函数返回指向命名对象51Testing软件测试网A;h8^Og_)sWz
// （例如 COM 接口）的 GUID 的指针。VuGen51Testing软件测试网E
L3Y#JU1m}
F
// 使用它检索标识符，该标识符用于检索接口51Testing软件测试网? kY!T+C-R8BM
// 标识符和用于 COM 通信的 COM 对象的51Testing软件测试网!Q"P;Vr
sV;nG
// PROGID。
3L@1R_0s,ky
[A0GUID* lrc_GUID_by_ref(const char *str);

// lrc_DispMethod 函数使用 IDispatch:Invoke
gOkGX-xocI,`0// 方法调用接口的方法。lrc_DispMethod 调用51Testing软件测试网Rl+mlDk
_-N
// 将 wflags 设置为 DISPATCH_METHOD。
x|'r\/M9@0v6q0VARIANT lrc_DispMethod(IDispatch * pDispatch, char *idName, unsigned long locale, ...);

D-@,nK{AM+r0// lrc_DispMethod1 使用 IDispatch 接口调用
K-y l4RHn$f;N0// （或获取）同名的方法（或属性）。lrc_DispMethod151Testing软件测试网?e)~?m
// 调用将 wflags 设置为 DISPATCH_METHOD 和
3Tz:~ p y,y&T)ekz0Zu0// DISPATCH_PROPERTYGET。它可以用在方法与属性
v8~.g eRcn7{ K)Y5VV0// 具有同一名称的情况下。51Testing软件测试网$fLf8[g&^
VARIANT lrc_DispMethod1(IDispatch * pDispatch, char *idName, unsigned long locale, ...);

// lrc_DispPropertyGet 调用使用 IDispatch 接口
6A9cV4sie4t+G M0// 获取属性并将 wflags 设置为 DISPATCH_PROPERTYGET。
t%X]5DfBw)|O0VARIANT lrc_DispPropertyGet(IDispatch * pDispatch, char *idName, unsigned long locale, ...);

q:e{ Y|L'b0// lrc_DispPropertyPut 使用 IDispatch 接口设置属性。51Testing软件测试网!e-d@%[,RQ-h.y
// 该调用将设置 DISPATCH_PROPERTYPUT 标志。
#Y&U5P"H$Y5t(m0void lrc_DispPropertyPut(IDispatch * pDispatch, char *idName, unsigned long locale, ...);51Testing软件测试网9}vyPC'RPB

~t"zp7Rv0?0// lrc_DispPropertyPutRef 使用 IDispatch 接口根据51Testing软件测试网N:XSX}.t z
// 引用设置属性，并设置 DISPATCH_PROPERTYPUTREF 标志。51Testing软件测试网9uQ
P g9x'v
void lrc_DispPropertyPutRef(IDispatch * pDispatch, char *idName, unsigned long locale, ...);51Testing软件测试网@7n6xI8V2o~(w@'h

// lrc_CreateVBCollection 函数创建填充安全51Testing软件测试网OGH^7y`;P
// 数组值的 Visual Basic (VB) Collection 对象，
3nG"iQfxyG0// 并将集合接口指针返回到 pCollection 中。
6t8x9^5_u0// VB 集合是由 COM 实现为接口的变量51Testing软件测试网2|e*U/\0ja-g-dN
// SafeArray。
"E9aY$y XG0HRESULT lrc_CreateVBCollection(SAFEARRAY *items, _Collection** pCollection);

// lrc_CoObject_from_variant 函数从变量中51Testing软件测试网ndS*ww"Ye$F$[
// 提取 IUnknown 接口类型指针。
J}1K^2l~fp1\Im0IUnknown* lrc_CoObject_from_variant(VARIANT var);51Testing软件测试网4^Ck7sETJE6[PE+?

,Vw$G0z @.A|?0// lrc_DispObject_from_variant 函数从变量中
"? ?#YL j(W Dc^0// 提取 IDispatch 接口类型指针。51Testing软件测试网BPu Sh?E|
IDispatch* lrc_DispObject_from_variant(VARIANT var);51Testing软件测试网
uu8?8^_

A&}"|\!\#iG9B;Z;d0// lrc_CoObject_by_ref_from_variant 函数从指向51Testing软件测试网_ |.xw6O!^ x
// 变量的指针中提取 IUnknown 接口类型指针。51Testing软件测试网'W1T8_$g
r7}-u&Z6d
IUnknown* lrc_CoObject_by_ref_from_variant(VARIANT var);

Z}(Fj;H3l!u0// lrc_DispObject_by_ref_from_variant 函数从指向
.^y0D(? I{q0// 变量的指针中提取 IDispatch 接口类型指针。51Testing软件测试网8]C3fS
H,AZ(?7@1{
IDispatch* lrc_DispObject_by_ref_from_variant(VARIANT var);

// 输入表示整数的字符串时，lrc_int 函数返回
6JD%S @U+a0CKs0// integer 类型值。此参数可以是文字字符串、51Testing软件测试网 F~#rA4U2WM!q
// 变量或参数。51Testing软件测试网G4Q*v$y~*rC
int lrc_int(const char* str);51Testing软件测试网-|%s?c'K

// 输入表示整数的字符串时，lrc_int_by_ref
[B(A%})G6e3I z0// 函数返回指向 integer 类型值的指针。此参数51Testing软件测试网]|(\n)B)w
// 可以是文字字符串、变量或
#L#WG&ib/V#B'_1L2_0]0// 参数。
.fF
x?T0int* lrc_int_by_ref(const char* str);51Testing软件测试网/R$k:yS.C:h8T9i]\

// lrc_save_int 函数将 integer 值

? ?
i| @0// 保存在指定变量 name 下的字符串中，以便
h;kB*~
~#H6N!i0// 您将其用于参数化。VuGen 将此函数生成
q `kb0?v,NI0// 为注释掉的调用。如果要将此值用作参数，
.h%w-M,pH(z _N0// 可以更改 name 参数并取消调用的51Testing软件测试网kjh$T-{3J!|-L2G
// 注释。51Testing软件测试网g*s2LpV ^+A(s
int lrc_save_int(const char* name, int val);51Testing软件测试网;~x:`n"^9V7?)S"Qx

// lrc_save_int_by_ref 函数将 integer 值
$a'o&rY7J8qXbRFb0// 保存在字符串中，并将 val 设置为指向该字符串。51Testing软件测试网)P6q
jo6b]F#@+b
// VuGen 将此函数生成为注释掉的调用。如果要
i2UUak EI[0// 将此值用作参数，可以更改 name 并取消调用
&kcd%Au
fU&E0// 的注释。51Testing软件测试网F!M)}`wGp1nr
int lrc_save_int_by_ref(const char* name, int *val);51Testing软件测试网z+]$~.X&N&R

// lrc_get_bstr_length 返回 BSTR 类型字符51Testing软件测试网)q5}`;Q8[%M.xS.q
// 串的长度。BSTR 字符串可以包括 null。
{|xfL)U w O]0int  lrc_get_bstr_length(BSTR str);

1@?W#f#n9Pz0// lrc_get_bstr_sub 从输入字符串 str 的开始处
S}} k]I0// 返回 size 个字符的子集。51Testing软件测试网N1e;eVN3u5mD {
BSTR lrc_get_bstr_sub(BSTR str, int size);51Testing软件测试网Y*LM~WG+Qm

// lrc_print_bstr 将 BSTR 字符串输出到51Testing软件测试网YB$L6@sm'j@
// 用于调试目的的标准输出上。51Testing软件测试网@3R \/s;g2P~yA)K
int lrc_print_bstr(BSTR str);

// lrc_BSTR1 创建长度为 len 的 BSTR 字符串，它可以包括 null。
B;H)^'C^n
YJ9}$ZO0BSTR lrc_BSTR1 (const char* str, long len);

// lrc_save_BSTR1 函数将 BSTR str 保51Testing软件测试网7?iX
C;a8B6P Z
// 存到字符串 name 中。51Testing软件测试网ss)RyUR
int lrc_save_BSTR1 (const char* name, BSTR str);

// 输入表示无符号整数的字符串时，lrc_uint 函数
|ehx&R8Tl0// 返回无符号 integer 类型值。51Testing软件测试网FZh1\.[)^
unsigned int lrc_uint(const char* str);51Testing软件测试网 WQ7\ko1b
PU

// 输入表示无符号整数的字符串时，lrc_uint_by_ref51Testing软件测试网[/QFp'P bp
// 函数返回指向无符号 integer 类型值的
D
P
YZe8z;^JX8k0// 指针。
[5y C;q xO/Y0unsigned int* lrc_uint_by_ref(const char* str);51Testing软件测试网Q/kF&d`%U&YB!glSM

5RT_I$U&O4r[0// lrc_save_uint 函数将无符号 integer 值51Testing软件测试网us&]GT5pjd0K
// 保存在指定变量 name 下的字符串中，以便
$x:r'D bsE"]7@0// 您将其用于参数化。VuGen 将此函数生
r"~ I${YE*yK0// 成为注释掉的调用。如果要将此值用作
c+e"qg#B"\0// 参数，可以更改 name 参数并取消调用的51Testing软件测试网WbV_ I%PaN}
u0J
// 注释。
6Ob7O_#rUw0int lrc_save_uint(const char* name, unsigned int val);51Testing软件测试网`$HV2ONl
J1i*v

// lrc_save_uint_by_ref 函数将
(N]0^8o#V'yf V+}0// 无符号 integer 类型值保存在字符串中，51Testing软件测试网2u_C-@7gl*[*`
// 并将 val 设置为指向该字符串。VuGen 将此
Q2R~+Z$?`*G8L0// 函数生成为注释掉的调用。如果要将此值
Q7f
V\0xm9au h;T0// 用作参数，可以更改 name 并取消调用的注释。51Testing软件测试网_3l$C%m"j Rk
int lrc_save_uint_by_ref(const char* name, unsigned int *val);51Testing软件测试网R q_1R&}]5re

// 输入表示 long 类型的字符串时，lrc_long 函数51Testing软件测试网:vFxK yb#L
// 返回长整型值。
$FlD$z
l/ye7V0long lrc_long(const char* str);

:UqL{(Z&x;@0// 输入表示 long 类型的字符串时，lrc_long_by_ref 函数51Testing软件测试网C7h U9Q])mPN
// 返回指向长整型值的指针。51Testing软件测试网4ExJ;Q ~|3p
long* lrc_long_by_ref(const char* str);

,[4U#g E^$c6DUX@0// lrc_save_long 函数将长整型值
)@&X ~q-?p0// 保存在指定变量 name 下的字符串中，
9~*zjE]|r0// 以便您可以将其用于参数化。VuGen
p)oY!HDA\`!{)AE0// 将此函数生成为注释掉的调用。如果51Testing软件测试网3\UqF&J4f3hs4o+c
// 要将此值用作参数，可以更改 name51Testing软件测试网G!SOBo:a}
// 并取消调用的注释。
}.]O,i-L0int lrc_save_long(const char* name, long val);

// lrc_save_long_by_ref 函数将长整型值保存在字符串中，51Testing软件测试网3Qt P]3AQ
// 并将 val 设置为指向该字符串。51Testing软件测试网#Z%s^v:^;u'W;Q
int lrc_save_long_by_ref(const char* name, long *val);

$`rz.Y(mm:~JE0// 输入表示无符号 long 类型值的字符串时，
8aX(dx1lR;[%|0// lrc_ulong 函数返回无符号长整型值。
O.g7x*k'z$jy0unsigned long lrc_ulong(const char* str);

ZWODL0// 输入表示无符号 long 类型值的字符串时，
bM[-c9a0|0// lrc_ulong_by_ref 函数返回指向无符号长整型值
9j)?"HlOt0// 的指针。
NDI/t6d0unsigned long* lrc_ulong_by_ref(const char* str);

// lrc_save_ulong 函数将无符号51Testing软件测试网H!fm*G7v
// 长整型值保存在指定变量 name 下
k1SQ-g j+h\W0// 的字符串中，以便您可以将其用于参数化。
R"YF0q!d9v5f0// VuGen 将此函数生成为注释掉的调用。51Testing软件测试网/qikuZ9R
// 如果要将此值用作参数，可以更改 name
i3~e @&q dqB0// 并取消调用的注释。51Testing软件测试网0~$i7Jv^/B;v
int lrc_save_ulong(const char* name, unsigned long val);51Testing软件测试网 {+hM8ZR
z

// lrc_save_ulong_by_ref 函数将无符号长整型值保存为字符串，51Testing软件测试网3^Zx,h9^b3^_"N
// 并将 val 设置为指向该字符串。51Testing软件测试网 g%?3r%OW`
int lrc_save_ulong_by_ref(const char* name, unsigned long *val);51Testing软件测试网Q5m O,[:}5t'z/g'Bb

4?.~ Y*WLR;i tl$w0// 输入表示短整型值的字符串时，lrc_short 函数51Testing软件测试网x3t*}eW
// 返回短整型值。
_/V0P{7uz0short lrc_short(const char* str);51Testing软件测试网-`DM @M

// 输入表示短整型值的字符串时，lrc_short_by_ref 函数51Testing软件测试网+X'@Ua]k{
// 返回指向短整型值的51Testing软件测试网d4ks.m6l!G [P
// 指针。51Testing软件测试网[4TljI q(u!Fg
short* lrc_short_by_ref(const char* str);51Testing软件测试网:d6t$[8`a `7@

%@0ncF3n A0// lrc_save_short 函数将短整型值保存
's6j:y\ur1XE0// 在指定变量 name 下的字符串中，以便
@&E-\%]yFr5T0// 您可以将其用于参数化。VuGen 将此51Testing软件测试网~3rk4BV~d+}K
// 函数生成为注释掉的调用。如果要将此值51Testing软件测试网8Tqt2Q`
// 用作参数，可以更改 name 并取消调用的51Testing软件测试网 p ZO4Y\~"m*w7L
// 注释。51Testing软件测试网 v%M MD M${)`"Ch{m
int lrc_save_short(const char* name, short val);51Testing软件测试网Q8amv^ZY

Q`yEE\m[7B0// lrc_save_short_by_ref 函数将短整型值保存在字符串中，51Testing软件测试网A'Bj4w|(ng
// 并将 val 设置为指向该字符串。
]q%G'^s'CE0int lrc_save_short_by_ref(const char* name, short *val);

// 输入表示货币值的字符串时，lrc_currency 函
k ^J:IKAyj0// 数返回货币值。51Testing软件测试网
ct:H ArgLb2f
CY lrc_currency(const char* str);

K5\_ eN$GuG,p]d0// 输入表示货币值的字符串时，51Testing软件测试网(N/U5b%d/Xs t
w:]
// lrc_currency_by_ref 函数返回指向
BfYO bn+K5Am)pH0// 货币结构的指针。51Testing软件测试网#q uBIT8]db|
CY* lrc_currency_by_ref(const char* str);51Testing软件测试网m
P(};e p8bdQ.w\,@'P

// lrc_save_currency 函数将货币 (CY) 值
5Pi#iB(R
a2p1k B0// 保存在指定变量 name 下的字符串中，以便您51Testing软件测试网 tv(f D*Mq
// 可以将其用于参数化。VuGen 将此函数
@)r#G6~w'wAg3V0// 生成为注释掉的调用。如果要将此值51Testing软件测试网.VX:v&h I-dAo.JO
// 用作参数，可以更改 name 并取消调用的51Testing软件测试网 zseLcAV4?0@;Q
// 注释。
uv+Y|k-^
d0int lrc_save_currency(const char* name, CY val);51Testing软件测试网)F"KJVA{K

// lrc_save_currency_by_ref 函数将由“val”
H
r5X'X:A;Cn/X&Za!g0// 指针引用的货币值保存到字符串参数中。
?c!x.{6A4Sk H0int lrc_save_currency_by_ref(const char* name, CY *val);

`7GIV-FWfY!U0// 输入表示 date 类型值的字符串时，51Testing软件测试网xw.VIB1V
// lrc_date 函数返回 DATE 类型值。51Testing软件测试网;Y-~{go
DATE lrc_date(const char* str);

7y-}+p|$}R0// 输入表示 date 类型值的字符串时，lrc_date_by_ref 函数51Testing软件测试网,Tln1L^2]
// 返回指向 DATE 的指针。51Testing软件测试网Qdk0CDx3}
o
DATE* lrc_date_by_ref(const char* str);

// lrc_save_date 函数将 date 类型值保存51Testing软件测试网*y)P~o!q2UIe)W2g
// 为字符串。VuGen 将此函数生成为注释掉的调用。
u#IGqp}3Is0// 如果要将此值用作参数，可以更改 name 并取消51Testing软件测试网o[(q/a"\
// 调用的注释。
gW:_
VaK4p0int lrc_save_date(const char* name, DATE val);

// lrc_save_date_by_ref 函数将 date 类型值保存为字符串。
,V7~o XIUv7Ll~D0int lrc_save_date_by_ref(const char* name, DATE *val);51Testing软件测试网 Y_.yJh

// 输入包含“true”或“false”的字符串时，51Testing软件测试网-F*f)K-D,KcK
// lrc_bool 函数返回 Boolean 类型值。51Testing软件测试网@3_{d8JI_$k
VARIANT_BOOL lrc_bool(const char* str);51Testing软件测试网U(FC s)p}B

j#Usax/}0// 输入包含“true”或“false”的字符串时，
o9BL;{Wn.]/tu0// lrc_bool_by_ref 函数返回指向 Boolean51Testing软件测试网p\Z/z~D I.I
// 类型值的指针。51Testing软件测试网AJ fq&Ze X7p,tQK
VARIANT_BOOL* lrc_bool_by_ref(const char* str);

v%J!nP TGv0// lrc_save_bool 函数将 Boolean 类型值51Testing软件测试网 S3AX,K0ev5z_+B{eJ
// 保存为字符串参数。VuGen 将此函数生成为51Testing软件测试网 g~@,B"{}
// 注释掉的调用。如果要将此值用作参数，可以51Testing软件测试网'[rbK0fk9Ye:A
// 更改 name 并取消调用的注释。51Testing软件测试网3m.NuxbH`
int lrc_save_bool(const char* name, VARIANT_BOOL val);51Testing软件测试网Phq8i-o^#i

// lrc_save_bool_by_ref 函数将 Boolean 类型值51Testing软件测试网z2]U(E'N N
// 保存到字符串参数中。
c1@/m9A(C,vVM0int lrc_save_bool_by_ref(const char* name, VARIANT_BOOL *val);

// 输入表示无符号短整型值的字符串时，51Testing软件测试网#L
}J4j%V S
// lrc_ushort 函数返回无符号51Testing软件测试网yvC"l(I#j0p
// 短整型值。51Testing软件测试网Ds$H V Iyc]rM
unsigned short lrc_ushort(const char* str);51Testing软件测试网6?)sd
o|,G2d+kSQ#S#Y[

// 输入表示无符号短整型值的字符串时，51Testing软件测试网ST^ WzRqC
// lrc_ushort_by_ref 函数返回指向无符号短整型值
Q#]+E6Q.\'X1b0// 的指针。
.Y$u@%x%H/n/M#r0unsigned short* lrc_ushort_by_ref(const char* str);51Testing软件测试网3Eu(H pgn5Q*I5`

// lrc_save_ushort 函数将无符号51Testing软件测试网8}2iHv1n h^'y
// 短整型值保存在参数中。
W3~ Qn D[DT0int lrc_save_ushort(const char* name, unsigned short val);51Testing软件测试网W5FQ8W;q L

&b-j3RJ5W2no4\7C0// lrc_save_ushort_by_ref 函数将无符号短整型值51Testing软件测试网 _ Lfi2Q \
// 保存到参数中。
6z7C1YF ]#p7hz)E0int lrc_save_ushort_by_ref(const char* name, unsigned short *val);

// 输入包含浮点数的字符串时，51Testing软件测试网yL~*Mr^[!]
// lrc_float 函数返回浮点数。
jl i!J_P0I0float lrc_float(const char* str);51Testing软件测试网6~?|+_W{2E-tV

// 输入包含浮点数的字符串时，
zw%R\(](u.g5d0// lrc_float_by_ref 函数返回指向浮点数51Testing软件测试网t"RG7mT1BH
// 的指针。
P"n0x_cu
b$m0float* lrc_float_by_ref(const char* str);

// lrc_save_float 函数将浮点类型
!Umg+kPO g3G0// 浮点值保存在字符串参数中。VuGen 将此
!G
\#t9e\(}0// 函数生成为注释掉的调用。如果要使用51Testing软件测试网mCV6}npI
// 该参数，可以更改 name 并取消调用的51Testing软件测试网4[? S(XS];Z
// 注释。51Testing软件测试网HS@H3Andq
int lrc_save_float(const char* name, float val);

// lrc_save_float_by_ref 函数将浮点51Testing软件测试网R2Dx_#h.|F
// 类型浮点值保存在字符串参数中。51Testing软件测试网 fbaHt4O
int lrc_save_float_by_ref(const char* name, float *val);

// 输入包含 double 类型值的字符串时，51Testing软件测试网}.WSUB8j
// lrc_double 函数返回 double 类型值。51Testing软件测试网H"tdr5z-UR
double lrc_double(const char* str);

// 输入包含 double 类型值的字符串时，lrc_double_by_ref51Testing软件测试网A2j i`hSnX
// 函数返回指向 double 类型值的指针。
|\
u s4I3d'R0double* lrc_double_by_ref(const char* str);51Testing软件测试网0o9xWtN0A

// lrc_save_double 函数将双精度浮点
G J6`^(e*z$p6I0// 类型值保存在字符串参数中。VuGen 将
v"Cb|.bW.@!f0// 此函数生成为注释掉的调用。如果要将
Ob R"D L*`+r!J q0// 此值用作参数，可以更改 name 并取消51Testing软件测试网$b`U D
_[W M c
// 调用的注释。
YqtNb0int lrc_save_double(const char* name, double val);

// lrc_save_double_by_ref 函数将双精度浮点
"QS$d.{,o)]^0// 类型值保存在字符串参数中。51Testing软件测试网f/z.c}$Y [9K
int lrc_save_double_by_ref(const char* name, double *val);

W Kf*I7tY)@0// 输入包含 dword 类型值的字符串时，lrc_dword 函数51Testing软件测试网Zc6{7W`
PnV
// 返回双字类型值。
U:^ S\w,[4^H)O0DWORD lrc_dword(const char* str);51Testing软件测试网U3S,|}l6MVd

Kz~S Dq,e8qwI0// lrc_save_dword 函数将双字类型值
"JQ(BS"k0// 保存在字符串参数中。VuGen 将此函数51Testing软件测试网 A*G FffA_
// 生成为注释掉的调用。如果要将此值用作
u4{4? u4n0// 参数，可以更改 name 并取消调用的注释。51Testing软件测试网*Gi_na;XB
int lrc_save_dword(const char* name, DWORD val);51Testing软件测试网*X
z[wGb;x-^ F:^

// lrc_BSTR 函数将任何字符串转换为 BSTR。
q[a6u{ b*\"J0BSTR lrc_BSTR(const char* str);

z5rhN ^[0// lrc_save_BSTR 函数将 BSTR 值保存51Testing软件测试网j9pf,L6P-h
// 为字符串参数。VuGen 将此函数生成为
3N0G.sA2SyEQXG0// 注释掉的调用。如果要将此值用作参数，51Testing软件测试网s:mD|T2d U)A7b&_B
// 可以更改 name 并取消调用的注释。51Testing软件测试网0WVHf8Fq%d#|Qwl%t
int lrc_save_BSTR(const char* name, BSTR val);

// lrc_ascii_BSTR 函数将字符串
(n,i G$~S$ld
e0// 转换为 ascii_BSTR。51Testing软件测试网y+?Q3?-EJ
BSTR lrc_ascii_BSTR(const char* str);

// lrc_ascii_BSTR_by_ref 函数将字符串转换51Testing软件测试网z2jl3`w t9f*V U
// 为 ascii_BSTR，并返回指向该 BSTR 的指针。51Testing软件测试网j,d0yCM)P^7Y
BSTR* lrc_ascii_BSTR_by_ref(const char* str);

:l;Z4k*K+m6q0// 当不再使用 COM 对象时，
5{ E%A8xq]0// lrc_Release_Object 函数释放该对象。
2?0O][%q%cSa0// 释放对象后，对象的引用计数将减 151Testing软件测试网d.KCj Yso6z"\5M
// （例如，IUnknown_1 到 IUnknown_0）。51Testing软件测试网V+O*R%`b6UR"fhx
//51Testing软件测试网"U5r9o c+g
int lrc_Release_Object(const char* interface);

// lrc_save_ascii_BSTR 函数将 ascii BSTR 保存51Testing软件测试网t7K)ZBv g*{}
// 到字符串参数中。VuGen 将此函数生成为注释掉的调用。
]1|7N0zz$cJF;wnp0// 如果要将此值用作参数，可以更改 name 并取消调用的
/X/AL1Mr
f Y0// 注释。51Testing软件测试网Il*Qch
int lrc_save_ascii_BSTR(const char* name, BSTR val);

// lrc_save_ascii_BSTR_by_ref 函数将 ascii BSTR 保51Testing软件测试网(l%OYTAdI
// 存到字符串参数中。51Testing软件测试网-b6q4C.Q%WvG
int lrc_save_ascii_BSTR_by_ref(const char* name, BSTR *val);51Testing软件测试网 W*gy1Q7VCk

-G9]^ |TS9[0// lrc_save_VARIANT 函数将任何数据类型的值51Testing软件测试网&?X%QBS&F*`
// 保存到字符串参数中。51Testing软件测试网q;jg^]h.p~H
int lrc_save_VARIANT(const char* name, VARIANT val);51Testing软件测试网#THL(v/X4_+_:O

// lrc_save_variant_<Type-Name> 函数系列51Testing软件测试网;R(A%I7j:NGBN3x~
// 由 VuGen 生成，用于将指定的 <Type-Name>
;E J R U^;~K0// 变量保存为字符串参数。VuGen 将这些代码行51Testing软件测试网6L@Z!Isyg$SI4@
// 生成为注释掉的调用。如果要将此值用作参数，
wi4IEx-q*N0// 可以更改 name 并取消调用的51Testing软件测试网(|;|%O:M_eX
// 注释。
/fr#W)t%`0int lrc_save_variant_<Type-Name>(const char* name, VARIANT val);

// lrc_save_variant_short 将 short 变量类型值保存到字符串参数中。51Testing软件测试网J\"]_3Q3r8I
int lrc_save_variant_short(const char* name, VARIANT val);

// lrc_save_variant_ushort 将 short 变量类型值保存到字符串参数中。51Testing软件测试网%l,D z!|.pDz
int lrc_save_variant_ushort(const char* name, VARIANT val);

// lrc_save_variant_char 将 short 变量类型值保存到字符串参数中。
?$tV:xr a*_2e0int lrc_save_variant_char(const char* name, VARIANT val);

|sDkF$Jc*]0// lrc_save_variant_int 将 int 变量类型值保存到字符串参数中。
.J:o+q"o(g#CAd0int lrc_save_variant_int(const char* name, VARIANT val);51Testing软件测试网#{%L:mT$i`Wl

cQ IW?%C.^%{0// lrc_save_variant_uint 将无符号 integer 变量
{,R'[c3jr/g0// 类型值到字符串参数中。51Testing软件测试网'gR8]8VuK
int lrc_save_variant_uint(const char* name, VARIANT val);51Testing软件测试网\
g0?)@m&~I2v1XP

// lrc_save_variant_ulong 将无符号 long 变量51Testing软件测试网6W4zT.GKg
// 类型值保存到字符串参数中。
nupo
Gn6Z$ac7f2P0int lrc_save_variant_ulong(const char* name, VARIANT val);51Testing软件测试网*bahEr!M8X

// lrc_save_variant_BYTE 将 BYTE 变量类型值保存到字符串参数中。51Testing软件测试网Ioaw^ mv0g8klA(_
int lrc_save_variant_BYTE(const char* name, VARIANT val);

// lrc_save_variant_long 将 long 变量类型值保存到字符串参数中。51Testing软件测试网C?NCg1[
int lrc_save_variant_long(const char* name, VARIANT val);51Testing软件测试网Y/GI#b4A@

// lrc_save_variant_float 将 float 变量类型值保存到字符串参数中。51Testing软件测试网/`-rN%H/Vqj
int lrc_save_variant_float(const char* name, VARIANT val);

#^+s7N_U2[4Em0// lrc_save_variant_double 将 double 变量51Testing软件测试网R
mm:v2Y1HI9Y
// 类型值保存到字符串参数中。51Testing软件测试网?*fGs"f;@&}:P,f2P
int lrc_save_variant_double(const char* name, VARIANT val);51Testing软件测试网&un(K'gKvn

// lrc_save_variant_bool 将 boolean 变量类型值保存到字符串参数中。
#lguHn jB/Wy0int lrc_save_variant_bool(const char* name, VARIANT val);

// lrc_save_variant_scode 将 scode 变量类型值保存到字符串参数中。51Testing软件测试网j
QvZZwX
int lrc_save_variant_scode(const char* name, VARIANT val);51Testing软件测试网(H,j]%e'Ztc7nQ }

// lrc_save_variant_currency 将 currency 变量
y}gX#B3W zJJ0// 类型值保存到字符串参数中。
~#T/C4TWv1t(m0int lrc_save_variant_currency(const char* name, VARIANT val);

// lrc_save_variant_date 将 DATE 变量类型值保存到字符串参数中。51Testing软件测试网Lt8Fm%M5h D L-m
int lrc_save_variant_date(const char* name, VARIANT val);51Testing软件测试网7`3}
Qvp}{ N"@usw

D.Lp0Y5j0// lrc_save_variant_BSTR 将 BSTR 变量类型值保存到字符串参数中。
3i0^+r y7XFGa5c0int lrc_save_variant_BSTR(const char* name, VARIANT val);51Testing软件测试网Q5p0M EaT

4enI
_kX4\"O(`;Z0// lrc_save_variant_<Type-Name>_by_ref 函数

B0oI PB Q%y
a0// 系列由 VuGen 生成，以便将通过变量中的引用方式
,C6r^J~&| SS[#B0// 存储的、指定了 <Type-Name> 的变量保存为字符串
XN;n:Jp.y.G0// 参数。VuGen 将这些代码行生成为注释掉的调用。51Testing软件测试网.d`bJv
// 如果要将此值用作参数，可以更改 name 并取消调用的51Testing软件测试网a#A [`s"s
// 注释。51Testing软件测试网 J%J3d:u(}
//51Testing软件测试网t`j%D-A6ToDQI
int lrc_save_variant_<Type-Name>_by_ref(const char* name, VARIANT val);

// lrc_save_variant_short_by_ref 将通过变量中
fg/Gu%G2@
b!}0// 的引用方式存储的值保存为参数。51Testing软件测试网eh#pt8u+Gy"[1a3yS
int lrc_save_variant_short_by_ref(const char* name, VARIANT val);

// lrc_save_variant_ushort_by_ref 将51Testing软件测试网SNq9k1D!Y^$K1h7y
// 通过变量中的引用方式存储的值保存为参数。
4W?u7tp0int lrc_save_variant_ushort_by_ref(const char* name, VARIANT val);51Testing软件测试网$K6H-szn0z,r`r

k.`f'@Y0// lrc_save_variant_char_by_ref 将通过51Testing软件测试网}_(fj/v'^
// 变量中的引用方式存储的值保存为参数。51Testing软件测试网Z
U@(Noccy
int lrc_save_variant_char_by_ref(const char* name, VARIANT val);51Testing软件测试网P
T8yf)O3s9Y-Q3_

r:knif
L6C9R.n+pe0// lrc_save_variant_int_by_ref 将通过51Testing软件测试网zl8fJ3Cs
// 变量中的引用方式存储的值保存为参数。
!qSqK a)`0int lrc_save_variant_int_by_ref(const char* name, VARIANT val);

// lrc_save_variant_uint_by_ref 将通过
}8@,Z$n(\9a-U X |"Ff0// 变量中的引用方式存储的值保存为参数。
w lQ/_m0int lrc_save_variant_uint_by_ref(const char* name, VARIANT val);

// lrc_save_variant_ulong_by_ref 将通过
)z$gj
b g+X\ A0// 变量中的引用方式存储的值保存为参数。
$y"Ac"`7m E0int lrc_save_variant_ulong_by_ref(const char* name, VARIANT val);51Testing软件测试网R%Oa!f9`(K\:|9f

xIX:O{k0// lrc_save_variant_BYTE_by_ref 将通过51Testing软件测试网'n4wJh:[c.V#S9|S
// 变量中的引用方式存储的值保存为参数。
0?/o#W_)t0int lrc_save_variant_BYTE_by_ref(const char* name, VARIANT val);

j&t#lH+a]G0p0// lrc_save_variant_long_by_ref 将
*WQ5_-n&jc(D"c n0// 变量中的引用方式存储的值保存为参数。
p gC-R7R:P
S0int lrc_save_variant_long_by_ref(const char* name, VARIANT val);

[cbp(C:{&WkS0// lrc_save_variant_float_by_ref 将通过51Testing软件测试网9Kt8FU#e
q+A,\{2y
// 变量中的引用方式存储的值保存为参数。
)l,izw$YH0int lrc_save_variant_float_by_ref(const char* name, VARIANT val);51Testing软件测试网x)E"ubP5iK

// lrc_save_variant_double_by_ref 将通过
"j:P2H-x^0V5q}0// 变量中的引用方式存储的值保存为参数。51Testing软件测试网'Mg*j3f1pHFh.y0bZT
int lrc_save_variant_double_by_ref(const char* name, VARIANT val);51Testing软件测试网 tR_~hj

// lrc_save_variant_bool_by_ref 将通过51Testing软件测试网ra1Z7E&}'R7p6K
// 变量中的引用方式存储的值保存为参数。
/VWv/R V A0int lrc_save_variant_bool_by_ref(const char* name, VARIANT val);51Testing软件测试网%j1_H)D]1c\6U

// lrc_save_variant_scode_by_ref 将通过51Testing软件测试网1QZ#WdJ
// 变量中的引用方式存储的值保存为参数。51Testing软件测试网s,e"h$O2E(]E D&Y4}7K
int lrc_save_variant_scode_by_ref(const char* name, VARIANT val);

// lrc_save_variant_currency_by_ref 将通过51Testing软件测试网#suoE3R'h0Tj P$Z
// 变量中的引用方式存储的值保存为参数。
#MRowH-n0int lrc_save_variant_currency_by_ref(const char* name, VARIANT val);

b0]O?^;C"V0// lrc_save_variant_date_by_ref 将通过
:`UQ'B^oDLf0// 变量中的引用方式存储的值保存为参数。51Testing软件测试网*_+F:W5o l&D9t"I
int lrc_save_variant_date_by_ref(const char* name, VARIANT val);51Testing软件测试网@4qj5QC\

// lrc_save_variant_BSTR_by_ref 将通过51Testing软件测试网5?'EJA!}*|A
// 变量中的引用方式存储的值保存为参数。51Testing软件测试网%oovy U+|5s3LO
int lrc_save_variant_BSTR_by_ref(const char* name, VARIANT val);

d k
Di]3u)[)r!\0// lrc_BYTE 函数将字符串转换
!x(em9x(MN0// 为无符号字符（字节）数值。51Testing软件测试网:H3E_+G$_ r,J`
BYTE lrc_BYTE(const char* str);

-fO.SU%ELw2e0// lrc_BYTE_by_ref 函数将字符串转换
3~!R%K%U#rY$G/k4OR0// 为无符号字符（字节）数值，并返回指向该字节51Testing软件测试网&T#h
y'A.mDUMH
// 的指针。
8?%A6M.z&s Z2j$M0char * lrc_BYTE_by_ref(const char* str);51Testing软件测试网Cx+V0Z)V9?T@,{

// lrc_save_BYTE 函数将 byte 类型值保存为参数。
2OjA$uF@0// VuGen 将此函数生成为注释掉的调用。如果要将此值
3E)e5rwa.rM0// 用作参数，可以更改 param_name 并取消调用的51Testing软件测试网 B7Zr3K"J5M)kq
// 注释。51Testing软件测试网 rc_H)l&m+B
int lrc_save_BYTE(const char* param_name, BYTE val);51Testing软件测试网a,zmu5`H\`+}2j

C5H3K]4I5C2]m0// lrc_save_BYTE_by_ref 函数将 byte
+N7q`j*K!rS%z0// 类型值保存为参数。VuGen 将此函数生成为51Testing软件测试网PxT(m4hO8}/B[tx
// 注释掉的调用。如果要将此值用作参数，可以
7J W ~(a}!S0// 更改 param_name 并取消调用的注释。
pP.v^3V']g8f0int lrc_save_BYTE_by_ref(const char* param_name, BYTE *val);51Testing软件测试网{4IUN[p3Vb&};P

.o0y3J%fO2{`}L0// 输入表示超级整型值的字符串时，lrc_hyper 函51Testing软件测试网NW V.E/a(?
// 数返回超级（64 位）整型值。51Testing软件测试网
x*W;WA8@NE*S1WM
hyper lrc_hyper(const char* str);51Testing软件测试网pER%uAG k*X3_O

// 输入表示超级整型值的字符串时，
K A~^?^l0// lrc_hyper_by_ref 函数返回指向51Testing软件测试网"a*p8D f!{O _(C
// 超级（64 位）整型值的指针。
0h:Fdtq&khR-K F0hyper* lrc_hyper_by_ref(const char* str);

*`(R z
p eLC1{.H2_)p0// lrc_save_hyper 函数将 64 位超级51Testing软件测试网*xd4XT6ig
// 整型值保存在字符串参数中。VuGen 将
o"N!EK&oM0// 此函数生成为注释掉的调用。如果要将51Testing软件测试网/I^*@/c2vhsJ
// 此值用作参数，可以更改 name 并取消
(u5EW3y$j ~YZ0// 调用的注释。
0ak6? TMV2W0int lrc_save_hyper(const char* name, hyper val);

// lrc_save_hyper_by_ref 函数将 64 位
V@!xzY}ps&Z*Y0// 超级整型值保存到字符串参数中。
7M#`0Hml0L4gh0^0int lrc_save_hyper_by_ref(const char* name, hyper *val);

// 输入表示无符号超级整型值的字符串时，51Testing软件测试网:z{"x3s:r,Ro%HP
// lrc_uhyper 函数返回无符号超级51Testing软件测试网"s1D3O?pk*BK$u0X
// （64 位）整型值。
Cvf)d0BJi0uhyper lrc_uhyper(const char* str);51Testing软件测试网O7k x6]-O~LMs3I

:Sl/Yr0i{V:W0// 输入表示无符号超级整型值的字符串时，
6?3Qy9C
C)v%E4Ll0// lrc_uhyper_by_ref 函数返回指向51Testing软件测试网;^rVOw`i.e z`
// 无符号超级（64 位）整型值。
3X,Jn
f8CCZ0uhyper* lrc_uhyper_by_ref(const char* str);51Testing软件测试网(]6Bz.hXZ|*Z

FE ?8M^}-a2y0// lrc_save_uhyper 函数将无符号 64 位
a-o'{#XmA0m0// 超级整型值保存在字符串参数中。VuGen 将51Testing软件测试网,A$~/R[t
// 此函数生成为注释掉的调用。如果要将此值
u:K7W'y3fn|e6l6m1P0// 用作参数，可以更改 name 并取消调用的51Testing软件测试网`.a.\2`;h5B {y'X
// 注释。
h#\'M q$c"\-J9kFr0int lrc_save_uhyper(const char* name, uhyper val);

%E-zq~m)U|m6r9l0// lrc_save_uhyper_by_ref 函数将无符号51Testing软件测试网:FzD}][
// 64 位超级整型值保存到字符串参数中。VuGen
s v0L]&bBB0// 将此函数生成为注释掉的调用。如果要将此值51Testing软件测试网;k_U(Z,H(nj)y.O"S
// 用作参数，可以更改 name 并取消调用的
M.C RTAgn@0// 注释。51Testing软件测试网kk3~&mfn-w"B6n
int lrc_save_uhyper_by_ref(const char* name, uhyper *val);

"sg
|9Q f0// lrc_char 函数将包含 char 类型数值
$IC/F0P;|0// 的字符串转换为 char 变量。
_w@]"H$Q1w%Z0char lrc_char(const char* str);

// lrc_char_by_ref 函数将包含 char 类型数值的51Testing软件测试网%iGCM i7l-j
// 字符串转换为 char 变量。51Testing软件测试网&G2\-mo)wob3?~
char* lrc_char_by_ref(const char* str);51Testing软件测试网 @GP5F\(X7N i1v-A6g

// lrc_save_char 函数将 char类型51Testing软件测试网vG.DwL/_*Scf
// (0 - 127) 保存到字符串参数中。
5t.V6k f#S9I u0// VuGen 将此函数生成为注释掉的调用。51Testing软件测试网!^v6[M W]}&huL
// 如果要将此值用作参数，可以更改 name51Testing软件测试网&bnj0[Z8y
// 并取消调用的注释。
_Tl B'Rf0int lrc_save_char(const char* name, char val);51Testing软件测试网%d
Pf7]&l_
AJG

?8OKOv2h8g[0// lrc_save_char_by_ref 函数将 char 类型
1g7^1`3pL0// (0 - 127) 保存到字符串参数中。VuGen 将51Testing软件测试网Pi#o:a:D
// 此函数生成为注释掉的调用。如果要将此值
&wrp xR%R*k0// 用作参数，可以更改 name 并取消调用的51Testing软件测试网 D0V*t-S-`}C x
// 注释。51Testing软件测试网m'\ [ ]%x(E z|6u
int lrc_save_char_by_ref(const char* name, char *val);

5v8]?*I,jB ~0// lrc_variant_empty 函数返回空变量。
2CLl:d8?0VARIANT lrc_variant_empty();51Testing软件测试网4d%e H/rA_^k)rw6O

Z%\'N1Y2e0// lrc_variant_empty_by_variant 返回51Testing软件测试网J9}g)_gA!wV6x
// 包含对空变量引用的变量。51Testing软件测试网L#i|{O
VARIANT lrc_variant_empty_by_variant();51Testing软件测试网'FuQP0@

yw*vmQ D!t0// lrc_variant_null 函数返回 null 变量。
cur'[ l$Yq0VARIANT lrc_variant_null();

// lrc_variant_null_by_variant 返回
5?.`2qbM7`R6r%K6Y0// 包含对 null 变量引用的变量。51Testing软件测试网7Afu"fl;c/K7n%v
VARIANT lrc_variant_null_by_variant();

5^LE,~4{2fi U0// lrc_variant_short 函数将字符串转换为51Testing软件测试网3E,Y
K*D[HK~
// 短整型值，并在变量中将其返回。51Testing软件测试网,m0y3Av'fH7RHS
VARIANT lrc_variant_short(const char* str);51Testing软件测试网v2b^H3S'zLh9C1~

\HE@3k!@Pi P0// lrc_variant_short_by_variant 函数将字符串51Testing软件测试网2hx.MB"ND
// 转换为短整型值，并返回包含对某变量（其中包含
(G9l!g{ua }
k0// 该短整型值）引用的变量。
e3S ]j?oG0VARIANT lrc_variant_short_by_variant(const char* str);

// lrc_variant_ushort 函数将字符串转换为51Testing软件测试网@`} l%N5A$~D6?
// 无符号短整型值，并在变量中将其返回。51Testing软件测试网5o@|;u2j)F5e
VARIANT lrc_variant_ushort(const char* str);

// lrc_variant_char 函数将字符串转换为51Testing软件测试网ysEfyiy/~5?Y
// char 类型值，并在变量中将其返回。51Testing软件测试网X4T*n\3N c7ZlbN
VARIANT lrc_variant_char(const char* str);

// lrc_variant_int 函数将字符串转换为整型51Testing软件测试网#f%u }|nX-@v+MM6@
// 值，并在变量中将其返回。
*_oj8_gn"h
S2z0VARIANT lrc_variant_int(const char* str);

// lrc_variant_uint 函数将字符串转换为
F5gmL6V @0// 无符号整型值，并将其存储在变量中返回。51Testing软件测试网)la!f(b u?NeB^6Y
VARIANT lrc_variant_uint(const char* str);

E$gY4V5Lg0// lrc_variant_ulong 函数将字符串转换为51Testing软件测试网B;m2wqWEB7Z
// 无符号长整型值，并将其存储在变量中返回。51Testing软件测试网$jR[zQ
VARIANT lrc_variant_ulong(const char* str);

// lrc_variant_BYTE 函数将字符串转换为
)V*X @i/nK`.I0// 无符号 char (byte) 类型值并存储于变量中。
$gF+g*z8\0VARIANT lrc_variant_BYTE(const char* str);

// lrc_variant_BYTE_by_variant 函数将字符串
k\6n9]&j$m s"r0// 转换为无符号 char (byte) 类型值，并返回包含51Testing软件测试网,n9\lo`/}9s)X&\!^$T
// 对某变量（包含该 byte）引用的变量。51Testing软件测试网)^{bm`|}.V gW
VARIANT lrc_variant_BYTE_by_variant(const char* str);

// lrc_variant_long 函数将字符串51Testing软件测试网%c1{%@DJ-i5A}
// 转换为存储于变量中的长整型值。
z#~6T/Vl&bc0VARIANT lrc_variant_long(const char* str);51Testing软件测试网[BC*]Go+\

~!b{/D0d;?-VC;m0// lrc_variant_long_by_variant 函数将

ft6Q2RN8s;w0// 字符串转换为存储于变量中的长整型值，并且51Testing软件测试网9`F$_mZe
// 返回包含对某变量（其中包含该长整型值）51Testing软件测试网Be!p)z:?NO9`\
// 引用的变量。
V@ vg]'quC MQ0VARIANT lrc_variant_long_by_variant(const char* str);51Testing软件测试网+n;`3^mD3n

// lrc_variant_float 函数将字符串转换为
{l'uy eW0// 存储于变量中的浮点类型值。51Testing软件测试网'ThIdZ
VARIANT lrc_variant_float(const char* str);

// lrc_variant_float_by_variant 函数将51Testing软件测试网8y^8FV~nku
// 字符串转换为浮点类型值，并且返回包含对某
wtK$w&Z5M \PU0// 变量（其中包含该值）引用的变量。
UJ @:{*k0VARIANT lrc_variant_float_by_variant(const char* str);51Testing软件测试网0qt;Z%E(r4k8~x4HC ]

// lrc_variant_double 函数将字符串转换为51Testing软件测试网+d%oAa U\ a,|BD]
// 存储于变量中的双精度型浮点值。51Testing软件测试网7mmg:H3VN8o
VARIANT lrc_variant_double(const char* str);51Testing软件测试网.lFJ\O+~h

pV p+m/F:j&R0// lrc_variant_double_by_variant 函数将51Testing软件测试网]Y"{cr$mE2Pk
// 字符串转换为双精度型值，并且返回包含对某变量51Testing软件测试网-Xc(LxTK?7w
// （其中包含该值）引用的变量。51Testing软件测试网 ad)Y(~ x8I.Ig^
VARIANT lrc_variant_double_by_variant(const char* str);51Testing软件测试网H"a$PKj2} n9VX

// lrc_variant_bool 函数将包含“true”或“false”
mQ!c+XY5f0// 的字符串转换为存储于变量中的 Boolean 类型值。51Testing软件测试网R@,s}%\;We
VARIANT lrc_variant_bool(const char* str);51Testing软件测试网*sXPka\Y\"{b

// lrc_variant_bool_by_variant 函数将
R6I2ucQ-y8C0// 包含“true”或“false”的字符串转换为51Testing软件测试网
hp)TfD3H!k8dh
// Boolean 值，并且返回包含对某变量（其中
W3ELQ
^'t{0// 包含该值）引用的变量。
&VJBF~L1MI0VARIANT lrc_variant_bool_by_variant(const char* str);51Testing软件测试网4gKmJ,`6M

// lrc_variant_scode 函数将包含系统错误代码值的。51Testing软件测试网mv)W1K6S]lFC
// 字符串转换为存储于变量中的错误代码51Testing软件测试网XF!fV$D3Z#KpOD
VARIANT lrc_variant_scode(const char* errcode);51Testing软件测试网b;S8e)_L1m%L
l

RP(r&I5^(F]]x0// lrc_variant_scode_by_variant 函数将51Testing软件测试网 Q q-yU RXAc
// 包含系统错误代码值的字符串转换为错误代码，51Testing软件测试网B&L#P$`OyB8a(j"eEl
// 并且返回包含对某变量（其中包含该值）引用
u,x.wNP%~
X0// 的变量。51Testing软件测试网G%DEWV\XS
VARIANT lrc_variant_scode_by_variant(const char* errcode);

// lrc_variant_currency 函数将包含货币值
!klu#] sDLD0// 的字符串转换为存储于变量中的货币值。
2^CR4dZa GH&\^+e0VARIANT lrc_variant_currency(const char* str);51Testing软件测试网
z NAu5dd*h+P

S9g;|.Ck$bQ^1i$E3q[0// lrc_variant_currency_by_variant 函数
C [9Oz2mv
S5j\0// 将包含货币值的字符串转换为货币值，并且
+r
eK,iqVoF'`0w0// 返回包含对某变量（其中包含该值）引用的
} Oxg%\0// 变量。51Testing软件测试网&XSlZXdG1Ho
VARIANT lrc_variant_currency_by_variant(const char* str);51Testing软件测试网wh z,} a wp S {

// lrc_variant_date 函数将包含 date 类型值的
]xRy
G'fR0// 字符串转换为存储于变量中的 date 类型值。
B
Jhp,_[F0VARIANT lrc_variant_date(const char* str);51Testing软件测试网'}'P#jJ3} `7A.q{"{

// lrc_variant_date_by_variant 函数将51Testing软件测试网_P$SB-R/~PM"c
// 包含 date 类型值的字符串转换为 date 类型值，
X$s
Zu;c0// 并且返回包含对某变量（其中包含该 date 类型值）51Testing软件测试网c(V8Cz9^2T-\
}
// 引用的变量。
!zA[n"~}"|RA0VARIANT lrc_variant_date_by_variant(const char* str);

// lrc_variant_BSTR 函数将字符串转换为51Testing软件测试网b
JSQm$u(y
// 存储于变量中的 BSTR 类型值。51Testing软件测试网(cW/A3v#D$w o)@"I
VARIANT lrc_variant_BSTR(const char* str);51Testing软件测试网$H!K:A;I/D `

// lrc_variant_BSTR_by_variant 函数将字符串
2@G W K7pT!o0// 转换为 BSTR 值，并且返回包含对某变量（其中51Testing软件测试网0rUjf,xc4Q p
F/o BRS
// 包含该值）引用的变量。51Testing软件测试网 ?DW KZ9K6o(y wn
VARIANT lrc_variant_BSTR_by_variant(const char* str);

-r|)o5\&b)b0// lrc_variant_ascii_BSTR 函数将字符串分配给51Testing软件测试网 @S]%D|M,j
// 存储于变量中的 ASCII BSTR 值
u4V"f'q'S$m*N0VARIANT lrc_variant_ascii_BSTR(const char* str);

zgk*{ i;bI
K1G!p0// lrc_variant_CoObject 函数将 IUnknown 接口51Testing软件测试网.X/{a0k0Y*h"d+n J
// 指针分配给变量。
g Ffpbti
X0VARIANT lrc_variant_CoObject(IUnknown* pUnknown);

u(DB~"vK
\0// lrc_variant_CoObject_by_variant 函数将
2n8\~t$xS5Rd{#R/z0//  IUnknown 接口指针分配给变量，并且返回51Testing软件测试网|F:^Q*E+P!t!e
// 包含对某变量（其中包含 IUnknown 引用）
W}]V|1I0// 引用的变量。
LN)|xm0VARIANT lrc_variant_CoObject_by_variant(IUnknown* pUnknown);

S5W,l0p
Z cCjZ0// lrc_variant_DispObject 函数将51Testing软件测试网3Z'pi8t6m+Rs
//  IDispatch 接口指针分配给变量。51Testing软件测试网 oO0{o!?
W
VARIANT lrc_variant_DispObject(IDispatch* pDispatch);51Testing软件测试网 io[5q5K;z

// lrc_variant_DispObject_by_variant 函数51Testing软件测试网o&]N(R&p k(c
// 将 IDispatch 接口指针分配给变量，并且返回包含
"{1G#u!Y#sV \b0// 对某变量（其中包含 IDispatch 引用）引用的
5g6l3^2X9cea0// 变量。51Testing软件测试网hp.p mL
VARIANT lrc_variant_DispObject_by_variant(IDispatch* pDispatch);51Testing软件测试网2TPM$BUb4_\x

Bm"\c"ttX;A@0// lrc_variant_short_by_ref 函数将字符串
5Z!l!Z
LNe+g#i1d;PX#L0// 分配给通过变量中的引用方式存储的短整型值。51Testing软件测试网0bl"V7F#ELZ
VARIANT lrc_variant_short_by_ref(const char* str);51Testing软件测试网9? D[p\k-g#t\{_

// lrc_variant_ushort_by_ref 函数将字符串51Testing软件测试网av[KBd
// 分配给通过变量中的引用方式存储的无符号短整型值。
cmK(`b*~F0VARIANT lrc_variant_ushort_by_ref(const char* str);

// lrc_variant_char_by_ref 函数将字符串分配
n"Y m,g7WI0// 给通过变量中的引用方式存储的 char 类型值。

jN)@4H7xr&j XF0VARIANT lrc_variant_char_by_ref(const char* str);51Testing软件测试网-f{rtQ"l0w

// lrc_variant_int_by_ref 函数将字符串分配给51Testing软件测试网-N"j:I*S-e w/?9@A
// 通过变量中的引用方式存储的 integer 类型值。51Testing软件测试网C`a,u,Cd^%Q
VARIANT lrc_variant_int_by_ref(const char* str);

p7_){w2a)ytd0// lrc_variant_uint_by_ref 函数将字符串分配给
s-{*z(@kB-l q0// 通过变量中的引用方式存储的无符号 integer 类型值。51Testing软件测试网e5]"R8rkqw?
VARIANT lrc_variant_uint_by_ref(const char* str);51Testing软件测试网#D[/Tmc6Q{8cuE

+d/O
xj:Z,|/as0// lrc_variant_ulong_by_ref 函数将字符串分配给51Testing软件测试网G|*?*H2G8~
// 通过变量中的引用方式存储的长整型值。
Wz&f(u.C5H"e0VARIANT lrc_variant_ulong_by_ref(const char* str);

// lrc_variant_BYTE_by_ref 函数将字符串分配给51Testing软件测试网ULYd
m~j
// 通过变量中的引用方式存储的 char (byte) 类型值。
5^Zx:?`?,\[0VARIANT lrc_variant_BYTE_by_ref(const char* str);51Testing软件测试网\`b1gz3W

o1R9^yY BG2X+K0// lrc_variant_long_by_ref 函数将字符串分配给51Testing软件测试网enD$BM
// 通过变量中的引用方式存储的长整型值。
5a+p[1~.}5X0VARIANT lrc_variant_long_by_ref(const char* str);

;R0c#L h~#W{@0// lrc_variant_float_by_ref 函数将字符串分配给
z pisnS`0// 通过变量中的引用方式存储的浮点型浮点值。51Testing软件测试网clb"r-hPI
VARIANT lrc_variant_float_by_ref(const char* str);51Testing软件测试网}1`}*?U+msVO4D

(? Y~&dYaz8t0// lrc_variant_double_by_ref 函数将字符串分配给
J?~]'d6^d` c2B,k0// 通过变量中的引用方式存储的双精度型值。51Testing软件测试网l9N%O0kT G7j
VARIANT lrc_variant_double_by_ref(const char* str);51Testing软件测试网/Z)GlrDPB%Up

6ba T5y {n/A0// lrc_variant_bool_by_ref 函数将包含“true”
.V&x)V$_1X-[GOM!}0// 或“false”的字符串分配给通过变量中的
z;QL/F2OMu5V4b0// 引用方式存储的 Boolean 类型值。51Testing软件测试网%Q\^.r!z
VARIANT lrc_variant_bool_by_ref(const char* str);

// lrc_variant_scode_by_ref 函数将包含51Testing软件测试网$r9dzT^&D C
// 系统错误代码值的字符串分配给通过变量中的
d*ALd6Q0// 引用方式存储的错误代码中。
?JY}!F;z2ztSv-T0VARIANT lrc_variant_scode_by_ref(const char* str);51Testing软件测试网,RJTd-n;\(Ae

// lrc_variant_currency_by_ref 函数将字符串
d |z@/FQ#Zk7~z0// 分配给通过变量中的引用方式存储的货币类型值。51Testing软件测试网)F,K$|AE#@
VARIANT lrc_variant_currency_by_ref(const char* str);

h ju.c2v*g0// lrc_variant_date_by_ref 函数将字符串51Testing软件测试网K-[&v0|^KO
// 分配给通过变量中的引用方式存储的 date 类型值。51Testing软件测试网I'wga\aL:x
VARIANT lrc_variant_date_by_ref(const char* str);51Testing软件测试网+[5wX${$}7Ye

f3`#d&{4cjO)Ub0// lrc_variant_BSTR_by_ref 函数将字符串分配给的
kR*L ?{,V2R,o0// 通过变量中引用方式存储的 BSTR 值。51Testing软件测试网!r-Es2h G%N
VARIANT lrc_variant_BSTR_by_ref(const char* str);

// lrc_variant_ascii_BSTR_by_ref 函数将字符串51Testing软件测试网@1h+o NGni7G
// 分配给通过变量中的引用方式存储的 ascii BSTR 值。
9M!?-|z['dOS6I0VARIANT lrc_variant_ascii_BSTR_by_ref(const char* str);51Testing软件测试网7enW:{`I#oEu

// lrc_variant_CoObject_by_ref 函数将指针
*?+Ko\?(iF]p0// 分配给变量中的 IUnknown 接口。51Testing软件测试网6rY9y]#~V6pL
VARIANT lrc_variant_CoObject_by_ref(IUnknown* pUnknown);

// lrc_variant_DispObject_by_ref 函数将指针
*O/U+U9es7f(lCk0// 转换为变量中的 IDispatch 接口。
uw5Zsa.p:iK? _0VARIANT lrc_variant_DispObject_by_ref(IDispatch* pDispatch);51Testing软件测试网T"c'l2\\mu,[JK

// lrc_variant_variant_by_ref 函数创建包含现有51Testing软件测试网/t.S#q;EGy
EJR
// 变量的新变量。
@5h(FB7J"h:BY_0VARIANT lrc_variant_variant_by_ref(VARIANT * pVar);51Testing软件测试网!f0gQ0rY\;@?

k/I'j1A}0// lrc_variant_from_variant_by_ref 函数从
.Jh!O} i/v#@
N0// 另一个变量引用中获取变量。51Testing软件测试网:@$lN`U
VARIANT lrc_variant_from_variant_by_ref(VARIANT var);

?-Sws0Q(k9P0// Create<n>D<Type-Name>Array 函数系列51Testing软件测试网x5RhX.^6{T S
// 创建由 Type-name 指定的类型的 n 维数组。51Testing软件测试网'm&sx0s;`
// 对于每一维，该调用必须指定 lower_bound51Testing软件测试网 l6OT(fw+hH3]N
// 和 upper_bound。
'Vn;S6Thv*a0<Type-Name> Array Create<n>D<Type-Name>Array(int lower_bound,int upper_bound, int lower_bound, int upper_bound...);51Testing软件测试网i[l^Ep7S7T

P7|
rC"Er E0// Destroy<Type-Name>Array 函数系列销毁
9fvCoJ9a6vpl)a0// 由 Type-name 指定的类型的数组。对于在
xE!JG/l/~q9Q9NH0// 脚本中（而非由 VuGen）创建的数组，可以使用51Testing软件测试网!@Kr1HM7};t1g!P
// 它们恢复内存。51Testing软件测试网Y q0j a2\U
void Destroy<Type-Name>Array(<Type-Name>Array Array);

// DestroyBoolArray 释放由数组占用的内存。
j aW_+X0// 该函数用于恢复由脚本为数组分配的内存。
+g.`9NA\qwcxZ0void DestroyBoolArray(BoolArray Array);

t#XoG lm*rVx0// DestroyBstrArray 释放由数组占用的内存。51Testing软件测试网:qP nH0d,y``h:g
// 该函数用于恢复由脚本为数组分配的内存。
C+})~S0qGhs:p0void DestroyBstrArray(BstrArray Array);

\t!j!\%C ~5c3d$w0// DestroyByteArray 释放由数组占用的内存。51Testing软件测试网[2X-W$yZ C
// 该函数用于恢复由脚本为数组分配的内存。
P?{c1s!ZEV0void DestroyByteArray(ByteArray Array);51Testing软件测试网#V#[vQc;b}T

?'ZZ%q(`(`]0// DestroyCharArray 释放由数组占用的内存。
#W-ez mV'bo0// 该函数用于恢复由脚本为数组分配的内存。
"{;I#~F { K0void DestroyCharArray(CharArray Array);

c'sk8M]%eW0// DestroyCoObjectArray 释放由数组占用的内存。51Testing软件测试网9NTMx?.|
// 该函数用于恢复由脚本为数组分配的内存。51Testing软件测试网Dl\6@6L Q~`0{cx J%o
void DestroyCoObjectArray(CoObjectArray Array);

// DestroyCurrencyArray 释放由数组占用的内存。于
P#Y6uj V-C Q0// 该函数用恢复由脚本为数组分配的内存。51Testing软件测试网i&K0sn3aD
void DestroyCurrencyArray(CurrencyArray Array);

_o8?0Y
B;JR8{v+X o0// DestroyDateArray 释放由数组占用的内存。51Testing软件测试网1nx;ez#o0Y;d9u7o
// 该函数用于恢复由脚本为数组分配的内存。51Testing软件测试网SX$H$y1K*XP&c-E-?!{t8@
void DestroyDateArray(CurrencyArray Array);51Testing软件测试网}\&s1^W8B

6Z(wYK.K$LZS;r0// DestroyDispObjectArray 释放由数组占用的内存。51Testing软件测试网9OKV)m$N%WTG
// 该函数用于恢复由脚本为数组分配的内存。
9S,zX^6w{Z0void DestroyDispObjectArray(DispObjectArray Array);51Testing软件测试网"|8vG)Nf;uT;Tx%d

4qa-F6\&\(FUA.S+TQ0// DestroyDoubleArray 释放由数组占用的内存。
]c9y|0P/SV0// 该函数用于恢复由脚本为数组分配的内存。51Testing软件测试网E`y4]1f8N)GA#Q
void DestroyDoubleArray(DoubleArray Array);51Testing软件测试网"Ue-b a!P.z&l
V7e

PYl0^g8v6q0// DestroyErrorArray 释放由数组占用的内存。
*oeZ;|%a6kN0// 该函数用于恢复由脚本为数组分配的内存。51Testing软件测试网UN+Kxg G+OTv
void DestroyErrorArray(ErrorArray Array);

// DestroyFloatArray 释放由数组占用的内存。51Testing软件测试网TF4U:a8kc IC
// 该函数用于恢复由脚本为数组分配的内存。51Testing软件测试网 Cw-Z;i!U$Q/S
void DestroyFloatArray(FloatArray Array);51Testing软件测试网6P0Uk [(@!{z3R

i4Q/p&]5TtlB&G0// DestroyIntArray 释放由数组占用的内存。51Testing软件测试网&Y6f!`"L9Ly7hH
// 该函数用于恢复由脚本为数组分配的内存。51Testing软件测试网|#A^h.Z#U^@8x
void DestroyIntArray(IntArray Array);51Testing软件测试网8KcV9G)k+](|i

// DestroyLongArray 释放由数组占用的内存。
*m hb#| |T~*_0// 该函数用于恢复由脚本为数组分配的内存。
aE!E6B~0void DestroyLongArray(LongArray Array);

// DestroyShortArray 释放由数组占用的内存。51Testing软件测试网qQ3?n,L3Q fW
// 该函数用于恢复由脚本为数组分配的内存。
6D E4n RQ3h` ea5e}2O/{0void DestroyShortArray(ShortArray Array);51Testing软件测试网]$QPp;f VD2P

// DestroyUIntArray 释放由数组占用的内存。51Testing软件测试网.e2^ f wA/tB {
// 该函数用于恢复由脚本为数组分配的内存。51Testing软件测试网0z | P1l)l
void DestroyUIntArray(UIntArray Array);

// DestroyULongArray 释放由数组占用的内存。51Testing软件测试网y(QXf8n%EBo4l
uy
// 该函数用于恢复由脚本为数组分配的内存。51Testing软件测试网6A B9u%j}S7BukP$`s-V
void DestroyULongArray(ULongArray Array);

// DestroyUShortArray 释放由数组占用的内存。51Testing软件测试网n'?a3~8b t4m;q-_(l
// 该函数用于恢复由脚本为数组分配的内存。
#k ?r5H b*k8p8v+I o N0void DestroyUShortArray(UShortArray Array);51Testing软件测试网_6n#G6e'U o;D;c7A

N.sc%w5Y3J9|T0// DestroyVariantArray 释放由数组占用的内存。51Testing软件测试网KFK5],p)c,W
// 该函数用于恢复由脚本为数组分配的内存。
%N\5yW`j/vyQ0void DestroyVariantArray(VariantArray Array);51Testing软件测试网AilsYzJA

// GetBufferFrom<n>DByteArray 函数系列从 n 维
DE3Rm}0// byte 类型数组的最后一维中提取缓冲区。此函数51Testing软件测试网8UmE @inO8M:|B
// 的返回值是一个指向 byte 类型的缓冲区的指针。
C)A3U7?7Yy Z0// 缓冲区的大小返回到 *plinesize 所指定的51Testing软件测试网 Y;C7pm"z0}{+ZW
// 地址中。
%c$VR1MZ%k0char * GetBufferFrom<n>DByteArray(ByteArray Array, int ind1...indn-1, size_t *pLineSize);

{ D*D3b)[0d0// Fill<n>DByteArray 函数系列将 n 维 byte 数组51Testing软件测试网L p/vi%`o
// 的最后一维中填充缓冲区的内容。51Testing软件测试网;b1VGbCoyO9}
char * Fill<n>DByteArray(ByteArray Array, int ind1...indn-1, const char* buffer, size_t buff_size);51Testing软件测试网$g)z X e:e(P

nH\:UY:n0// lrc_variant_<Type-Name>Array 函数系列将在
$l,[
IxtN"Ib0// Type-Name 中指定的类型的数组分配给变量。51Testing软件测试网`1eP3ExG K
VARIANT lrc_variant_<Type-Name>Array(<Type-Name>Array array);

// lrc_variant_BoolArray 将数组分配给变量。51Testing软件测试网o(Wa$G#l1f{w`%r
VARIANT lrc_variant_BoolArray(BoolArray array);51Testing软件测试网jY4cJ-OVT

+?WzH2i"sY/T,i0// lrc_variant_BstrArray 将数组分配给变量。51Testing软件测试网r9_Uw
R\_;c
VARIANT lrc_variant_BstrArray(BstrArray array);51Testing软件测试网ikOL.Kk

// lrc_variant_ByteArray 将数组分配给变量。
q)m(\1TQ-V"?0VARIANT lrc_variant_ByteArray(ByteArray array);51Testing软件测试网-DH"h#s [Q+h

// lrc_variant_CharArray 将数组分配给变量。
9m_4~,T0w
l vX0VARIANT lrc_variant_CharArray(CharArray array);

// lrc_variant_CoObjectArray 将数组分配给变量。
1`8PH"c7tN'o0VARIANT lrc_variant_CoObjectArray(CoObjectArray array);

// lrc_variant_CurrencyArray 将数组分配给变量。51Testing软件测试网dX5p&? J
VARIANT lrc_variant_CurrencyArray(CurrencyArray array);

.X`s)K^~q0g.^0// lrc_variant_DateArray 将数组分配给变量。
E3aYK%kT#Uo0VARIANT lrc_variant_DateArray(DateArray array);51Testing软件测试网1VTjH2W [ {

// lrc_variant_DispObjectArray 将数组分配给变量。
$wk7VV@H K/AlqQ0VARIANT lrc_variant_DispObjectArray(DispObjectArray array);

// lrc_variant_DoubleArray 将数组分配给变量。51Testing软件测试网+C*zx7a$Vj#p5s4]
VARIANT lrc_variant_DoubleArray(DoubleArray array);51Testing软件测试网{y ? []M*Jj

// lrc_variant_ErrorArray 将数组分配给变量。51Testing软件测试网!w$m BO5f[+E/k4C*gk
VARIANT lrc_variant_ErrorArray(ErrorArray array);

// lrc_variant_FloatArray 将数组分配给变量。
@p o*t4i|0VARIANT lrc_variant_FloatArray(FloatArray array);51Testing软件测试网-e8f?+NLmg4Y2T

// lrc_variant_IntArray 将数组分配给变量。51Testing软件测试网+`A
T}7u
VARIANT lrc_variant_IntArray(IntArray array);51Testing软件测试网"^jbxV7g

%M5c9L
V0s `*R0// lrc_variant_LongArray 将数组分配给变量。
-O-b7hlH q k2PG b6X n0VARIANT lrc_variant_LongArray(LongArray array);

// lrc_variant_ShortArray 将数组分配给变量。51Testing软件测试网kLz#G(rb']Qj9r
VARIANT lrc_variant_ShortArray(ShortArray array);

// lrc_variant_UintArray 将数组分配给变量。
/A ?I$X"I\+d0yV8P!a0VARIANT lrc_variant_UintArray(UintArray array);

// lrc_variant_UlongArray 将数组分配给变量。
!|d/yq{v0Q0VARIANT lrc_variant_UlongArray(UlongArray array);

// lrc_variant_UshortArray 将数组分配给变量。51Testing软件测试网e@']u`p
^v
VARIANT lrc_variant_UshortArray(UshortArray array);

D(s6[-[@ }ljY0// lrc_variant_VariantArray 将数组分配给变量。51Testing软件测试网]*RZ;v
s r,r7o
VARIANT lrc_variant_VariantArray(VariantArray array);

// lrc_variant_<Type-Name>Array_by_ref 函数系列
e|9`ss0// 返回对由 Type-name 指定的类型的数组的引用。返回类型
~d:OB3\A;C0// 为变量。51Testing软件测试网yG(Bv~q~ eE
VARIANT lrc_variant_<Type-Name>Array_by_ref( <Type-Name>Array array );51Testing软件测试网*n+Nqd/eK(~

6k(])RcR!d0// lrc_variant_BoolArray_by_ref 返回对数组的引用
g:\m-aQq$S0VARIANT lrc_variant_BoolArray_by_ref(BoolArray array);51Testing软件测试网`~ H}2\Kp

// lrc_variant_BstrArray_by_ref 返回对数组的引用
7Y9]v(y,u.R0VARIANT lrc_variant_BstrArray_by_ref(BstrArray array);

9KNF3Xr(O0// lrc_variant_ByteArray_by_ref 返回对数组的引用51Testing软件测试网3B` C]-pA6Wk||
VARIANT lrc_variant_ByteArray_by_ref(ByteArray array);51Testing软件测试网 n
o
j.b3c$_q ]Ky-m

fZ8h#L:z*p8L0// lrc_variant_CharArray_by_ref 返回对数组的引用
K;f;K(y|6s;g9Q0VARIANT lrc_variant_CharArray_by_ref(CharArray array);51Testing软件测试网 eX`7x \p%x|

&Th:}4HRb0// lrc_variant_CoObjectArray_by_ref 返回对数组的引用51Testing软件测试网3w3P4V7YO4?h
VARIANT lrc_variant_CoObjectArray_by_ref(CoObjectArray array);51Testing软件测试网)\t)@ds-X4Yj

// lrc_variant_CurrencyArray_by_ref 返回对数组的引用
8~"^DPQNS0VARIANT lrc_variant_CurrencyArray_by_ref(CurrencyArray array);51Testing软件测试网/D(m^
`L ?'}4bx@4{

!y m8f%`S8Nu&Z0// lrc_variant_DateArray_by_ref 返回对数组的引用51Testing软件测试网 S&q)W a(L,G3P6_c
VARIANT lrc_variant_DateArray_by_ref(DateArray array);51Testing软件测试网Sr _K#A;ln ~

1DQ0_Xcu0// lrc_variant_DispObjectArray_by_ref 返回对数组的引用51Testing软件测试网'd4yH5c f6jMR$xv
VARIANT lrc_variant_DispObjectArray_by_ref(DispObjectArray array);

]I.Z t6X6Z2l+w0// lrc_variant_DoubleArray_by_ref 返回对数组的引用
gGU.``m0VARIANT lrc_variant_DoubleArray_by_ref(DoubleArray array);51Testing软件测试网.INh*uqcW

N,O*w:z Z7I{4_'YP[`Fl0// lrc_variant_ErrorArray_by_ref 返回对数组的引用
|,DS5m&Xy0VARIANT lrc_variant_ErrorArray_by_ref(ErrorArray array);

// lrc_variant_FloatArray_by_ref 返回对数组的引用
^V#rUh9l8E0VARIANT lrc_variant_FloatArray_by_ref(FloatArray array);

// lrc_variant_IntArray_by_ref 返回对数组的引用51Testing软件测试网5o2L8z;Ni
VARIANT lrc_variant_IntArray_by_ref(IntArray array);51Testing软件测试网[n0V}U M8B:@

~eUf1t#O+DS0a0// lrc_variant_LongArray_by_ref 返回对数组的引用
(cgV{X-F)q0DS(c*Gs0VARIANT lrc_variant_LongArray_by_ref(LongArray array);51Testing软件测试网)y'E:pDB e"h_8N

7D}9g4JB*P[X(?5X P0// lrc_variant_ShortArray_by_ref 返回对数组的引用
$N_n6u ^~1[@(xgi0VARIANT lrc_variant_ShortArray_by_ref(ShortArray array);

9@+q&LAElg0// lrc_variant_UintArray_by_ref 返回对数组的引用51Testing软件测试网eAO.cg}ej mX
VARIANT lrc_variant_UintArray_by_ref(UintArray array);51Testing软件测试网 K&Iv@8X1e?U}&_

// lrc_variant_UlongArray_by_ref 返回对数组的引用51Testing软件测试网dvbX|MY kHAVg
VARIANT lrc_variant_UlongArray_by_ref(UlongArray array);51Testing软件测试网*f%_^%H:d$xH

*l8?a y1u.q0// lrc_variant_UshortArray_by_ref 返回对数组的引用
&{ zwh:D\0VARIANT lrc_variant_UshortArray_by_ref(UshortArray array);51Testing软件测试网
_2Nr"A![3ZP"PU

A _ X2t/Z FS1`0// lrc_variant_VariantArray_by_ref 返回对数组的引用51Testing软件测试网"f]ds&?:E_\\
VARIANT lrc_variant_VariantArray_by_ref(VariantArray array);

Vt0]!tX/e7i{'Q#w0// lrc_Get<Type-Name>ArrayFromVariant 函数系列从变量中
K/l1i w'}K0// 提取由 Type-name 指定的类型的数组。51Testing软件测试网8ra0C`BI Fx
<Type-Name> lrc_Get<Type-Name>ArrayFromVariant const VARIANT* var);

// lrc_GetBoolArrayFromVariant 从变量中提取数组。
n3b|*`*[z)wD0VARIANT lrc_GetBoolArrayFromVariant(const VARIANT* var);51Testing软件测试网r}(D}Uo^`v

// lrc_GetBstrArrayFromVariant 从变量中提取数组。
~$~ A]/F:NNu+MKx.Z0VARIANT lrc_GetBstrArrayFromVariant(const VARIANT* var);51Testing软件测试网gU~ \:K@[

// lrc_GetByteArrayFromVariant 从变量中提取数组。
h/]SF;I7\
qMY)~0VARIANT lrc_GetByteArrayFromVariant(const VARIANT* var);

e8m)p0Sr:Z8` k7V0// lrc_GetCharArrayFromVariant 从变量中提取数