8 、软件测试过程模型

   ⑴  V模型

      瀑布模型：人们通常把测试过程作为在需求分析、概要设计、详细设计和编码全部完成之后的一个阶段。

     V模型是软件开发瀑布模型的一个变种。

    用户需求→需求分析、系统设计→概要设计→详细设计→编码

    验收测试←系统测试、确认测试←集成测试←单元测试

V模型的局限性：它仅仅把测试过程作为在需求分析、概要设计、详细设计以及编码之后的一个阶段。容易使人理解测试是软件开发的最后一个阶段，主要是针对程序进行测试寻找错误，而需求分析阶段隐藏的问题一直到后期的验收测试才被发现。没有说明早期的测试，没有体现“尽早的和不间断地进行软件测试”的原则。

⑵ W模型

  V模型的局限性在于没有明确地说明早期的测试,无法体现“尽早地和不断地进行软件测试”的原则。在V模型中增加软件各开发阶段应同步进行的测试，演化为W模型。在模型中不难看出，开发是“V”，测试是与此并行的“V”。基于“尽早地和不断地进行软件测试”的原则，在软件的需求和设计阶段的测试活动应遵循IEEE1012-1998《软件验证与确认（V&V）》的原则

W模型是V模型的发展，强调的是测试伴随着整个软件开发周期，而且测试的对象不仅仅是程序，需求、功能和设计同样要测试。测试与开发是同步进行的，从而有利于尽早地发现问题。

W模型的局限性：模型和V模型都把软件的开发视为需求、设计、编码等一系列串行的活动，软件测试和开发保持一种线性的前后关系，需要有严格的指令表示上一阶段完全结束，下一阶段才可以开始，无法支持迭代、自发性以及变更调整

⑶H模型

它将测试活动完全独立出来，形成一个完全独立的流程，将测试准备活动和测试执行活动清晰地体现出来。

在H模型中，软件测试模型是一个独立的流程，贯穿于整个产品周期，与其他流程并发地进行。当某个测试时间点就绪时，软件测试即从测试准备阶段进入测试执行阶段。 

X模型：目标是弥补V模型的一些缺陷

模型还定位了探索性测试（右下方）。这是不进行事先计划的特殊类型的测试，诸如“我这么测一下结果会怎么样？”，这一方式往往能帮助有经验的测试人员在测试计划之外发现更多的软件错误

尽管很多项目缺乏足够的需求，V模型还是从需求处理开始。V模型提示我们要对各开发阶段中已经得到的内容进行测试，但它没有规定我们要取得多少内容。如果没有任何的需求资料，开发人员知道他们要做什么吗？V模型的一个强项是它明确的需求角色的确认，而X模型没有这么做，这大概是X模型的一个不足之处。

Marick也质疑了单元测试和集成测试的区别，因为在某些场合人们可能会跳过单元测试而热衷于直接进行集成测试。Marick担心人们盲目地跟随“学院派的V模型”，按照模型所指导的步骤进行工作，而实际上某些做法并不切合实用。我已经尽自己的努力把Marick的关于需要很多具有可伸缩性的行为的期望结合进了X模型，这样，X模型并不要求在进行作为创建可执行程序（图中右上方）的一个组成部分的集成测试之前，对每一个程序片段都进行单元测试（图中左侧的行为）。但X模型没能提供是否要跳过单元测试的判断准则

前置测试模型：

1、 开发和测试相结合

业务需求最好在设计和开发之前就被正确定义
2、 对每一个交付内容进行测试

源程序并不是唯一的测试内容，其他的测试对象，包括可行性报告、业务需求说明以及设计文档(对V模型的扩展)

3、 在设计阶段进行测试计划和测试设计

4、验收测试和技术测试相互独立

验收测试可以在实施阶段的第一步来执行，也可以在开发阶段的最后一步执行。

5、测试和开发结合在一起

测试模型的使用：

软件测试基础

1、 什么是软件测试

测试的含义“以检验产品是否满足需求为目标“，软件测试的重要活动即发现错误

软件测试的经典定义：在规定的条件下对软件进行操作，以发现错误，并对软件质量进行评估。

软件是由程序、数据和文档组成的，软件测试就是对软件形成过程中的文档、数据和程序进行测试，而不仅仅是对程序进行测试。

60％以上的软件错误并不是程序错误，而是软件分析和设计的错误

2、 什么是软件质量

经典定义：软件特性的总和，软件满足规定或潜在用户需求的能力

软件质量包括“内部质量“、“外部质量”以及“使用质量”，也就是说“软件满足规定或者潜在用户需求能力”要从“内部质量”、“外部质量”和“使用质量”三部分体现

3、 软件测试和质量保证的区别：

软件测试只是软件质量保证的一个工作环节：

质量保证：通过预防、检查和改进来保证软件质量。采用全面质量管理和过程改进的原理来开展质量保证工作，主要着眼于软件开发活动的过程、步骤和产物。

软件测试：关心的并不是过程的活动，而是对过程的产物以及开发的软件进行剖析。通过执行软件来，对过程中的产物（开发文档和程序）进行走查，发现问题，报告质量

4、 软件测试的目的：

测试的目的不仅仅是为了发现软件错误和缺陷，而是也是对软件质量进行评估，以提高软件质量。

测试是程序的执行过程，目的在于发现错误；

一个好的测试用例在于发现了至今未发现的错误；

一个成功的测试是发现了 至今未发现的错误的测试；

5、 软件测试原则：

①     所有的测试都应该追溯的用户的需求

②     应该把“尽早的和不断的测试”作为软件测试者的座右铭

③     完全测试是不可能的，测试需要终止

输入量太大

输出结果太多

路径组合太多

（中止测试原则）根据测试错误的概率以及软件可靠性要求，来确定测试的停止测试时间

④     测试无法显示软件潜在的缺陷  

软件测试只能证明软件存在错误而不能保证软件没有错误

⑤     充分注意测试中的群集现象

     测试后程序中残存的错误数目和该程序中已经发现的错误数目成正比
⑥  程序员应该避免检查自己的程序

⑥     尽量避免测试的随意性

6、 软件测试对象

     在整个软件生命周期中，各个阶段有不同的测试对象，形成了不同开发阶段的不同类型的测试。

     需求分析、概要设计、详细设计以及程序编码等阶段得到的不同的文档，例如需求规格说明书、概要设计规格说明书、详细设计规格说明书以及源程序，都应该成为测试对象。

软件编码完成后，对每一模块进行测试，称为“模块测试”或“单元测试”。在模块集成后，对集成在一起的模块组件，称为“集成测试”，在集成测试后需要检测和证实软件是否满足软件需求说明书中规定的需求，这就称为“确认测试”，将整个软件集成为系统，安装在运行环境下，对硬件、网路、操作系统以及支撑平台构成的整体系统进行测试，称为“系统测试”。

验证：保证软件正确实现特定功能的一系列活动和过程

确认：保证软件满足用户需求的一系列活动或过程。

7、 软件测试分类

⑴按照开发阶段划分

①        单元测试

     又称为模块测试，检查各个程序单元能否正确的实现详细设计说明中的模块功能、性能、接口和设计约束等要求，发现各个模块可能存在的各种错误  

②    集成测试

      又称为组装测试，在单元测试的基础上，将所有的程序模块进行有序的、递增的测试。集成测试是检验程序单元或部件的接口关系，逐步集成为符合概要设计要求的程序部件或系统

③    确认测试

      通过检查和提供数据，证实软件是否满足特定预期用途的需求。确认测试时候检测和证实软件是否满足软件需求说明规格的需求

④    系统测试

     对集成的硬件和软件进行测试。

⑤    验收测试

按照项目书或合同，供需双方约定的验收依据文档进行的对整个系统的测试和评审

⑵按照测试实施组织划分

①    开发方测试

通常也叫验收测试或“a”测试，开发方在开发环境下，通过测试和提供数据，证实软件的实现是否满足规定的需求，是否满足软件设计说明或软件需求说明的需求。可以和软件的系统测试一同进行。

②    用户测试

在用户的应用环境下，用户检测与核实软件实现是否符合自己预期的要求。B测试通常被认为是用户测试，把软件有计划地免费地分发到目标市场，让用户大量使用、评价检查软件

③    第三方测试

   由第三方测试机构来进行的测试，也称独立测试

⑶按照测试技术划分

按照测试技术划分为：白盒测试、黑盒测试、灰盒测试。也可以分为静态测试和动态测试

静态测试：不运行程序，通过人工对程序和文档进行分析和检查，静态测试实际上是对软件中的需求说明书、设计说明书、程序代码进行非运行的检查。静态测试包括走查、符号执行以及需求确认等。

动态测试：通过人工或工具运行程序进行检查、分析程序的运行状态以及外部表现

①    白盒测试

②     了解程序结构和处理过程，检查是否所有的结构和路径都是正确的，检查程序的内部动作是否按照设计说明的规定正常进行

③     黑盒测试

完全不考虑程序的结构和处理过程，在程序界面进行测试，它只是检查是否按照需求规格说明书的规定正确实现

④    灰盒测试

   灰盒测试只是关注输出对于输入的正确性，同时也关注内部表现

单元测试可以应用白盒测试方法

集成测试应用灰盒测试方法

系统测试以及确认测试可以应用黑盒测试方法

我们可以让指针指向某类变量，并替代该变量在程序中使用；我们也可以让指针指向一维、二维数组或字符数组，来替代这些数组在程序中使用，给我们在编程时带来许多方便。
下面我们定义一种特殊的数组，这类数组存放的全部是指针，分别用于指向某类的变量，以替代这些变量在程序中的使用，增加灵活性。指针数组定义形式：
类型标识*数组名[数组长度]
例如： char *str[4];
由于[ ] 比*优先权高，所以首先是数组形式str[4 ]，然后才是与“*”的结合。这样一来指针数组包含4个指针s t r [ 0 ]、s t r [ 1 ]、s t r [ 2 ]、s t r [ 3 ]，各自指向字符类型的变量。例如： int *p t r [ 5 ] ;
该指针数组包含5个指针p t r [ 0 ]、p t r [ 1 ]、p t r [ 2 ]、p t r [ 3 ]、p t r [ 4 ]，各自指向整型类型的变量。
[例6-22] 针对指针数组的应用，我们分别用指针数组的各指针指向字符串数组、指向一维整型数组、指向二维整型数组。
#include <stdlib.h>
#include <stdio.h>
m a i n ( )
{
char *ptr1[4]={"china","chengdu","sichuang","chongqin"};
/* 指针数组p t r 1 的4个指针分别依此指向4个字符串* /
int i,*ptr2[3],a[3]={1,2,3},b[3][2]={1,2,3,4,5,6};
for(i=0;i<4;i++)
printf("\n%s",ptr1[i]);/依*此输出ptr1数组4个指针指向的4个字符串*/
printf("\n");
for(i=0;i<3;i++)
ptr2[i]=&a[i];/*将整型一维数组a的3个元素的地址传递给指针数组ptr2*/
for(i=0;i<3;i++)/*依此输出ptr2所指向的3个整型变量的值*/
printf("%4d",*ptr2[i]);
printf("\n");
for(i=0;i<3;i++)
ptr2[i]=b[i];/*传递二维数组b的每行首地址给指针数组的4个指针*/
for(i=0;i<3;i++)/*按行输出*/
printf("%4d%4d\n",*ptr2[i],*ptr2[i]+1);
}
程序中指针数组与所指对象的关系如图6-12所示。

 
ptr1指针数组中的4个指针分别指向4个字符串，如图6-11的a）所示，程序中依此输出；ptr2指针数组共有3个指针，若将整型一维数组a中各元素地址分别传递给指针数组的各指针，则ptr2[0]就指向a[0]；ptr2[1]就指向a[1]；ptr2[2]就指向a[2]。若将二维数组各行的首地址分别传递给指针数组的各指针，如图6-11b）所示，这样一来，ptr2[0]就指向了b数组的第0行，该行有两个元素，其地址为ptr2[0]与ptr2[0]+1；相应指针数组第i个元素ptr2[i]指向的b数组的第i行两个元素地址分别为ptr2[i]与ptr[i]+1。
 
在处理二维字符数组时，我们可以把二维字符数组看成是由多个一维字符数组构成，也就是说看成是多个字符串构成的二维字符数组，或称为字符串数组。
指针数组对于解决这类问题（当然也可以解决其它问题）提供了更加灵活方便的操作。
有一点需要说明，若定义一个指针数组后，指针数组各元素的取值（即地址）要注意安全性。
如定义指针数组：
char*ptr[3];
我们说该数组包含三个指针，但指针的指向是不确定的，指针现在可能指向内存的任一地址。假定现在作语句：scanf("%s",ptr[i]),则输入的字符串在内存的存放其地址由ptr[i]决定。除非给指针数组元素赋值安全的地址。
[例6-23]定义字符指针数组，包含5个数组元素。同时再定义一个二维字符数组其数组大小为5*10，即5行10列，可存放5个字符串。若将各字符串的首地址传递给指针数组各元素，那么指针数组就成为名副其实的字符串数组。下面对各字符串进行按字典排序。
在字符串的处理函数中，strcmp(str1,str2)函数就可以对两个字符串进行比较，函数的返回值>0、=0、<0分别表示串str1大于str2、str1等于str2、str1小于str2。再利用strcpy()函数实现两个串的复制。下面选用冒泡排序法。
#include<stdlib.h>
#include<string.h>
#include<stdio.h>
main()
{
char*ptr1[4],str[4][20],temp[20];
/*定义指针数组、二维字符数组、用于交换的一维字符数组*/
int i,j;
for(i=0;i<4;i++)
gets(str[i]);/*输入4个字符串*/
printf("\n");
for(i=0;i<4;i++)
ptr1[i]=str[i];/*将二维字符数组各行的首地址传递给指针数组的各指针*/
printf("original string:\n");
for(i=0;i<4;i++)/*按行输出原始各字符串*/
printf("%s\n",ptr1[i]);
printf("ordinal string:\n");
for(i=0;i<3;i++)/*冒泡排序*/
for(j=0;j<4-i-1;j++)
if(strcmp(ptr1[j],ptr1[j+1])>0)
{strcpy(temp,ptr1[j]);
strcpy(ptr1[j],ptr1[j+1]);
strcpy(ptr1[j+1],temp);
}
for(i=0;i<4;i++)/*输出排序后的字符串*/
printf("%s\n",ptr1[i]);
}

 
程序中一定要注意指针的正确使用。一旦将二维字符数组的各行首地址传递给指针数组的各指针，则相当于给指针分配了安全可操作的地址，地址空间大小由二维字符数组来决定。
当然也可由编译系统为指针分配地址用于字符串的存放。
[例6-24]利用malloc()函数为指针分配存储空间，实现字符串的排序。
#include<stdlib.h>
#include<string.h>
#include<stdio.h>
main()
{
char *ptr1[4],*temp;
inti,j;
for(i=0;i<4;i++)
{
ptr1[i]=malloc(20);/*为指针数组各指针分配20字节的存储空间*/
gets(ptr1[i]);
}
printf("\n");
printf("original string:\n");
for(i=0;i<4;i++)
printf("%s\n",ptr1[i]);
printf("ordinal string:\n");
for(i=0;i<3;i++)
for(j=0;j<4-i-1;j++)
if(strcmp(ptr1[j],ptr1[j+1])>0)
{
temp=ptr1[j];/*利用指向字符串的指针，进行指针地址的交换*/
ptr1[j]=ptr1[j+1];
ptr1[j+1]=temp;
}
for(i=0;i<4;i++)/*字符串输出*/
printf("%s\n",ptr1[i]);
}
运行程序，其结果与上述例6-23完全相同

[例6-25]对已排好序的字符指针数组进行指定字符串的查找。字符串按字典顺序排列，查找算法采用二分法，或称为折半查找。
折半查找算法描述：
1.设按开序（或降序）输入n个字符串到一个指针数组。
2.设low指向指针数组的低端，high指向指针数组的高端，mid=(low+high)/2
3.测试mid所指的字符串，是否为要找的字符串。
4.若按字典顺序，mid所指的字符串大于要查找的串，表示被查字符串在low和mid之间，否则，表示被查字符串在mid和high之间。
5.修改low式high的值，重新计算mid，继续寻找。
#include<stdlib.h>
#include<alloc.h>
#include<string.h>
#include<stdio.h>
main()
{
char*binary();/*函数声明*/
char*ptr1[5],*temp;
inti,j;
for(i=0;i<5;i++)
{
ptr1[i]=malloc(20);/*按字典顺序输入字符串*/
gets(ptr1[i]);
}
printf("\n");
printf("original string:\n");
for(i=0;i<5;i++)
printf("%s\n",ptr1[i]);
printf("input search string:\n");
temp=malloc(20);
gets(temp);/输*入被查找字符串*/
i=5;
temp=binary(ptr1,temp,i);/*调用查找函数*/
if(temp)printf("succesful-----%s\n",temp);
elseprintf("nosuccesful!\n");
return;
}
char *binary(char *ptr[],char *str,int n)定义返回字符指针的函数*/
{/*折半查找*/
int hig,low,mid;
low=0;
hig=n-1;
while(low<=hig)
{
mid=(low+hig)/2;
if(strcmp(str,ptr[mid])<0)
hig=mid-1;
elseif(strcmp(str,ptr[mid])>0)
low=mid+1;
else return(str);/*查帐成功，返回被查字符串*/
}
return NULL; / *查找失败，返回空指针* /
}

[例6-26] 在一个已排好序的字符串数组中，插入一个键盘输入的字符串，使其继续保持有序。
在上述程序查找成功的基础上，我们将该字符串插入到字符数组中。插入的位置可以是数组头、中间或数组尾。查找的算法采用折半算法，找到插入位置后，将字符串插入。
#include <stdlib.h>
#include <alloc.h>
#include <string.h>
#include <stdio.h>
m a i n ( )
{
int binary(); / *查找函数声明* /
void insert(); / *插入函数声明* /
char *temp,*ptr1[6];
int i,j;
for (i=0;i<5;i++)
{

ptr1[i]=malloc(20);/*为指针分配地址后*/
gets(ptr1[i]);/*输入字符串*/
}
ptr1[5]=malloc(20);
printf("\n");
printf("original string:\n");
for(i=0;i<5;i++)/*输出指针数组各字符串*/
printf("%s\n",ptr1[i]);
printf("input search string:\n");
temp=malloc(20);
gets(temp);/*输入被插字符串*/
i=binary(ptr1,temp,5)/*;寻找插入位置i*/
printf("i=%d\n",i);
insert(ptr1,temp,5,i);/*在插入位置i处插入字符串*/
printf("outputstrings:\n");
for(i=0;i<6;i++)/*输出指针数组的全部字符串*/
printf("%s\n",ptr1[i]);
return;
}
int binary(char*ptr[],char*str,intn)
{/*折半查找插入位置*/
int hig,low,mid;
low=0;
hig=n-1;
if(strcmp(str,ptr[0])<0)return0;
/*若插入字符串比字符串数组的第0个小，则插入位置为0*/
if(strcmp(str,ptr[hig])>0)returnn;
/*若插入字符串比字符串数组的最后一个大，则应插入字符串数组的尾部*/
while(low<=hig)
{
mid=(low+hig)/2;
if(strcmp(str,ptr[mid])<0)
hig=mid-1;
else if(strcmp(str,ptr[mid])>0)
low=mid+1;
else return(mid);/*插入字符串与字符串数组的某个字符串相同*/
}
return low;/*插入的位置在字符串数组中间*/
}
void insert(char*ptr[],char*str,intn,inti)
{
int j;
for(j=n;j>i;j--)/*将插入位置之后的字符串后移*/
strcpy(ptr[j],ptr[j-1]);
strcpy(ptr[i],str);将被插字符串按字典顺序插入字符串数组*/
}
在程序中，字符串数组的6个指针均分配存放20字节的有效地址。语句ptr1[5]=malloc(20)保证插入字符串后，也具有安全的存储空间，字符串的长度以串中最长的为基准向系统申请存储空间，以保证在串的移动中有足够的存储空间。

1、函数指针：

指针函数是指带指针的函数，即本质是一个函数。我们知道函数都又返回类型（如果不返回值，则为无值型），只不过指针函数返回类型是某一类型的指针。其定义格式如下所示：

返回类型标识符 *返回名称（形式参数表）
{ 函数体 }

返回类型可以是任何基本类型和复合类型。返回指针的函数的用途十分广泛。事实上，每一个函数，即使它不带有返回某种类型的指针，它本身都有一个入口地址，该地址相当于一个指针。比如函数返回一个整型值，实际上也相当于返回一个指针变量的值，不过这时的变量是函数本身而已，而整个函数相当于一个“变量”。例如下面一个返回指针函数的例子：
float *find(float(*pionter)[4],int n)/*定义指针函数*/
{
    float *pt;
    pt=*(pionter+n);
    return(pt);
}

main()
{
    static float score[][4]={{60,70,80,90},{56,89,34,45},{34,23,56,45}};
    float *p;
    int i,m;
    printf("Enter the number to be found:");
    scanf("%d",&m);
    printf("the score of NO.%d are:\n",m);
    p=find(score,m);
    for(i=0;i<4;i++)
        printf("%5.2f\t",*(p+i));
}


学生学号从0号算起，函数find()被定义为指针函数，起形参pointer是指针指向包含4个元素的一维数组的指针变量。pointer+1指向score的第一行。*(pointer+1)指向第一行的第0个元素。pt是一个指针变量，它指向浮点型变量。main()函数中调用find()函数，将score数组的首地址传给pointer.

 将字符串1(str1)连接字符串2(str2)，并输出字符串1.

#include "stdio.h"
 char * mystrcpy(char * str1,char * str2)
{
    char * p;
    p=str1;
    while(*str1)
    str1++;
    while(*str1++=*str2++);
    return p;
}
int main(void)
{
  char str1[]="I LOVE SHY";
  char str2[]="   chj!";
  char *p;
  p=mystrcpy(str1,str2);
  printf("%s\n",p);
}
例3：

int * GetDate(int wk,int dy)
        {
            static int calendar[5][7]=
            {
               {1,2,3,4,5,6,7},
               {8,9,10,11,12,13,14},
               {15,16,17,18,19,20,21},
               {22,23,24,25,26,27,28},
               {29,30,31,-1,0}
            };
            return (&calendar[wk-1][dy-1]);
        }

   int  main(void)
        {
            int wk,dy;
            do
            {
                printf("Enter week(1-5)day(1-7)\n");
                scanf("%d %d",&wk,&dy);
            }
            while(wk<1||wk>5||dy<1||dy>7);
            printf("%d",*GetDate(wk,dy));
        }

2,函数指针：

“函数指针”是指向函数的指针变量，因而“函数指针”本身首先应是指针变量，只不过该指针变量指向函数。这正如用指针变量可指向整型变量、字符型、数组一样，这里是指向函数。如前所述，C在编译时，每一个函数都有一个入口地址，该入口地址就是函数指针所指向的地址。有了指向函数的指针变量后，可用该指针变量调用函数，就如同用指针变量可引用其他类型变量一样，在这些概念上一致的。函数指针有两个用途：调用函数和做函数的参数。函数指针的说明方法为:

