📄 firstdlg.cpp
字号:
{
if(vec_TC_Node[kk].Node==vect1[kkk])break;
else if(kkk==vect1.size()-1)
vect1.push_back(vec_TC_Node[kk].Node);
}
}
//显示分化后的vec_TC_Node文件
xmlNode.AddElem("节点");
xmlNode.IntoElem();
xmlNode.AddElem("TestedNode",vect1.size());
float ratio=(100*vect1.size())/50;
xmlNode.AddElem("TestedRatio",ratio);
for(int tt=0;tt<vec_TC_Node.size();tt++)
{
xmlNode.AddElem("TC");
xmlNode.AddAttrib("TC_ID",vec_TC_Node[tt].tcid);
xmlNode.AddAttrib("Node",vec_TC_Node[tt].Node);
xmlNode.AddAttrib("time",vec_TC_Node[tt].time);
xmlNode.AddAttrib("reverse",vec_TC_Node[tt].reverse);
}
xmlNode.OutOfElem();
xmlNode.Save("xmlNode.xml");
//显示分化后的vec_TC_Seg文件
xmlSeg.AddElem("段");
xmlSeg.IntoElem();
for(int mm=0;mm<vec_TC_Seg.size();mm++)
{
xmlSeg.AddElem("TC");
xmlSeg.AddAttrib("TC_ID",vec_TC_Seg[mm].tcid);
xmlSeg.AddAttrib("segment",vec_TC_Seg[mm].segment);
xmlSeg.AddAttrib("time",vec_TC_Seg[mm].time);
}
xmlSeg.OutOfElem();
xmlSeg.Save("xmlSeg.xml");
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
//使用贪心算法对测试用例集进行优化
xmlMinGreedy.AddElem("TS");
xmlMinGreedy.IntoElem();
// xmlMinGreedy.AddElem("优化后的用例");
vect2.push_back(vec_TC_Node[0].Node);
int node_time=0;
while(vect2.size()*100/50<98)
{
int max=0;
int id=0;
int id_temp=0;
// int index=0;//当前第index个TC符合要求
// int
// float ratio_before=0;
// float ration_back=0;
for(int j=0;(j<TestSuite.size())&&(TestSuite[j].TC_Node_Count!=0);j++)
{//对于TestSuite检查
int ratio_middle=0;
for(int jj=0;jj<TestSuite[j].TC_Node_Count;jj++)//TestSuite中每个用例TC
{
for(int jjj=0;jjj<vect2.size();jjj++)
{//检查是否与vect1中某个值相同
if(TestSuite[j].NodeList[jj]==vect2[jjj])break;//若此数据已经存在，检查TC中下一个Node
else if(jjj==(vect2.size()-1))
{//记录还未存在的Node个数以及这些Node对应的TestSuite中的id
ratio_middle++;
id_temp=j;
}
}
}
//找出覆盖率增加最大的用例的id，存放于vect3中
if(max<ratio_middle)
{
max=ratio_middle;
id=id_temp;
}
else if(max==ratio_middle)
{
if(TestSuite[id].Time>TestSuite[id_temp].Time)
{
max=ratio_middle;
id=id_temp;
}
}
}
vect3.push_back(TestSuite[id].TC_ID);
node_time+=TestSuite[id].Time;
//将当前覆盖率增加最大的用例中的Node加入到vect2中
for(int ijj=0;ijj<TestSuite[id].TC_Node_Count;ijj++)//
for(int ijjj=0;ijjj<vect2.size();ijjj++)
{//
if(TestSuite[id].NodeList[ijj]==vect2[ijjj])break;//
else if(ijjj==vect2.size()-1)
{//
vect2.push_back(TestSuite[id].NodeList[ijj]);
FILE * fp=fopen("aaa.txt","w");
fprintf(fp,"%d",vect2.size());
fclose(fp);
}
}
// xmlMinGreedy.AddChildElem("TCID",TestSuite[id].TC_ID);
// TestSuite[id].TC_Node_Count=0;
}//while(vect2.size()*100/50<85);
xmlMinGreedy.AddElem("总时间",node_time);
xmlMinGreedy.AddElem("优化后的用例");
xmlMinGreedy.AddAttrib("总数",vect3.size());
for(int iijj=0;iijj<vect3.size();iijj++)
{
xmlMinGreedy.AddChildElem("Node",vect3[iijj]);
}
xmlMinGreedy.AddElem("所有被覆盖的节点");
xmlMinGreedy.AddAttrib("总数",vect2.size());
for(int iij=0;iij<vect2.size();iij++)
{
xmlMinGreedy.AddChildElem("Node",vect2[iij]);
}
xmlMinGreedy.OutOfElem();
xmlMinGreedy.Save("xmlMinGreedy.xml");
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
/*
//对vec_TC_Node进行排序
squen_TC_Node.assign(1000,0);
for(int n=0;n<vec_TC_Node.size();n++)
{
vector<TC_Node_Node>::iterator inter_left = squen_TC_Node.begin();// 准备
vector<TC_Node_Node>::iterator inter_right = squen_TC_Node.end();
//int =0;
int left=0;
int right=squen_TC_Node.size()-1;
int middle=0;
while( right >= left)// 二分法查找插入位置
{
middle=(left+right)/2;
inter_Node = squen_TC_Node.begin()+squen_TC_Node.size()/2;
// 指向已排序好的中间位置
if( vec_TC_Node[n].Node < squen_TC_Node[middle].Node )// 即将插入的元素应当在在左区间
{
right = middle-1;
inter_left=inter_Node-1;
}
else // 即将插入的元素应当在右区间
{
left = middle+1;
inter_right=inter_Node+1;
}
}
squen_TC_Node.insert(inter_Node,vec_TC_Node[n]);// 插入
}
//显示squen_TC_Node中的内容
xmlNodeSequen.AddElem("TS");
xmlNodeSequen.IntoElem();
for(int ii=0;ii<squen_TC_Node.size();ii++)
{
xmlNodeSequen.AddElem("TC");
xmlNodeSequen.AddAttrib("TC_ID",squen_TC_Node[ii].tcid);
xmlNodeSequen.AddAttrib("Node",squen_TC_Node[ii].Node);
xmlNodeSequen.AddAttrib("time",squen_TC_Node[ii].time);
}
xmlNodeSequen.OutOfElem();
xmlNodeSequen.Save("xmlNodeSequen.xml");
//对vec_TC_Seg进行排序
for(int m=0;m<vec_TC_Seg.size();m++)
{
vector<TC_Seg_Node>::iterator inter_left = squen_TC_Seg.begin();// 准备
vector<TC_Seg_Node>::iterator inter_right = squen_TC_Seg.end();
int left=0;
int right=squen_TC_Seg.size()-1;
int middle=0;
while( right >= left)// 二分法查找插入位置
{
middle=(left+right)/2;
inter_segment = squen_TC_Seg.begin()+squen_TC_Seg.size()/2;
// 指向已排序好的中间位置
if( vec_TC_Seg[m].segment < squen_TC_Seg[middle].segment )// 即将插入的元素应当在在左区间
{
right = middle-1;
inter_left=inter_segment-1;
}
else // 即将插入的元素应当在右区间
{
left = middle+1;
inter_right=inter_segment+1;
}
}
squen_TC_Seg.insert(inter_segment,vec_TC_Seg[m]);// 插入
}
//显示squen_TC_Seg中的内容
xmlSegSequen.AddElem("TS");
xmlSegSequen.IntoElem();
for(int jj=0;jj<squen_TC_Seg.size();jj++)
{
xmlSegSequen.AddElem("TC");
xmlSegSequen.AddAttrib("TC_ID",squen_TC_Seg[jj].tcid);
xmlSegSequen.AddAttrib("segment",squen_TC_Seg[jj].segment);
xmlSegSequen.AddAttrib("time",squen_TC_Seg[jj].time);
}
xmlSegSequen.OutOfElem();
xmlSegSequen.Save("xmlSegSequen.xml");
*/
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
vector<int> inter_TC;
vector<int> inter_Node;
CMarkup xml_inter_TC;
xml_inter_TC.SetDoc("<?xml version=\"1.0\" encoding=\"GB2312\"?>\r\n");
int put=0;
int putt=0;
inter_TC.push_back(0);
inter_Node.push_back(0);
int total_time=0;
//启发式算法，对Node_TestCase操作,优化测试用例集
for(int k=1;k<12;k++)
{
for(int kk=0;kk<Node_TestCase.size();kk++)
{
for(int jk=0;jk<inter_Node.size();jk++)
{
if(inter_Node[jk]==Node_TestCase[kk].Node_id)break;
else if((jk==inter_Node.size()-1)&&Node_TestCase[kk].TC_count!=0)
inter_Node.push_back(Node_TestCase[kk].Node_id);
}
if(Node_TestCase[kk].TC_count==k)
for(int kkk=0;kkk<k;kkk++)
{
for(int kkkk=0;kkkk!=inter_TC.size();kkkk++)
{
if(inter_TC[kkkk]==Node_TestCase[kk].TC[kkk])break;
else if(kkkk==inter_TC.size()-1)
{
inter_TC.push_back(Node_TestCase[kk].TC[kkk]);
/* for(int ik=0;ik<TestSuite.size();ik++)
{
if(TestSuite[ik].TC_ID==Node_TestCase[kk].TC[kkk])
total_time+=TestSuite[ik].Time;
}*/
// inter_TC[put++]=Node_TestCase[kk].TC[kkk];//[put++]=;
}
}
}
}
}
//输出最优化后的用例集合
for(int ik=0;ik<inter_TC.size();ik++)
for(int ikk=0;ikk<TestSuite.size();ikk++)
{
if(TestSuite[ikk].TC_ID==inter_TC[ik])
total_time+=TestSuite[ikk].Time;
}
xml_inter_TC.AddElem("TS");
xml_inter_TC.IntoElem();
xml_inter_TC.AddElem("All_TC");
xml_inter_TC.AddAttrib("TC_Count",inter_TC.size()-1);
xml_inter_TC.AddAttrib("total_time",total_time);
xml_inter_TC.IntoElem();
for(int c=1;c<inter_TC.size();c++)
{
// xml_inter_TC.AddChildElem("TC",inter_TC[c]);
xml_inter_TC.AddElem("TC",inter_TC[c]);//.AddChildAttrib();
}
xml_inter_TC.OutOfElem();
xml_inter_TC.AddElem("All_Node");
xml_inter_TC.AddAttrib("Node_count",inter_Node.size()-1);
for(int cc=1;cc<inter_Node.size();cc++)
{
xml_inter_TC.AddElem("Node",inter_Node[cc]);
}
xml_inter_TC.OutOfElem();
xml_inter_TC.Save("xml_inter_TC.xml");
///////////////////////////////////////////////////////////////////////////////////////////////////
//对Node进行最小化操作,使用启发式算法Heuristic
/*
// int mmm= vec_TC_Node.size();
// int nnn = vec_TC_Node[0].reverse;
xmlMinHeur.AddElem("TS");
xmlMinHeur.IntoElem();
// int k=0;
// bool hhh=(k<vec_TC_Node.size())&(vec_TC_Node[k].reverse);)&&(vec_TC_Node[k].reverse==2)
for(int k=0;k<vec_TC_Node.size();k++)
{
if(vec_TC_Node[k].reverse==2)
{
// int flag=vec_TC_Node[k].reverse;
for(int kk=k+1;kk<vec_TC_Node.size();kk++)
{
int vec=vec_TC_Node[k].Node;
int veck=vec_TC_Node[kk].Node;
// bool v=(bool)(vec>veck);
if(vec==veck)
{
if(vec_TC_Node[k].time>vec_TC_Node[kk].time)
{
vec_TC_Node[k].reverse=0;
vec_TC_Node[kk].reverse=1;
}
else if(vec_TC_Node[k].time==vec_TC_Node[kk].time)
{
vec_TC_Node[k].reverse=1;
vec_TC_Node[kk].reverse=1;
}
else
{
vec_TC_Node[k].reverse=1;
vec_TC_Node[kk].reverse=0;
}
}
}
}
}
// vec_TC_Node.iterator iter=vec_TC_Node.begin();
//显示优化一次后的vec_TC_Node文件
xmlMinHeur.AddElem("TS");
xmlMinHeur.IntoElem();
for(int kkk=0;(kkk<vec_TC_Node.size());kkk++)
{
if(vec_TC_Node[kkk].reverse==1)
{
// bool v=(kkk<vec_TC_Node.size())&&(vec_TC_Node[kkk].reverse);
//vec_TC_Node.erase(vec_TC_Node.begin());
xmlMinHeur.AddElem("TC");
xmlMinHeur.AddAttrib("TC_ID",vec_TC_Node[kkk].tcid);
xmlMinHeur.AddAttrib("Node",vec_TC_Node[kkk].Node);
xmlMinHeur.AddAttrib("time",vec_TC_Node[kkk].time);
xmlMinHeur.AddAttrib("reverse",vec_TC_Node[kkk].reverse);
}
}
xmlMinHeur.OutOfElem();
xmlMinHeur.Save("xmlMinHeur.xml");
///////////////////////////////////////////////////////////////////////////////////////////////////
//评估输出测试覆盖情况，以及所用时间
//代码覆盖率
// if()
*/
}
///////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////
/*
void CFirstDlg::BinInsert(vector<TC_Node_Node> TS1,TC_Node_Node TC)
{
int left,right;
int middle;
for(int i=0;i<TS1.size();i++)
{
left = 0;// 准备
right = TS1.size()-1;
while( right >= left)// 二分法查找插入位置
{
middle = ( left + right ) / 2; // 指向已排序好的中间位置
if( TC.Node < TS1[middle].Node )// 即将插入的元素应当在在左区间
right = middle-1;
else // 即将插入的元素应当在右区间
left = middle+1;
}
TS1.insert(middle,TC);// 插入
}
}
*/
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -