LoadRunner CPC认证考试复习试题

x.w*v W!L
v156874LoadRunner CPC认证考试复习试题(2006年12月版本),部分答案将在以后公布. CPC考试在2006年12月之前是实验室上机考试,主要分为问答题,选择题和编程题,考试结果一个月之后揭晓,批卷在Mercury的亚太总部新加坡进行的.这里是部分的选择题. 另外,2007年据说将实行新的题型,改为跟SP考试同样的类型,所以题目难度可能有所降低.

1. How many default Widows: Apache counters are added?

a) 10 : 5

b) 11 : 9

c) 6 : 10

d) 9 : 4

e) 5 : 2

f) None of above

2. Can the list of default Windows monitors be changed?

a) No-this list is determined by Microsoft Corporation

b) Yes-modify the scenario .Irs file

c) No-only the domain administrator can modify it

d) Yes-modify a cfg file in LoadRunner’s installation directory

e) Yes-modify a dft file in LoadRunner’s \dat directory

f) All of the above

软件测试专业网站:51Testing软件测试网c.DB"V$O5[
3. For a host machine in a different domain, you try to monitor PerfMon on it and get an “access denied” message. What might resolve this problem?

a) Edit a cfy file in the LoadRunner installation directory to update permissions

b) Edit the registry on the host machine to update permissions by granting READ access toHKEY_LOCAL_MACHINE\Software\Microsoft\WindowsNT\CurrentVersion\Perflib

c) Ensure the host machine and the controller machine use the same version of WindowsNT

d) Run the netstat command from the host machine to update permissions

e) Run the net use command to update permissions

f) All of the above

9O[T9[{IG{1568744. If you run tracert and notice significant network delays while running the load test, depending on the network configuration, you could try the following to reduce net-work traffic:

a) Run PerMon and check network byte transfer rate on the controller machine

b) Have the network admin increase the physical packet size (MTU)for large data sets since fragments degrade performance

c) Initialize all vusers before loading them for the test

d) If the problem is the network, upgrade the NIC

e) Configure the controller to write run-time data to a shared network drive, rather than to the host machines

f) None of the above

+?0V M+M)P4V-Hx1568745. To monitor an Apache server:

a) You need the correct URL that reports server statistics

b) You need to monitor through port 80 to accurately measure the end user experience.

c) You can update the monitor defaults via a .cfg file in LoadRunner’s \monitors folder

d) You can update the defaults via a dft file in LoadRunner’s\dat directory

e) You can monitor Apache even if there is a proxy server between the controller and the Apache servers, after updating a LoadRunner .cfg file

f) All of above

7I;H C)d2R,]1568746. Choose the true answer(s) from the list below

a) You can change the agent’s working language from a list of 4 languages

b) Use path translation where controller and hosts map a different path to a shared drive where scrīpts are stored

c) You can select to not collate log files after a run

d) You can set a file transfer trace if you have problems transferring files

e) Temporary files ate saved during a run: LoadRunner agent files ate stored in Irr folders and controller files ate stored in brr folders

f) All temporary files are automatically deleted at the end of the run and cannot be automatically saved

软件测试专业网站:51Testing软件测试网(R_8n:jW:]
7. Which of the following is true when trouble-shooting the controller’s communication with load generators?

a) The controller always uses the host machine’s short name so all host machines must be in the same domain as the controller

b) To ensure the full machine name is used, modify a .ini file in LoadRunner’s \dat directory

c) An .exe file in LoadRunner’s \bin lets you check that tcp/ip is properly installed on a current machine since tcp/ip problems can prevent load testing

d) If the controller has multiple IPs, alias the controller’s name on all load generators via their. Hosts file

e) Path translation is only effective across different OS platforms

f) All of the above

2]Y,H8Q#Lu }1568748. When configuring online graphs per load test, you :

a) Can choose to display the x-axis with or without clock time

b) Can choose to let LR automatically pick the Y-axis or set s min max value for custom scaling

c) Can modify line colors, scaling and visibility of measurements on graphs

d) Can monitor multiple machine on one monitor graph

e) Cannot monitor multiple machines on multiple monitor graphs

f) All of above

,[O7ID imz/b^1568749. During a scenario run, the default storage location for vuser data is :

a) The controller’s temporary folder- this is configurable

b) The controller’s result folder- this is not configurable

c) The host’s installation folder-this is not configurable

d) The host’s temporary folder- this is configurable

e) The controller’s installation folder- this is configurable

f) None of above

软件测试专业网站:51Testing软件测试网\0XL0w+Sn:h/H_
10. New features in LR 7.6 include:

a) Wan emulator

b) Multi-protocol support

c) Remote global performance monitor

d) MS-Word report generator

e) EJB analysis – new views

f) Analysis data import wizard

g) All of the above

软件测试专业网站:51Testing软件测试网!} yL#AN
@ V7|[0u(C9T6M
11. Pick the top time transaction(s) for your 3 rd run :

a) Login

b) Logout

c) FlightSearch_roundTrip

d) FlightSelect_roundTrip

e) FlightPurchase_roundTrip

f) FlightSearch _oneWay

g) FlightSelect_ oneWay

h) FlightPurchase_oneWay

i) DeleteItinerary

j) ViewItineraryh_roundTrip

12. What must happen in order to generate analysis data :

a) Transactions must be used

b) Performance monitors must be used

c) User data points must be defined

d) Rendezvous functions must be enabled

e) Online graphs must be viewed

4z"QI#]6}f(Y L15687413. You can prevent excessive use of disk space for the analysis database by :

a) Verifying list separator registry options ate the same on your machine as on the database machine

b) Instructing LoadRunner to save in Access 2000 rather than Access 97

c) Storing small databases on a SQL server or MSDE machine

d) Storing large databases on a SQL server or MSDE machine

e) Clicking a button in the Options>database tab

软件测试专业网站:51Testing软件测试网F,P7h MO8a6B
14. If using a time range filter for stored scenario data:

a) The running vusers graph expands to suit

b) The processing time decreases

c) The db size increases to track what is ignored

d) The db size decreases

e) This behavīor will be globally applied

软件测试专业网站:51Testing软件测试网 lRK,}4v:xe}
15. When saving display options and filters for future reuse, available features include:

a) Automatically apply this template to a new session

b) Use automatic granularity

c) Generate the following automatic HTML report

d) Automatically save the session as

e) All of the above

软件测试专业网站:51Testing软件测试网C uD:@u7z
16. From recent versions of the analysis tool, you :

a) Cannot view the controller’s vuser groups information

b) Can view the controller’s build number

c) Can view the controller’s scheduling details

d) Can distinguish between summary and complete analysis data

e) All of above

d\UM H$p'DGd15687417. Which of the following customizations can you apply to a subset of graphs?

a) Can change the title font and text

b) Cannot change the background/foreground colors or add images unless exported

c) Can change the depth perception on the graph using an additional dimension

d) Cannot rotate or tilt

e) All of the above

,g"B,c0s/r%g15687418. To standardize a gragh is to

a) Focus on behavīor patterns

b) Cancel axtual vaues

c) Have y-axis values converge around zero

d) Plot standard deviation values

e) None of the above

%N Ra ] k8Us4l15687419. The Transactions per Second graph helps you to determine load on the system at any given moment

a) False

b) True

软件测试专业网站:51Testing软件测试网:cvY.H+Q8[b'y
20. The Response Time (under load) graph helps you create a gradual load

a) False

b) True

软件测试专业网站:51Testing软件测试网\JjJm
21. The graph helps you calculate the time to first buffer.

a) False

b) True

E\(~ ?)B15687422. If you have min and max acceptable transaction times defined, you can use the Distribution graph to determine if server performance is within an acceptable range.

a) False

b) True

软件测试专业网站:51Testing软件测试网"_6UWu3b)QdG\
23. The auto correlation options include:

a) Automatic

b) Correlate data based on X second intervals

c) Manual

d) Correlate data based on X minute intervals

e) None of the above

7ir
NF G.J|`m15687424. When tuning a system, web/web-app server metrics to check include:

a) Browser version

b) Physical memory

c) Load balancing algorithm

d) Images per page

e) CPU

软件测试专业网站:51Testing软件测试网N"O N8Y:^g!j
25. Two examples of common database server problems are:

a) Corrupt .dll files

b) Inefficient index design

c) Fragmented databases

d) Compacted data

e) Short transactions

软件测试专业网站:51Testing软件测试网kq2G"Jh9|bt6u
26. When making improvements to SSL web application performance, include these steps:

a) Cache the session identifiers from each transaction

b) Avoid excessive use of SSL and re-design pages that have low data sensitivity to not use SSL.

c) Use “keep-alive” enhancement features available with most web browsers

d) Change level of security according to level of data sensitivity

e) Use SSL accelerator appliances and cards

软件测试专业网站:51Testing软件测试网,ekO+{0~(G!g
27. Network bottlenecks are indicated during a test when you add considerable load but:

a) Sever-side components are barely affected

b) Outgoing replied are significantly delayed compared to incoming requests

c) Receive timeouts only

d) No idle servers available

e) All of above

3I7mz)ui.LE15687428. Load tests and subsequent data analysis are recommended:

a) During initial load testing of the test system to determine its final state

b) After tuning the system to ensure previous problems were fixed

c) During finial load testing of the system to prove new bottlenecks exist

d) When determining configuration changes to improve response times

e) When determining architectural changes to improve response times

软件测试专业网站:51Testing软件测试网/X jq/A@
29. Available performance reports include:

a) Detailed Summary

b) Transaction Performance by Vuser

c) Detail Transaction

d) Failed Transactions

e) All of above

1n2a-| LS0bBXd7J15687430. Available activity reports include:

a) Scenario Summary

b) Failed Transaction

c) Failed Vuser

d) Scenario Execution

e) All of above

软件测试专业网站:51Testing软件测试网|2}0RD-o A u{
31. Two prerequisites for merging graphs are:

a) Both graphs must be identical

b) The graph should have identical axes

c) Both graphs should be opened first

d) Both graphs should share one common axis

e) None of the above

$?U})R'P0K U At"@h15687432. Cross-result graphs can be use to:

a) Check 2 different result files(maximum)

b) Test software versions

c) Determine system capacity

d) Benchmark hardware

e) All of above

内存分配方式
-------------------------------------------------------------------------

内存分配方式有三种：
（1） 从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量static变量。
（2） 在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存 分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。
（3） 从堆上分配，亦称动态内存分配。程序在运行的时候用malloc或new申请任意多少的内存，程序员自己负责在何时用free或delete释放内存。动态内存的生存期由我们决定，使用非常灵活，但问题也最多。

常见的内存错误及其对策

-------------------------------------------------------------------------

发生内存错误是件非常麻烦的事情。编译器不能自动发现这些错误，通常是在程序运行时才能捕捉到。而这些错误大多没有明显的症状，时隐时现，增加了改错的难度。有时用户怒气冲冲地把你找来，程序却没有发生任何问题，你一走，错误又发作了。

常见的内存错误及其对策如下：

1>内存分配未成功，却使用了它。
------------------------------------------
编程新手常犯这种错误，因为他们没有意识到内存分配会不成功。常用解决办法是，在使用内存之前检 指针是否为NULL。如果指针p是函数的参数，那么在函数的入口处用assert(p!=NULL)进行检查。如果是用malloc或new来申请内存，应该用if(p==NULL) 或if(p=NULL)进行防错处理。

2>内存分配虽然成功，但是尚未初始化就引用它
------------------------------------------
犯这种错误主要有两个起因：一是没有初始化的观念；二是误以为内存的缺省初值全为零，导致引用初 错误（例如数组）。
内存的缺省初值究竟是什么并没有统一的标准，尽管有些时候为零值，我们宁可信其无不可信其有。所 以无论用何种方式创建数组，都别忘了赋初值，即便是赋零值也不可省略，不要嫌麻烦。

3>内存分配成功并且已经初始化，但操作越过了内存的边界。
------------------------------------------
例如在使用数组时经常发生下标"多1"或者"少1"的操作。特别是在for循环语句中，循环次数很容易搞错，导致数组操作越界。

4>忘记了释放内存，造成内存泄露。
------------------------------------------
含有这种错误的函数每被调用一次就丢失一块内存。刚开始时系统的内存充足，你看不到错误。终有一次程序突然死掉，系统出现提示：内存耗尽。动态内存的申请与释放必须配对，程序中malloc与free的使用次数一定要相同，否则肯定有错误（new/delete同理）。

5>释放了内存却继续使用它。
------------------------------------------
有三种情况：
（1）程序中的对象调用关系过于复杂，实在难以搞清楚某个对象究竟是否已经释放了内存，此时应该重新设计数据结构，从根本上解决对象管理的混乱局面。
（2）函数的return语句写错了，注意不要返回指向"栈内存"的"指针"或者"引用"，因为该内存在函数体结束时被自动销毁。
（3）使用free或delete释放了内存后，没有将指针设置为NULL。导致产生"野指针"。

【规则1】用malloc或new申请内存之后，应该立即检查指针值是否为NULL。防止使用指针值为NULL的内存。
【规则2】不要忘记为数组和动态内存赋初值。防止将未被初始化的内存作为右值使用。
【规则3】避免数组或指针的下标越界，特别要当心发生"多1"或者"少1"操作。
【规则4】动态内存的申请与释放必须配对，防止内存泄漏。
【规则5】用free或delete释放了内存之后，立即将指针设置为NULL，防止产生"野指针"。

-------------------------------------------------------------------------

指针与数组的对比
C++/C程序中，指针和数组在不少地方可以相互替换着用，让人产生一种错觉，以为两者是等价的。
    
数组
-------------
数组要么在静态存储区被创建（如全局数组），要么在栈上被创建。数组名对应着（而不是指向）一块内存，其地址与容量在生命期内保持不变，只有数组的内容可以改变。

指针
--------------
指针可以随时指向任意类型的内存块，它的特征是"可变"，所以我们常用指针来操作动态内存。指针远比数组灵活，但也更危险。

下面以字符串为例比较指针与数组的特性。

1.修改内容
------------------------------------------
示例1中，字符数组a的容量是6个字符，其内容为hello\0。a的内容可以改变，如a[0]= 'X'。
指针p指向常量字符串"world"（位于静态存储区，内容为world\0），常量字符串的内容是不可以被修改的。
从语法上看，编译器并不觉得语句p[0]= ‘X'有什么不妥，但是该语句企图修改常量字符串的内容而导致运行错误。

示例7-3-1 修改数组和指针的内容
   ------------------------------
   char a[] = "hello";
   a[0] = 'X';
   cout << a << endl;
   char *p = "world"; // 注意p指向常量字符串  
   p[0] = 'X'; // 编译器不能发现该错误cout << p << endl;
  

2.内容复制与比较
------------------------------------------
数组复制
--------
不能对数组名进行直接复制与比较。示例2中，若想把数组a的内容复制给数组b，不能用语句 b = a ，否则将产生编译错误。应该用标准库函数strcpy进行复制。同理，比较b和a的内容是否相同，不能用if(b==a) 来判断，应该用标准库函数strcmp进行比较。

指针复制
--------
语句p = a 并不能把a的内容复制指针p，而是把a的地址赋给了p。要想复制a的内容，可以先用库函数malloc为p申请一块容量为strlen(a)+1个字符的内存，再用strcpy进行字符串复制。同理，语句if(p==a) 比较的不是内容而是地址，应该用库函数strcmp来比较。

示例2 数组和指针的内容复制与比较
-----------------------------------
        // 数组...
char a[] = "hello";
char b[10];
strcpy(b, a); //不能用b = a;
if(strcmp(b, a) == 0) // 不能用 if (b == a)...
// 指针...
int len = strlen(a);
char *p = (char *)malloc(sizeof(char)*(len+1));  
strcpy(p,a); // 不要用 p = a;
if(strcmp(p, a) == 0) // 不要用 if (p == a)...

3 计算内存容量
------------------------------------------
数组
----
用运算符sizeof可以计算出数组的容量（字节数）。
示例3中，sizeof(a)的值是12（注意别忘了'\0'）。

指针
----
指针p指向a，但是sizeof(p)的值却是4。这是因为sizeof(p)得到的是一个指针变量的字节数，
相当于sizeof(char*)，而不是p所指的内存容量。

C++/C语言没有办法知道指针所指的内存容量，除非在申请内存时记住它。

注意
----
当数组作为函数的参数进行传递时，该数组自动退化为同类型的指针。
示例3中，不论数组a的容量是多少，sizeof(a)始终等于sizeof(char *)。
      
       示例3 计算数组和指针的内存容量
-----------------------------
        char a[] = "hello world";
char *p = a; cout<< sizeof(a) << endl;// 12字节
cout<< sizeof(p) << endl;// 4字节

示例3（b） 数组退化为指针
-----------------------------
void Func(char a[100])
{
cout<< sizeof(a) << endl;// 4字节而不是100字节
   }

4、指针参数是如何传递内存的？
------------------------------------------
如果函数的参数是一个指针，不要指望用该指针去申请动态内存。
示例4-1中，Test函数的语句GetMemory(str, 200)并没有使str获得期望的内存，str依旧是NULL，为什么？

示例4-1 试图用指针参数申请动态内存
----------------------------------
void GetMemory(char *p, int num)
{
p = (char *)malloc(sizeof(char) * num);
}
void Test(void)
{
char *str = NULL;
GetMemory(str, 100);// str 仍然为 NULL
strcpy(str, "hello"); // 运行错误
}

毛病出在函数GetMemory中。编译器总是要为函数的每个参数制作临时副本，
指针参数p的副本是 _p，编译器使 _p = p。如果函数体内的程序修改了_p的内容，
就导致参数p的内容作相应的修改。这就是指针可以用作输出参数的原因。
在本例中，_p申请了新的内存，只是把_p所指的内存地址改变了，但是p丝毫未变。
所以函数GetMemory并不能输出任何东西。
事实上，每执行一次GetMemory就会泄露一块内存，因为没有用free释放内存。

如果非得要用指针参数去申请内存，那么应该改用"指向指针的指针"，见示例4-2。

示例4-2用指向指针的指针申请动态内存
------------------------------------
void GetMemory2(char **p, int num)
{
*p = (char *)malloc(sizeof(char) * num);
}
void Test2(void)
{
char *str = NULL;
GetMemory2(&str, 100); // 注意参数是 &str，而不是str
strcpy(str, "hello");
cout<< str << endl;
free(str);
}

由于"指向指针的指针"这个概念不容易理解，我们可以用函数返回值来传递动态内存。
这种方法更加简单，见示例4-3。

示例4-3 用函数返回值来传递动态内存
-----------------------------------
char *GetMemory3(int num)
{
char *p = (char *)malloc(sizeof(char) * num);
return p;
}
void Test3(void)
{
char *str = NULL;
str = GetMemory3(100);
strcpy(str,"hello");
cout<< str << endl;
free(str);
}

用函数返回值来传递动态内存这种方法虽然好用，但是常常有人把return语句用错了。这里强调不要用return语句返回指向"栈内存"的指针，因为该内存在函数结束时自动消亡，见示例4-4。

示例4-4 return语句返回指向"栈内存"的指针
--------------------------------------------
char *GetString(void)
{
char p[] = "hello world";
return p;// 编译器将提出警告
}
void Test4(void)
{
char *str = NULL;str = GetString();// str 的内容是垃圾
cout<< str << endl;
}

用调试器逐步跟踪Test4，发现执行str = GetString语句后str不再是NULL指针，
但是str的内容不是"hello world"而是垃圾。

如果把示例4-4改写成示例4-5，会怎么样？

示例4-5 return语句返回常量字符串
-----------------------------------
char *GetString2(void)
{
char *p = "hello world";
return p;
}
void Test5(void)
{
char *str = NULL;
str = GetString2();
cout<< str << endl;
}

函数Test5运行虽然不会出错，但是函数GetString2的设计概念却是错误的。
因为GetString2内的"hello world"是常量字符串，位于静态存储区，它在程序生命期内恒定不变。
无论什么时候调用GetString2，它返回的始终是同一个"只读"的内存块。

5 free和delete把指针怎么啦？
------------------------------------------
别看free和delete的名字恶狠狠的（尤其是delete），
它们只是把指针所指的内存给释放掉，但并没有把指针本身干掉。
用调试器跟踪示例5，发现指针p被free以后其地址仍然不变（非NULL），
只是该地址对应的内存是垃圾，p成了"野指针"。
如果此时不把p设置为NULL，会让人误以为p是个合法的指针。
如果程序比较长，我们有时记不住p所指的内存是否已经被释放，
在继续使用p之前，通常会用语句if (p !=NULL)进行防错处理。
很遗憾，此时if语句起不到防错作用，因为即便p不是NULL指针，
它也不指向合法的内存块。

示例5 p成为野指针
--------------------
char *p = (char *) malloc(100);
strcpy(p, "hello");
free(p);        // p 所指的内存被释放，但是p所指的地址仍然不变 ...
if(p != NULL) // 没有起到防错作用
{      strcpy(p, "world"); // 出错
}

6 动态内存会被自动释放吗？
------------------------------------------
函数体内的局部变量在函数结束时自动消亡。很多人误以为示例6是正确的。
理由是p是局部的指针变量，它消亡的时候会让它所指的动态内存一起完蛋。这是错觉！

示例7-6 试图让动态内存自动释放
------------------------------
void Func(void)
{
char *p = (char *) malloc(100); // 动态内存会自动释放吗？
}

我们发现指针有一些"似是而非"的特征：
------------------------------------
（1）指针消亡了，并不表示它所指的内存会被自动释放。
（2）内存被释放了，并不表示指针会消亡或者成了NULL指针。
     这表明释放内存并不是一件可以草率对待的事。也许有人不服气，
     一定要找出可以草率行事的理由：
     如果程序终止了运行，一切指针都会消亡，动态内存会被操作系统回收。
     既然如此，在程序临终前，就可以不必释放内存、不必将指针设置为NULL了。
     终于可以偷懒而不会发生错误了吧？
想得美。如果别人把那段程序取出来用到其它地方怎么办？

7 杜绝"野指针"
------------------------------------------
"野指针"不是NULL指针，是指向"垃圾"内存的指针。
人们一般不会错用NULL指针，因为用if语句很容易判断。
但是"野指针"是很危险的，if语句对它不起作用。

"野指针"的成因主要有两种：

（1）指针变量没有被初始化。任何指针变量刚被创建时不会自动成为NULL指针，
它的缺省值是随机的，它会乱指一气。所以，指针变量在创建的同时应当被初始化，
要么将指针设置为NULL，要么让它指向合法的内存。例如
char *p = NULL;
char *str = (char *) malloc(100);

（2）指针p被free或者delete之后，没有置为NULL，让人误以为p是个合法的指针。参见7.5节。

（3）指针操作超越了变量的作用范围。这种情况让人防不胜防，示例程序如下：
class A
{
public:
void Func(void){ cout << "Func of class A" << endl;
}

void Test(void)
{
A *p;
{
A a;
p = &a; // 注意 a 的生命期
}
p->Func();// p是"野指针"
}

函数Test在执行语句p->Func()时，对象a已经消失，而p是指向a的，所以p就成了"野指针"。
但奇怪的是我运行这个程序时居然没有出错，这可能与编译器有关。

8 有了malloc/free为什么还要new/delete ？
------------------------------------------
malloc与free是C++/C语言的标准库函数，new/delete是C++的运算符。
它们都可用于申请动态内存和释放内存。

对于非内部数据类型的对象而言，光用maloc/free无法满足动态对象的要求。
对象在创建的同时要自动执行构造函数，对象在消亡之前要自动执行析构函数。
由于malloc/free是库函数而不是运算符，不在编译器控制权限之内，
不能够把执行构造函数和析构函数的任务强加于malloc/free。

因此C++语言需要一个能完成动态内存分配和初始化工作的运算符new，以及一个能完成清理与释放内存工作的运

算符delete。注意new/delete不是库函数。
我们先看一看malloc/free和new/delete如何实现对象的动态内存管理，见示例8。

示例8 用malloc/free和new/delete如何实现对象的动态内存管理
-------------------------------------------------------------
class Obj
{
public :
Obj(void){ cout << "Initialization" << endl; }
~Obj(void){cout << "Destroy" << endl; }
void Initialize(void){ cout << "Initialization" << endl; }
void    Destroy(void){ cout << "Destroy" << endl; }
};
void UseMallocFree(void)
{
Obj *a = (obj *)malloc(sizeof(obj)); // 申请动态内存
a->Initialize(); // 初始化
a->Destroy(); // 清除工作
free(a);// 释放内存
}
void UseNewDelete(void)
{
Obj *a = new Obj;// 申请动态内存并且初始化
delete a;// 清除并且释放内存
}

类Obj的函数Initialize模拟了构造函数的功能，函数Destroy模拟了析构函数的功能。
函数UseMallocFree中，由于malloc/free不能执行构造函数与析构函数，
必须调用成员函数Initialize和Destroy来完成初始化与清除工作。
函数UseNewDelete则简单得多。

所以我们不要企图用malloc/free来完成动态对象的内存管理，应该用new/delete。
由于内部数据类型的"对象"没有构造与析构的过程，对它们而言malloc/free和new/delete是等价的。

既然new/delete的功能完全覆盖了malloc/free，为什么C++不把malloc/free淘汰出局呢？
这是因为C++程序经常要调用C函数，而C程序只能用malloc/free管理动态内存。

如果用free释放"new创建的动态对象"，那么该对象因无法执行析构函数而可能导致程序出错。
如果用delete释放"malloc申请的动态内存"，理论上讲程序不会出错，但是该程序的可读性很差。
所以new/delete必须配对使用，malloc/free也一样。

9 内存耗尽怎么办？
------------------------------------------
如果在申请动态内存时找不到足够大的内存块malloc和new将返回NULL指针，宣告内存申请失败。
通常有三种方式处理"内存耗尽"问题。

（1）判断指针是否为NULL，如果是则马上用return语句终止本函数。例如：
void Func(void)
{
A *a = new A;
if(a == NULL)
{
   return;
}
...
}

（2）判断指针是否为NULL，如果是则马上用exit(1)终止整个程序的运行。例如：
void Func(void)
{
A *a = new A;
if(a == NULL)
{
   cout << "Memory Exhausted" << endl;
   exit(1);
}
...
}

（3）为new和malloc设置异常处理函数。

例如Visual C++可以用_set_new_hander函数为new设置用户自己定义的异常处理函数，
也可以让malloc享用与new相同的异常处理函数。详细内容请参考C++使用手册。

上述（1）（2）方式使用最普遍。如果一个函数内有多处需要申请动态内存，
那么方式（1）就显得力不从心（释放内存很麻烦），应该用方式（2）来处理。

很多人不忍心用exit(1)，问："不编写出错处理程序，让操作系统自己解决行不行？"
不行。如果发生"内存耗尽"这样的事情，一般说来应用程序已经无药可救。
如果不用exit(1) 把坏程序杀死，它可能会害死操作系统。
道理如同：如果不把歹徒击毙，歹徒在老死之前会犯下更多的罪。

有一个很重要的现象要告诉大家。对于32位以上的应用程序而言
，无论怎样使用malloc与new，几乎不可能导致"内存耗尽"。
我在Windows 98下用Visual C++编写了测试程序，见示例9。
这个程序会无休止地运行下去，根本不会终止。
因为32位操作系统支持"虚存"，内存用完了，自动用硬盘空间顶替。
我只听到硬盘嘎吱嘎吱地响，Window 98已经累得对键盘、鼠标毫无反应。

我可以得出这么一个结论：对于32位以上的应用程序，"内存耗尽"错误处理程序毫无用处。这下可把Unix和Windows程序员们乐坏了：反正错误处理程序不起作用，我就不写了，省了很多麻烦。

我不想误导读者，必须强调：不加错误处理将导致程序的质量很差，千万不可因小失大。

示例9试图耗尽操作系统的内存
void main(void)
{
   float *p = NULL;
   while(TRUE)
   {
    p = new float[1000000];
    cout << "eat memory" << endl;
    if(p==NULL) exit(1);
   }
}

10 malloc/free 的使用要点
------------------------------------------
函数malloc的原型如下：
void * malloc(size_t size);
用malloc申请一块长度为length的整数类型的内存，程序如下：
int *p = (int *) malloc(sizeof(int) * length);
我们应当把注意力集中在两个要素上："类型转换"和"sizeof"。
malloc返回值的类型是void *，所以在调用malloc时要显式地进行类型转换，
将void * 转换成所需要的指针类型。
malloc函数本身并不识别要申请的内存是什么类型，它只关心内存的总字节数。
我们通常记不住int,float等数据类型的变量的确切字节数。例如int变量在16位系统下是2个字节
，在32位下是4个字节；而float变量在16位系统下是4个字节，在32位下也是4个字节。

最好用以下程序作一次测试：
cout << sizeof(char) << endl;
cout << sizeof(int) << endl;
cout << sizeof(unsigned int) << endl;
cout << sizeof(long) << endl;
cout << sizeof(unsigned long) << endl;
cout << sizeof(float) << endl;
cout << sizeof(double) << endl;
cout << sizeof(void *) << endl;

在malloc的"()"中使用sizeof运算符是良好的风格，但要当心有时我们会昏了头，写出 p = malloc(sizeof(p))这样的程序来。

函数free的原型如下：

void free( void * memblock );

为什么free函数不象malloc函数那样复杂呢？这是因为指针p的类型以及它所指的内存的容量事先都是知道的，语句free(p)能正确地释放内存。如果p是NULL指针，那么free对p无论操作多少次都不会出问题。
如果p不是NULL指针，那么free对p连续操作两次就会导致程序运行错误。

11 new/delete 的使用要点
------------------------------------------
运算符new使用起来要比函数malloc简单得多，例如：
int *p1 = (int *)malloc(sizeof(int) * length);
int *p2 = new int[length];
这是因为new内置了sizeof、类型转换和类型安全检查功能。对于非内部数据类型的对象而言，
new在创建动态对象的同时完成了初始化工作。
如果对象有多个构造函数，那么new的语句也可以有多种形式。
例如
class Obj
{
public :
Obj(void); // 无参数的构造函数
Obj(int x); // 带一个参数的构造函数
...
}
void Test(void)
{
Obj *a = new Obj;
Obj *b = new Obj(1); // 初值为1
...
delete a;
delete b;
}
如果用new创建对象数组，那么只能使用对象的无参数构造函数。例如
Obj *objects = new Obj[100]; // 创建100个动态对象
不能写成
Obj *objects = new Obj[100](1);// 创建100个动态对象的同时赋初值1
在用delete释放对象数组时，留意不要丢了符号‘[]'。例如
delete []objects; // 正确的用法
delete objects; // 错误的用法
后者相当于delete objects[0]，漏掉了另外99个对象。

Mercury QuickTest Professional 8.2 自述文件

本文件提供有关 QuickTest Professional 的下列信息：

概述

欢迎使用 QuickTest Professional - Mercury 关键字驱动的自动测试解决方案。通过监视最终用户行为，QuickTest Professional 创建交互式可自定义测试或组件，从而简化并缩短测试周期。

通过 QuickTest Professional，可以测试标准 Windows 应用程序、Web 对象、ActiveX 控件和 Visual Basic 应用程序。还可以获得适用于许多特殊环境的其他 QuickTest 加载项，例如 Java、Oracle、SAP 解决方案、.NET Windows 以及 Web Forms、Siebel、PeopleSoft 和终端仿真器应用程序。

QuickTest Professional 兼容 Unicode，支持 Unicode 2.0、UTF-8 和 UTF-16。

QuickTest Professional 支持运行 WinRunner 7.6 及更高版本的 WinRunner 测试和函数。

对于测试管理，QuickTest Professional 可以与 Mercury 集中质量解决方案 Quality Center（原为 TestDirector）集成，适用于 TestDirector 7.6 Service Pack 4、TestDirector 8.0 Service Pack 2 和 Quality Center 8.2 版。

对于 Business Process Testing，QuickTest Professional 可以与 Quality Center 8.2 版（带有支持 Business Process Testing 的许可证）集成。

QuickTest Professional 可以与 LoadRunner 集成，后者是用于应用程序性能测试的 Mercury 工具（用于版本 7.8、7.81 (FP1) 和 8.0）。

QuickTest Professional 还可以与 Mercury 应用程序管理（原为 Topaz）集成，后者是用于优化业务可用性和问题解析的 Mercury 解决方案。

新增功能

QuickTest Professional 8.2 包含下列新增功能：

在新增功能帮助（从“帮助”>“QuickTest 的新增功能”获得）中，可以找到有关上述功能的其他信息及更多功能。

客户支持

通过我们屡获殊荣的客户支持网站为 QuickTest Professional 提供技术支持。客户可以从该网站查阅常见问题、提交并检查支持请求的状态，以及访问联机文档、修补程序和其他下载内容。请访问客户支持网站：

http://support.mercury.com。

可以从以下网址找到世界各地的客户支持联系电话号码：

http://support.mercury.com/cgi-bin/portal/CSO/contacts.jsp。

系统要求

要成功安装并运行 QuickTest Professional，您需要满足以下最低系统要求：
jszB%kq3W5L156874
.H8Bhvz$C156874

注意： 尚未为“最低”系统配置优化性能。要获得最佳性能，您的系统应该至少按“建议”级别进行配置。

支持的加载项

除了所有 8.2 版加载项，您还可以将下列特定的加载项版本用于 QuickTest Professional 8.2：

有关详细信息和说明，请参阅《Mercury QuickTest Professional 安装指南》。

支持的环境和程序

QuickTest Professional 支持使用下面描述的环境和程序来创建、录制和运行测试或组件。

标准 Windows 应用程序

QuickTest Professional 支持在基于 Windows API 和 MFC 的应用程序上进行测试。

Visual Basic 应用程序

QuickTest Professional 支持在 Visual Basic 6.0 应用程序上进行测试。

注意： QuickTest Professional .NET 加载项支持 Visual Basic .NET 应用程序。

浏览器

ActiveX 网格控件

除了对 ActiveX 属性和方法的基本支持外，QuickTest Professional 还支持在下列 ActiveX 网格控件上进行上下文相关录制和验证：
Y^.j{_} v'VP%aP156874
"WvKYK^ i@W156874

ActiveX 日历控件

除了对 ActiveX 属性和方法的固有支持外，QuickTest Professional 还支持在下列 ActiveX 日历控件上进行上下文相关录制和验证：软件测试专业网站:51Testing软件测试网
d \@@
f Z-Q u"W7PA#O
软件测试专业网站:51Testing软件测试网 z;n!@~e

Microsoft Excel

在 QuickTest Professional 中使用 Microsoft Excel 文件（例如，向数据表导入数据或从数据表导出数据）时，可以使用 Microsoft Excel 2000、2002、2003 和 XP。

Microsoft Query

在 QuickTest Professional 中使用 Microsoft Query（例如，用于数据库检查点）时，可以使用 Microsoft Query 2000、2002、2003 和 XP。

其他环境

QuickTest Professional 加载项支持其他环境，例如 Java、.NET Windows 以及 Web Forms、SAP 解决方案、Oracle、Siebel、PeopleSoft、Web 服务和终端仿真器应用程序。有关 QuickTest Professional 加载项的详细信息，请与您的销售代表或 Mercury Interactive 客户支持联系。

有用的信息

已知问题和局限性

安装

向前兼容性

录制和运行测试或组件

在 Web 对象上录制和运行测试及组件

在 Netscape 中录制和运行测试或组件

在 AOL 中录制和运行测试或组件

在标准 Windows 对象上录制和运行测试及组件

在 Visual Basic 应用程序中录制和运行测试及组件

在 ActiveX 控件上录制和运行测试及组件

文本识别

对象库

恢复场景管理器

检查点和输出值

XML 检查点

数据库检查点

输出值

文档

Quality Center 集成

对于 Business Process Testing，QuickTest Professional 可以与 Quality Center 8.2 版（带有支持 Business Process Testing 的许可证）集成。

查看(1244) 评论(0) 收藏 分享 管理

Table of Contents

1. Why test an RDBMS?

2. What should we test?

3. When should we test?

4. How should we test?

   • Database sandboxes

   • Writing database tests

   • Setting up database tests

   • Database testing tools

5. Who should test?

6. Introducing database testing into your organization

7. Database testing and data inspection

8. Best practices

1. Why Test an RDBMS?

There are several reasons why you need to develop a comprehensive testing strategy for your RDBMS:

1. Data is an important corporate asset.  Doesn't it make sense to invest the effort required to validate the quality of data via effective testing?  My July 2006 survey into the current state of data management indicates that 95.7% of respondents believe that data is a corporate asset.  Yet of them only 40.3% had a database test suite in place to validate the data and of those without a test suite only 31.6% had even discussed the concept.

2. Mission-critical business functionality is implemented in RDBMSs.  In the survey,  63.7% of respondents indicated that their organizations did this, but of those only 46% had regression tests in place to validate the logic. Shouldn't we be doing better?

3. Current approaches aren't sufficient.  The current state of the art in many organizations is for data professionals to control changes to the database schemas, for developers to visually inspect the database during construction, and to perform some form of formal testing during the test phase at the end of the lifecycle.  Unfortunately, none of these approaches prove effective.  Application developers will often go around their organization's data management group because they find them too difficult to work with, too slow in the way they work, or sometimes they don't even know they should be working together.  The end result is that the teams don't follow the desired data quality procedures and as a result quality suffers.  Although visual inspection of query results is a good start it is little more than a debugging technique in practice that will help you to find problems but not prevent them.  Testing late in the lifecycle is better than nothing, but as Barry Boehm noted in the early 80s it's incredibly expensive to fix any defects you find at that point.

4. Testing provides the concrete feedback required to identify defects.  How do you know how good the quality of your source data actually is without an effective test suite which you can run whenever you need to?

5. Support for evolutionary development.  Many evolutionary development techniques, in particular database refactoring, are predicated upon the idea that it must be possible to determine if something in the database has been broken when a change has been made.  The easiest way to do that is to simply run your regression test suite.

Here's a few interesting questions to ask someone who isn't convinced that you need to test the DB:

1. If you're implementing code in the DB in the form of stored procedures, triggers, ... shouldn't you test that code to the same level that you test your app code?
2. Think of all the data quality problems you've run into over the years. Wouldn't it have been nice if someone had originally tested and discovered those problems before you did?
3. Wouldn't it be nice to have a test suite to run so that you could determine how (and if) the DB actually works?
    

I think that one of the reasons that we don't hear much about database testing is because it is a relatively new idea within the data community. Many traditional data professionals seem to think that testing is something that other people do, particularly test/quality assurance professionals, do. This reflects a penchant for over-specialization and a serial approach towards development by traditionalists, two ideas which have also been shown to be questionable organizational approaches at best.

2. What Should We Test?

Figure 1 indicates what you should consider testing when it comes to relational databases.  The diagram is drawn from the point of view of a single database, the dashed lines indicate threat boundaries, indicating that you need to consider threats both within the database (clear box testing) and at the interface to the database (black box testing).  Table 1 lists the issues which you should consider testing for both internally within the database and at the interface to it.  For details, read the article What To Test in an RDBMS.

Figure 1. What to test.

Table 1.  What to test in an RDBMS.

3. When Should We Test?

Agile software developers take a test-first approach to development where they write a test before you write just enough production code to fulfill that test.  The steps of test first development (TFD) are overviewed in the UML activity diagram of Figure 2.  The first step is to quickly add a test, basically just enough code to fail.  Next you run your tests, often the complete test suite although for sake of speed you may decide to run only a subset, to ensure that the new test does in fact fail.  You then update your functional code to make it pass the new tests.  The fourth step is to run your tests again.  If they fail you need to update your functional code and retest.  Once the tests pass the next step is to start over.

Figure 2. The Process of Test First Development (TFD).

Test-driven development (TDD) is an evolutionary approach to development which combines test-first development and refactoring.  When an agile software developer goes to implement a new feature, the first question they ask themselves is "Is this the best design possible which enables me to add this feature?"  If the answer is yes, then they do the work to add the feature.  If the answer is no then they refactor the design to make it the best possible then they continue with a TFD approach.  This strategy is applicable to developing both your application code and your database schema, two things that you would work on in parallel.

When you first start following a TDD approach to development you quickly discover that to make it successful you need to automate as much of the process as possible?  Do you really want to manually run the same build scrīpt(s) and the same testing scrīpt(s) over and over again?  Of course not.  So, agile developers have created OSS tools such as ANT, Maven, and Cruise Control (to name a few) which enable them to automate these tasks.  More importantly, it enables them to automate their database testing scrīpt into the build procedure itself.

Agile developers realize that testing is so important to their success that it is something they do every day, not just at the end of the lifecycle.  They test as often and early as possible, and better yet they test first.  As you can see with the agile system development lifecycle (SDLC) of Figure 3 testing is in fact something that occurs during the development and release cycles, not just during release.  Furthermore, many agile software developers realize that you can test more than just your code, you can in fact validate every work product created on a software development project if you choose to.  This philosophy is exemplified by the Full Lifecycle Object-Oriented Testing (FLOOT) Methodology.

Figure 3. The Agile Lifecycle.

4. How to Test

Although you want to keep your database testing efforts as simple as possible, at first you will discover that you have a fair bit of both learning and set up to do.  In this section I discuss the need for various database sandboxes in which people will test: in short, if you want to do database testing then you're going to need test databases (sandboxes) to work in.  I then overview how to write a database test and more importantly describe setup strategies for database tests.  Finally, I overview several database testing tools which you may want to consider.

4.1 Database Sandboxes

A common best practice on agile teams is to ensure that developers have their own "sandboxes" to work in.  A sandbox is basically a technical environment whose scope is well defined and respected.  Figure 4 depicts the various types of sandboxes which your team may choose to work in.  In each sandbox you'll have a copy of the database.  In the development sandbox you'll experiment, implement new functionality, and refactor existing functionality, validate your changes through testing, and then eventually you'll promote your work once you're happy with it to the project integration sandbox.  In this sandbox you will rebuild your system and then run all the tests to ensure you haven't broken anything (if so, then back to the development sandbox).  Occasionally, at least once an iteration/cycle, you'll deploy your work to the level (demo and pre-production testing), and rerun your test suite (including database tests) each time that you do so to ensure that your changes integrate with the changes made by other developers.  Every so often (perhaps once every six to twelve months) into production. The primary advantage of sandboxes are that they help to reduce the risk of technical errors adversely affecting a larger group of people than is absolutely necessary at the time. 

Figure 4. Sandboxes.

4.2 Writing Database Tests

There's no magic when it comes to writing a database test, you write them just like you would any other type of test.  Database tests are typically a three-step process:

1. Setup the test.  You need to put your database into a known state before running tests against it.  There are several strategies for doing so.
2. Run the test.  Using a database regression testing tool, run your database tests just like you would run your application tests.
3. Check the results.  You'll need to be able to do "table dumps" to obtain the current values in the database so that you can compare them against the results which you expected.

The article What To Test in an RDBMS goes into greater detail.

4.3 Setting up Database Tests

To successfully your database you must first know the exact state of the database, and the best way to do that is to simply put the database in a known state before running your test suite.  There are two common strategies for doing this:

1. Fresh start.  A common practice is to rebuild the database, including both creation of the schema as well as loading of initial test data, for every major test run (e.g. testing that you do in your project integration or pre-production test sandboxes). 

2. Data reinitialization.  For testing in developer sandboxes, something that you should do every time you rebuild the system, you may want to forgo dropping and rebuilding the database in favor of simply reinitializing the source data. You can do this either by erasing all existing data and then inserting the initial data vales back into the database, or you can simple run updates to reset the data values.  The first approach is less risky and may even be faster for large amounts of data.

Table 2. Some database testing tools.

5. Who Should Test?

During development cycles, the primary people responsible for doing database testing are application developers and agile DBAs.  They will typically pair together, and because they are hopefully taking a TDD-approach to development the implication is that they'll be doing database unit testing on a continuous basis.  During the release cycle your testers, if you have any, will be responsible for the final system testing efforts and therefore they will also be doing database testing.

The role of your data management (DM) group, or IT management if your organization has no DM group, should be to support your database testing efforts.  They should promote the concept that database testing is important, should help people get the requisite training that they require, and should help obtain database testing tools for your organization.  As you have seen, database testing is something that is done continuously by the people on development teams, it isn't something that is done by another group (except of course for system testing efforts).  In short, the DM group needs to support database testing efforts and then get out of the way of the people who are actually doing the work.

6. Introducing Database Regression Testing into Your Organization

Database testing is new to many people, and as a result you are likely to face several challenges:

1. Insufficient testing skills. This problem can be overcome through training, through pairing with someone with good testing skills (pairing a DBA without testing skills and a tester without DBA skills still works), or simply through trial and error. The important thing is that you recognize that you need to pick up these skills.
2. Insufficient unit tests for existing databases. Few organizations have yet to adopt the practice of database testing, so it is likely that you will not have a sufficient test suite for your existing database(s). Although this is unfortunate, there is no better time than the present to start writing your test suite.
3. Insufficient database testing tools. As I said earlier, we still have a way to go with respect to tools.
4. Reticent DM groups.  My experience is that some data management (DM) groups may see the introduction of database regression testing, and agile techniques such as test-first development (TFD) and refactoring, as a threat.  Or, as my July 2006 "state of data management" survey shows, a large percentage of organizations are not only not doing any database testing at all they haven't even discussed it.  For many in the data management community the idea of doing database testing is rather new and it's simply going to take a while for them to think it through.  I'm not so sure that you should wait to do such obvious process improvement.

In general, I highly suggest that you read my article Adopting Evolutionary/Agile Database Techniques and consider buying the book Fearless Change which describes a pattern language for successfully implementing change within organizations.

7. Database Testing and Data Inspection

A common quality technique s to use data inspection tools to examine existing data within a database.  You might use something as simple as a SQL-based query tool such as DB Inspect to select a subset of the data within a database to visually inspect the results.  For example, you may choose to view the unique values in a column to determine what values are stored in it, or compare the row count of a table with the count of the resulting rows from joining the table with another one.  If the two counts are the same then you don't have an RI problem across the join.

As Richard Dallaway points out, the problem with data inspection is that it is often done manually and on an irregular basis.  When you make changes later, sometimes months or years later, you need to redo your inspection efforts.  This is costly, time consuming, and error prone.

Data inspection is more of a debugging technique than it is a testing technique.  It is clearly an important technique, but it's not something that will greatly contribute to your efforts to ensure data quality within your organization.

8. Best Practices

I'd like to conclude this article by sharing a few database testing "best practices" with you:

1. Use an in-memory database for regression testing.  You can dramatically speed up your database tests by running them, or at least portions of them, against an in-memory database such as HSQLDB.  The challenge with this approach is that because database methods are implemented differently across database vendors that any method tests will still need to run against the actual database server.

2. Start fresh each major test run.  To ensure a clean database, a common strategy is that at the beginning of each test run you drop the database, then rebuild it from scratch taking into account all database refactorings and transformations to that point, then reload the test data, and then run your tests.  Of course, you wouldn't do this to your production database.  ;-)

3. Take a continuous approach to regression testing.  I can't say this enough, a TDD approach to development is an incredibly effective way to work.

4. Train people in testing.  Many developers and DBAs have not been trained in testing skills, and they almost certainly haven't been trained in database testing skills.  Invest in your people, and give them the training and education they need to do their jobs.

5. Pair with novices with people that have database testing experience.  One of the easiest ways to gain database testing skills is to pair program with someone who already has them.

质量体系建立的步骤

软件测试基础知识复习 （转）

做软件测试三、四年的给新手的建议

 | 作者: 网络转载 |