基于粒子群算法的软件测试用例自动生成算法

成功的软件测试是尽可能排除错误、提高软件质量的重要保证。然而，随着软件规模的增大，人工测试已变得困难，自动测试的重要性不言而喻。自动测试的成效与自动测试用例密不可分。

软件测试用例自动生成算法是一种依照软件测试用例规格需求和测试目标要求自动生成软件测试用例的方法。长期以来，软件测试用例生成主要依靠手工完成，这意味着软件测试人员需要具备丰富的经验和较高的专业水平。这导致实际工程软件测试用例生成往往带有很大的盲目性，软件测试用例数量多、测试效果差、测试成本高。因此，如何科学有效地通过软件测试用例自动生成算法，依据软件规格或程序结构自动构造软件测试用例成为软件测试的研究重点之一^[2]。多年来，许多研究者对软件测试用例自动生成进行了广泛而深入的研究，并取得了大量的研究成果。

1 基本粒子群算法

粒子群算法是从随机解出发，通过迭代寻找最优解，通过适应度来评价解的品质，通过追随当前搜索到的最优值来寻找全局最优。这种算法以其实现容易、精度高、收敛快等优点引起了学术界的重视，并且在解决实际问题中展示了其优越性。

粒子群算法源于对鸟群觅食行为的过程模拟，种群中每个粒子代表着一个潜在的可行解，粒子们在解空间中搜索食物的位置即全局最优解，粒子的运动速度与方向通过群体中最优粒子的位置来确定。粒子群算法的数学描述如下：

假设种群规模 (总粒子数)为r，搜索空间为m维，在迭代时刻t，第i个粒子的当前坐标位置可以表示为

   

从(5)式可以看出，当粒子当前位置与局部极值以及全局极值差距较大时，粒子的速度增加得会很快，这样有利于减少迭代次数，节约迭代时间；相反，当粒子当前位置与局部极值以及全局极值差距较小时，粒子的速度增加得会很慢，这样有利于防止因速度太快而越过极值点，但同时也可能因速度过慢而早熟，陷入局部最优。

粒子群算法的基本框架如图1：

图1粒子群算法流程图

2 基于粒子群算法的软件测试用例自动生成实例

以三角形类型判断程序为例，用粒子群算法进行软件测试数据自动生成实验。

初始种群规模n=100，第i个粒子可以表示为，代表第i个三角形三边长度。其中，每条边的长度都是一个1到100之间随机产生的整数。

如果这100个粒子是随机生成而未经任何处理的，那么，要生成一个等边三角形的概率为1/(100*100*100)，而粒子群算法的贡献就在于，通过适应度函数的调节，尽量抑制非三角形的数量，增加等边三角形、等腰三角形的数量，从而使得在测试用例有限的情况下，尽量出现等边三角形和等腰三角形。

在实现粒子群算法是，不得不考虑的是适应度函数的构造。适应度函数用于评估测试用例在搜索空间中对测试目标的接近程度，适应度函数是粒子群算法应用于求解问题的优化目标，它的构造直接影响粒子群算法在具体问题上的效率。适应度函数是对测试用例的一种调节，它使测试用例朝着测试者希望的方向生成。本文采用“分支函数叠加法”构造适应值函数。

构造的适应度函数如下：

         static float fit(int a,int b,int c)

         {       float f1=0, f2=0, f3=0, f4=0;

                   floatf;

                   if(a+b>c&& b+c>a || a+c>b)

                   {       if( a==b && b==c )

                                     f1 = 1; // 分支 函数插装

                            elseif ( a==b || b==c || c==a )              f2=((Math.abs(a-b)+Math.abs(b-c)+Math.abs(a-c))/(3*Math.max(Math.max(Math.abs(a-b),Math.abs(b-c)),Math.abs(a-c))));//  分支函数插装

                            elsef3 = ((Math.abs(a-b)+Math.abs(b-c) +Math.abs(a-c))/(3*Math.max( Math.max(Math.abs(a-b),Math.abs(b-c)),Math.abs(a-c ))));

}

                   elsef4=0;

                   f=f1+f2+f3+f4;

                   returnf;

                   }

实现代码

package 粒子群算法;

publicclass粒子群算法test{

staticfloatr1= 1;

staticfloatr2= 1;

staticfloat[][]v=newfloat[100][3];

staticfloat[]fitness=newfloat[100];

staticfloat[][]tri1=newfloat[100][3];

staticfloat[]pbest=newfloat[100];

staticfloat[]pbest1=newfloat[100];

privatestaticfloatxpbest[][]=newfloat[100][3];

privatestaticfloatxgbest[]=newfloat[3];

staticfloatgbest= 0;

staticint[]num=newint[4];

publicstaticvoidmain(String[] args){for(int i = 0;i<4;i++)

        num[i]=0;

        //生成速度以及粒子位置

    for(int i=0;i<100;i++){

    for(int j=0;j<3;j++){

        tri1[i][j] =(int)(Math.random()*99+1);         v[i][j]=(int)(10*Math.random());

    }

        }          

        //初始化

    for(int i=0;i<100;i++)

    {   pbest[i] = 0;

        xpbest[i][0]=tri1[i][0];

        xpbest[i][1]=tri1[i][1];

        xpbest[i][2]=tri1[i][2];

    }

        xgbest[0]=0;

        xgbest[1]=0;

        xgbest[2]=0;       

        //做20次迭代

    for(int k=0;k<20;k++){

        //粒子群算法

        for(int i = 0;i<100;i++){

            fitness[i] =fit((int)tri1[i][0],(int)tri1[i][1],(int)tri1[i][2]);

            pbest1[i] =fit((int)xpbest[i][0],(int)xpbest[i][1],(int)xpbest[i][2]);

    if(fitness[i]>=pbest1[i])

        {   pbest[i]=fitness[i];

            xpbest[i][0]=tri1[i][0];

            xpbest[i][1]=tri1[i][1];

            xpbest[i][2]=tri1[i][2];

          }

    if(pbest[i]>gbest)

    {gbest=pbest[i]            xgbest[0]=xpbest[i][0];            xgbest[1]=xpbest[i][1];

        xgbest[2]=xpbest[i][2];

        }      

        }

        for(int i=0;i<100;i++)

        {    for(int j=0;j<3;j++)

           {

    v[i][j]=v[i][j]+r1*(xpbest[i][j]-tri1[i][j])+r2*(xgbest[j]-tri1[i][j]);                tri1[i][j]=tri1[i][j]+v[i][j];

          }  

    }

    for(int i = 0;i<100;i++)

    {

        for(int j=0;j<3;j++)

    System.out.print(xpbest[i][j]+"   ");

    System.out.println();  

            }

        }

    for(int i=0;i<100;i++){

    if(xpbest[i][0]+xpbest[i][1]>xpbest[i][2]&&

    xpbest[i][2]+xpbest[i][1]>xpbest[i][0]                      &&xpbest[i][0]+xpbest[i][2]>xpbest[i][1]){               if(xpbest[i][0]==xpbest[i][1]&&xpbest[i][0]==xpbest[i][2])

    num[0]++;//等边

    elseif(xpbest[i][0]==xpbest[i][1]||xpbest[i][0]==xpbest[i][2]||xpbest[i][1]==xpbest[i][2])

    num[1]++;//等腰

    else

        num[2]++;//普通

            }

    else

        num[3]++;//非三角形

        }

    System.out.println();

    System.out.println(num[0]+"**"+num[1]+"**"+num[2]+"**"+num[3]);

    }  

    //适应度函数

    staticfloat fit(int a,int b,int c)

    {   float f1=0, f2=0, f3=0, f4=0;

        float f;

        if(a+b>c &&b+c>a || a+c>b)

        {if( a==b && b==c )

                f1= 1; // 分支函数插装

        elseif ( a==b || b==c || c==a)

    f2=((Math.abs(a-b)+Math.abs(b-c)+Math.abs(a-c))/    (3* Math.max(Math.max(Math.abs(a-b),Math.abs(b-c)),Math.abs(a-c))));// 分支函数插装

else f3 = ((Math.abs(a-b)+Math.abs(b-c) +Math.abs(a-c))/(3*Math.max( Math.max(Math.abs(a-b),Math.abs(b-c)),Math.abs(a-c ))));

}

    else f4=0;

    f=f1+f2+f3+f4;

    return f;

    }

}