例1：
 int max(int x,int y)
{ return(x>y?x:y);
}

2、strcmp函数：

int mystrcmp(const char *str1,const char *str2)
{
while((*str1==*str2)&&(*str1))
{
str1++;
str2++;
}
if((*str1==*str2)&&(!*str1)) //Same strings
return 0;
else if((*str1)&&(!*str2))  //Same but str1 longer
return 1;
else if ((!*str1)&&(*str2))
return -1 ;
else
return ((*str1>*str2)?1:-1);

}

3、strcat函数：

char *mystrcat(char *target,const char *source)
{
char *original=target;
while(*target) target++;     // Find the end of the string
while(*target++=*source++);
return(original);
}

int main(void)
{

  char destination[25];
  char * cc;                                                            
char *blank = " ", *c = "C++", *Borland = "Borland";
strcpy(destination, Borland);
mystrcat(destination, blank);
cc=mystrcat(destination, c);
printf("%s\n", cc);

}
4、strcpy函数

char *mystrcpy(char *destination, const char *source)
{
while(*destination++=*source++);            
return (destination);
}

5、strlen函数
int mystrlen(const char *string)
{
int i=0;
while(*string++)
 i++;
 return i;
}
5、streql函数
 int mystreql(char *str1,char *str2)
{
while((*str1==*str2)&&(*str1))
{
str1++;
str2++;
}
return((*str1==NULL)&&(*str2==NULL));
}
6、strchr函数
char * mystrchr(const char *string,char letter)
{
while((*string!=letter)&&(*string))
string++;
return (string);
}

int main(void)
{
char string[15];
char *ptr, c = 'r';
strcpy(string, "This is a string");
ptr = mystrchr(string, c);

if (ptr)
printf("The character %c is at position: %d\n", c,ptr-string);
else
printf("The character was not found\n");
return 0;
}
7、ctrcnt函数
int mychrcnt(const char *string,char letter) /*指定计算字符串内的指定字符的个数*/
{
int count=0;

while(*string)
{
    if(*string==letter)
    count++;
    string++;
}
return count;
}

2.与等价划分的区别
  1)边界值分析不是从某等价类中随便挑一个作为代表，而是使这个等价类的每个边界都要作为测试条件。
  2)边界值分析不仅考虑输入条件，还要考虑输出空间产生的测试情况。

3.边界值分析方法的考虑：
  长期的测试工作经验告诉我们，大量的错误是发生在输入或输出范围的边界上，而不是发生在输入输出范围的内部。因此针对各种边界情况设计测试用例，可以查出更多的错误。
  使用边界值分析方法设计测试用例，首先应确定边界情况。通常输入和输出等价类的边界，就是应着重测试的边界情况。应当选取正好等于，刚刚大于或刚刚小于边界的值作为测试数据，而不是选取等价类中的典型值或任意值作为测试数据。

4.常见的边界值
  1)对16-bit 的整数而言 32767 和 -32768 是边界
  2)屏幕上光标在最左上、最右下位置
  3)报表的第一行和最后一行
  4)数组元素的第一个和最后一个
  5)循环的第 0 次、第 1 次和倒数第 2 次、最后一次

5.边界值分析
  1)边界值分析使用与等价类划分法相同的划分，只是边界值分析假定错误更多地存在于划分的边界上，因此在等价类的边界上以及两侧的情况设计测试用例。
    例：测试计算平方根的函数
        --输入：实数
        --输出：实数
        --规格说明：当输入一个0或比0大的数的时候，返回其正平方根；当输入一个小于0的数时，显示错误信息"平方根非法-输入值小于0"并返回0；库函数Print-Line可以用来输出错误信息。
       
  2)等价类划分：
    I.可以考虑作出如下划分：
      a、输入 (i)<0 和 (ii)>=0
      b、输出 (a)>=0 和 (b) Error
    II.测试用例有两个：
      a、输入4，输出2。对应于 (ii) 和 (a) 。
      b、输入-10，输出0和错误提示。对应于 (i) 和 (b) 。

  3)边界值分析：
    划分(ii)的边界为0和最大正实数；划分(i)的边界为最小负实数和0。由此得到以下测试用例：
    a、输入 {最小负实数}
    b、输入 {绝对值很小的负数}
    c、输入 0
    d、输入 {绝对值很小的正数}
    e、输入 {最大正实数}
   
  4)通常情况下，软件测试所包含的边界检验有几种类型：数字、字符、位置、重量、大小、速度、方位、尺寸、空间等。
  5)相应地，以上类型的边界值应该在：最大/最小、首位/末位、上/下、最快/最慢、最高/最低、  最短/最长、 空/满等情况下。
  6)利用边界值作为测试数据

找零钱最佳组合

假 设 商 店 货 品 价 格 (R) 皆 不 大 於 100 元 （ 且 为 整 数 ） ， 若 顾 客 付 款 在 100 元 内 (P) ， 求 找 给 顾 客 之 最 少 货币 个（张） 数 ？ （ 货 币 面 值 50 元 (N50) ， 10 元 (N10) ， 5 元 (N5) ， 1 元 (N1) 四 种 ）

一、 分 析 输 入 的 情 形 。

R > 100

0 < R < = 100

R <= 0

P > 100

R<= P <= 100

P < R

二、 分 析 输 出 情 形 。

N50 = 1

N50 = 0

4 > N10 >= 1

N10 = 0

N5 = 1

N5 = 0

4 > N1 >= 1

N1 = 0

三、 分 析 规 格 中 每 一 决 策 点 之 情 形 ， 以 RR1, RR2, RR3 表 示 计 算 要 找 50, 10, 5 元 货 币 数 时 之 剩 余 金 额 。 R > 100R <= 0
P > 100
P < R
RR1 >= 50
RR2 >= 10
RR3 >= 5

四、 由 上 述 之 输 入 ／ 输 出 条 件 组 合 出 可 能 的 情 形 。

R > 100

R <= 0

0 < R <= 100, P > 100
0 < R <= 100, P < R
0 < R <= 100, R <= P <= 100, RR = 50
0 < R <= 100, R <= P <= 100, RR = 49
0 < R <= 100, R <= P <= 100, RR = 10
0 < R <= 100, R <= P <= 100, RR = 9
0 < R <= 100, R <= P <= 100, RR = 5
0 < R <= 100, R <= P <= 100, RR = 4
0 < R <= 100, R <= P <= 100, RR = 1
0 < R <= 100, R <= P <= 100, RR = 0

五、 为 满 足 以 上 之 各 种 情 形 ， 测 试 资 料 设 计 如 下 ：

1. 货品价格 = 101

2. 货品价格 = 0

3.货品价格 = -1

4. 货品价格 = 100, 付款金额 = 101

5. 货品价格 = 100, 付款金额 = 99

6. 货品价格 = 50, 付款金额 = 100

7. 货品价格 = 51, 付款金额 = 100

8. 货品价格 = 90, 付款金额 = 100

9. 货品价格 = 91, 付款金额 = 100

10. 货品价格 = 95, 付款金额 = 100

11. 货品价格 = 96, 付款金额 = 100

12. 货品价格 = 99, 付款金额 = 100

13. 货品价格 = 100, 付款金额 = 100

4.划分等价类的方法
  1)在输入条件规定了取值范围或值的个数的情况下,则可以确立一个有效等价类和两个无效等价类。如：输入值是学生成绩，范围是0～100；

  2)在输入条件规定了输入值的集合或者规定了"必须如何"的条件的情况下,可确立一个有效等价类和一个无效等价类；
  3)在输入条件是一个布尔量的情况下,可确定一个有效等价类和一个无效等价类。
  4)在规定了输入数据的一组值（假定n个）,并且程序要对每一个输入值分别处理的情况下,可确立n个有效等价类和一个无效等价类。
    例：输入条件说明学历可为:专科、本科、硕士、博士四种之一，则分别取这四种这四个值作为四个有效等价类，另外把四种学历之外的任何学历作为无效等价类。
  5)在规定了输入数据必须遵守的规则的情况下,可确立一个有效等价类（符合规则）和若干个无效等价类（从不同角度违反规则）；
  6)在确知已划分的等价类中各元素在程序处理中的方式不同的情况下,则应再将该等价类进一步的划分为更小的等价类。
 
5.设计测试用例
  在确立了等价类后,可建立等价类表,列出所有划分出的等价类输入条件：有效等价类、无效等价类，然后从划分出的等价类中按以下三个原则设计测试用例：
  1)为每一个等价类规定一个唯一的编号；
  2)设计一个新的测试用例,使其尽可能多地覆盖尚未被覆盖地有效等价类,重复这一步，直到所有的有效等价类都被覆盖为止；
  3)设计一个新的测试用例,使其仅覆盖一个尚未被覆盖的无效等价类,重复这一步，直到所有的无效等价类都被覆盖为止。
 
二.实战演习
1.某程序规定："输入三个整数 a 、 b 、 c 分别作为三边的边长构成三角形。通过程序判定所构成的三角形的类型，当此三角形为一般三角形、等腰三角形及等边三角形时，分别作计算 … "。用等价类划分方法为该程序进行测试用例设计。（三角形问题的复杂之处在于输入与输出之间的关系比较复杂。）
  分析题目中给出和隐含的对输入条件的要求：
  （1）整数    （2）三个数    （3）非零数   （4）正数  
  （5）两边之和大于第三边     （6）等腰     （7）等边
   如果 a 、 b 、 c 满足条件（ 1 ） ~ （ 4 ），则输出下列四种情况之一：
   1)如果不满足条件（5），则程序输出为 " 非三角形 " 。
   2)如果三条边相等即满足条件（7），则程序输出为 " 等边三角形 " 。
   3)如果只有两条边相等、即满足条件（6），则程序输出为 " 等腰三角形 " 。
   4)如果三条边都不相等，则程序输出为 " 一般三角形 " 。
   列出等价类表并编号

2.设有一个档案管理系统，要求用户输入以年月表示的日期。假设日期限定在1990年1月~2049年12月，并规定日期由6位数字字符组成，前4位表示年，后2位表示月。现用等价类划分法设计测试用例，来测试程序的"日期检查功能"。
  1)划分等价类并编号,下表等价类划分的结果

  2)设计测试用例，以便覆盖所有的有效等价类在表中列出了3个有效等价类，编号分别为①、⑤、⑧，设计的测试用例如下：
    测试数据    期望结果      覆盖的有效等价类
    200211      输入有效      ①、⑤、⑧
  3)为每一个无效等价类设计一个测试用例，设计结果如下：
    测试数据   期望结果     覆盖的无效等价类
    95June     无效输入          ②
    20036      无效输入          ③
    2001006   无效输入          ④
    198912     无效输入          ⑥
    200401     无效输入          ⑦
    200100     无效输入          ⑨
    200113     无效输入          ⑩
   
3.NextDate 函数包含三个变量：month 、 day 和 year ，函数的输出为输入日期后一天的日期。 例如，输入为 2006年3月 7日，则函数的输出为 2006年3月8日 。要求输入变量 month 、 day 和 year 均为整数值，并且满足下列条件：
  ①1≤month≤12
  ②1≤day≤31
  ③1920≤year≤2050 
  1)有效等价类为：
    M1＝{月份：1≤月份≤12}
    D1＝{日期：1≤日期≤31}
    Y1＝{年：1812≤年≤2012}
  2)若条件 ① ~ ③中任何一个条件失效，则 NextDate 函数都会产生一个输出，指明相应的变量超出取值范围，比如 "month 的值不在 1-12 范围当中 " 。显然还存在着大量的 year 、 month 、 day 的无效组合， NextDate 函数将这些组合作统一的输出： " 无效输入日期 " 。其无效等价类为：
    M2＝{月份：月份<1}
    M3＝{月份：月份>12}
    D2＝{日期：日期<1}
    D3＝{日期：日期>31}
    Y2＝{年：年<1812}
    Y3＝{年：年>2012}
  弱一般等价类测试用例
  月份    日期       年               预期输出
   6       15        1912           1912年6月16日
  强一般等价类测试用例同弱一般等价类测试用例
  注：弱--有单缺陷假设；健壮--考虑了无效值
 
  (一)弱健壮等价类测试
  用例ID   月份  日期    年          预期输出
  WR1      6      15    1912      1912年6月16日
  WR2     -1     15    1912      月份不在1～12中
  WR3     13     15    1912      月份不在1～12中
  WR4      6      -1    1912      日期不在1～31中
  WR5      6      32    1912      日期不在1～31中
  WR6      6      15    1811      年份不在1812～2012中
  WR7      6      15    2013      年份不在1812～2012中

  (二)强健壮等价类测试
  用例ID   月份    日期      年          预期输出
  SR1       -1      15       1912      月份不在1～12中
  SR2        6      -1        1912      日期不在1～31中
  SR3        6      15       1811      年份不在1812～2012中
  SR4       -1      -1       1912      两个无效一个有效
  SR5        6      -1        1811      两个无效一个有效
  SR6       -1      15       1811      两个无效一个有效
  SR7       -1      -1       1811      三个无效
 
4.佣金问题等价类测试用例，它是根据佣金函数的输出值域定义等价类，来改进测试用例集合。
输出销售额≤1000元     佣金10％
1000<销售额≤1800     佣金=100+(销售额-1000)*15%
销售额>1800              佣金=220+(销售额-1800)*20%
测试用例         枪机(45)    枪托(30)      枪管(25)          销售额     佣金
    1               5             5                5                  500        50
    2              15           15              15                 1500       175
    3              25           25              25                 2500       360
根据输出域选择输入值，使落在输出域等价类内，可以结合弱健壮测试用例结合。