Wie Python den Organisationsalgorithmus paarweise implementiert (effiziente Testfälle)

Der folgende Editor stellt Ihnen eine Python-Implementierungsmethode für einen effizienten Algorithmus zur paarweisen Organisation von Testfällen vor. Der Herausgeber findet es ziemlich gut, deshalb werde ich es jetzt mit Ihnen teilen und es allen als Referenz geben. Folgen wir dem Herausgeber und werfen wir einen Blick darauf.

Eröffnung:

Während des Testprozesses werden Testfälle für den Fall mehrerer Parameterparameter mit mehreren Werten. Ich habe [Orthogonale Analysemethode] verwendet, um Anwendungsfälle zu organisieren. Um es ganz klar auszudrücken: Es bedeutet, eine vollständige Kombination aller Werte jedes Parameters mit den Werten zu erstellen ​anderer Parameter wird mit einem Python-Skript implementiert, bei dem es sich um die Produktmethode (auch als Flute bezeichnet) im Itertools-Modul handelt.

Der Vorteil der orthogonalen Analysemethode besteht darin, dass die Testfallabdeckungsrate 100 % beträgt. Der Nachteil besteht darin, dass die Anzahl der Testfälle enorm ist und der Arbeitsaufwand für die Ausführung der Anwendungsfälle enorm ist.

Der paarweise Algorithmus ist aus der Optimierung traditioneller orthogonaler Analysemethoden abgeleitet und seine Theorie stammt aus der mathematischen Statistik. Ehrlich gesagt kann ich keine wissenschaftlichen Arbeiten zur mathematischen Statistik lesen, daher kann ich im Internet nur einige beliebte und einfache Erklärungen finden, um deren grundlegende Bedeutung zu verstehen.

Viele Leute im Internet verwenden [Betriebssystem, Browser, Sprachumgebung] als Beispiele:

Betriebssystem: W (Windows), L (Linux), Mac (Mac); Browser: M (Firefox), O (Opera), IE; Sprachumgebung: C (Chinesisch), E (Englisch)

Gemäß der orthogonalen Analysemethode: 3x3x2 wird generiert =18 Kombinationsmethoden, Testfallabdeckung 100 %.

Die Methode der paarweisen Testfallorganisation kann in 9 Kombinationen komprimiert werden. Daher besteht der Nachteil darin, dass die Anzahl der Testfälle gering ist, und der Nachteil besteht darin, dass definitiv Tests verpasst werden.

Einführung:

Das Kernkonzept des Pairwise-Algorithmus

1. Eine Reihe von Testfällen (jeder Anwendungsfall besteht aus 3 Parameterwerten, z. B. [W, M, C]). Jeweils 2 Elemente werden kombiniert, und wenn sie paarweise kombiniert werden, gibt es 3 Kombinationen (positioniert) [W, M][W,C][M,C]);

2 Wenn dieser erste Satz von Tests drei Kombinationen von zwei mal zwei verwendet, lautet das Vergleichsprinzip: [W,M] Es wird nur sein mit dem ersten Element in anderen Gruppen verglichen, und [W,C] wird nur mit dem zweiten Element in anderen Gruppen verglichen. . . . ;

[W,M][W,C][M,C] Diese drei Elemente erscheinen in den Elementen mit derselben Position in den verbleibenden gültigen Gruppen, sodass diese Gruppe von Fällen als redundante Fälle betrachtet werden kann , und zu löschen.

Erklärung des Substantivs: [Effektive Gruppe] bedeutet eine Gruppe, die nicht gelöscht wurde, und eine Gruppe, die nicht verglichen wurde. Beispiel: Wenn die Gruppen 1 und 3 gelöscht werden, sind die effektiven Gruppen, die mit Gruppe 4 verglichen werden sollen, die Gruppen 2, 5, 6, 7...18. Die effektive Gruppe ist hier durch die Grube gegangen%>_<%

3. Schließlich wird der Testfall erhalten, bei dem es sich um den optimalen Satz von Testfällen handelt, die vom Paarungsalgorithmus berechnet wurden.

Brillanter akademischer Beweis

Pairwise wurde erstmals 1927 von L. L. Thurstone (29. Mai 1887 – 30. September 1955) vorgeschlagen. Er ist ein amerikanischer Psychostatistiker. Pairwise ist ebenfalls ein Produkt, das auf mathematischer Statistik und der Optimierung traditioneller orthogonaler Analysemethoden basiert.

Pairwise basiert auf den folgenden zwei Annahmen:

(1) Jede Dimension ist orthogonal, das heißt, jede Dimension ist unabhängig von jeder andere. Kreuzung.

(2) Laut mathematisch-statistischer Analyse werden 73 % der Mängel (Einzelfaktor 35 %, Doppelfaktor 38 %) durch einen einzelnen Faktor oder das Zusammenspiel zweier Faktoren verursacht. 19 % der Mängel werden durch das Zusammenspiel von 3 Faktoren verursacht.

Daher wird paarweise basierend auf dem kostengünstigsten Satz von Anwendungsfällen generiert, die durch das Zusammenspiel aller beiden Faktoren generiert werden.

Text

1. Ideen

Ein Testszenario Wie Um von der Eingabe der getesteten Bedingungen bis zur Erstellung paarweiser Testfälle zu beginnen, lauten die Programmierideen mit Python wie folgt:

1. Setze allparams=[['M','O','P'],[' W ','L','I'],['C','E']] führen eine vollständige Kombinationsverarbeitung für kartesische Produkte durch, um ein eindimensionales Array (len=N) des vollständigen Satzes von Testfällen zu generieren, die von der regulären Funktion generiert werden Analysemethode;

2. Jeder Testfall im gesamten Testfallsatz wird in zwei Kombinationen zerlegt, um ein zweidimensionales Array mit der gleichen Länge wie der gesamte Testfallsatz zu erzeugen (eindimensionale Länge =). N);

3. Verwenden Sie die Python-Version des Pairwise-Algorithmus, um ungültige Testfälle zu eliminieren und schließlich einen Satz effektiver gepaarter Testfälle zu erhalten werden mit Pythons eigener mathematischer Berechnungsbibliothek itertools geschrieben, und der dritte Code Die Funktion ist der Code, den ich mir ausgedacht habe.

2. Laden Sie den Code direkt hoch

# -*- coding: utf-8 -*-
from datetime import *
import random,os,copy,time
import logging
import itertools
'''
#Author:Kuzaman
#Time:2017-07-18
'''
class utils2 :
 #1、笛卡尔积 对参数分组全排列
 def product(self,tuple1):
  newlist=[]
  for x in eval('itertools.product'+str(tuple(tuple1))):
   newlist.append(x)
  return newlist 
 
 #2、对笛卡尔积处理后的二维原始数据进行N配对处理，得到Pairwise计算之前的数据
 def get_pairslist(self,lista):
  pwlist = []
  for i in lista:
   subtemplist = []
   for sublista in itertools.combinations(i, 2):
    subtemplist.append(sublista)
   pwlist.append(subtemplist)
  return pwlist
 
 #3、进行Pirwise算法计算
 def pairwise(self,listb):
  sublistlen = len(listb[1])
  flag = [0]*sublistlen
  templistb = copy.deepcopy(listb)
  delmenu = []
  holdmenu=[]
  self.pprint (listb)
  print ('--'*25)
  for lb in listb:
   for sublb in lb: 
    for k in templistb:
     Xa = lb.index(sublb)
     Ya = listb.index(lb)
     if k != lb and sublb == k[Xa]:
      # print (sublb,'===>' ,k[Xa],'相等了。。。')
      flag[Xa] = 1
      break
     else:
      # print (sublb,'===>' ,k[Xa],'不不不等了。。。')
      flag[Xa] = 0
   # print ('下标%d,子元素 %s 双匹配对比结果flag:%s'%(listb.index(lb),lb,flag))
   if 0 not in flag:
    num = listb.index(lb)
    delmenu.append(num)
    templistb.remove(lb)
    # print ('下标为%d行应删除,内容=%s,'%(num,lb))
    # print ('delmenu:',delmenu)
   else:
    num2 = listb.index(lb)
    holdmenu.append(num2)
    # print ('下标为%d行应保留,内容=%s,'%(num2,lb))
    # print('holdmenu=',holdmenu)
   # print ('***'*20)
  print ('保留元素列表：%s \n匹配重复元素列表：%s'%(holdmenu,delmenu))
  return templistb

 def pwresult(self,slist,delmenu):
  for x in delmenu:
   slist.remove(slist[x])
  return slist

 def pprint(self,list):
  for i in list:
   print ('line %d:'%(list.index(i)+1),i)  

if __name__ == '__main__':
 u2 = utils2()
 allparams=[['M','O','P'],['W','L','I'],['C','E']]#,'K'],[1,2,3],['Yes','No']]
 str = u2.product(allparams)
 strpc = u2.get_pairslist(str)
 finallist = u2.pairwise(strpc)
 print('最终保留测试用例个数：%d 个'%(len(finallist)))
 u2.pprint(finallist)

Codeinterpretation : Die dritte for-Schleifencodezeile 39–48 dient hauptsächlich der vertikalen Bestimmung, ob das zu erkennende Element und das Element an derselben Position denselben Wert haben

Der zweite for-Schleifencode 38 ~Zeile 48, paart die beiden Testfälle in einer Gruppe und vergleicht sie mit den Elementen an derselben Position von links nach rechts

Der erste for-Schleifencode, Zeilen 37~48, durchläuft jede Gruppe von Testfällen.

第50~58行代码，判断一组用例的两两配对在其他组同位置上从上到下都能找到相同元素，则将改无效Case从templistb中删除，保持templistb的有效性。

执行结果：

line 1: [(&#39;M&#39;, &#39;W&#39;), (&#39;M&#39;, &#39;C&#39;), (&#39;W&#39;, &#39;C&#39;)]  <---第二个函数get_pairslist(self,lista)处理后的两两配对组合
line 2: [(&#39;M&#39;, &#39;W&#39;), (&#39;M&#39;, &#39;E&#39;), (&#39;W&#39;, &#39;E&#39;)]  <---同第一行解释
line 3: [(&#39;M&#39;, &#39;L&#39;), (&#39;M&#39;, &#39;C&#39;), (&#39;L&#39;, &#39;C&#39;)]
line 4: [(&#39;M&#39;, &#39;L&#39;), (&#39;M&#39;, &#39;E&#39;), (&#39;L&#39;, &#39;E&#39;)]
line 5: [(&#39;M&#39;, &#39;I&#39;), (&#39;M&#39;, &#39;C&#39;), (&#39;I&#39;, &#39;C&#39;)]
line 6: [(&#39;M&#39;, &#39;I&#39;), (&#39;M&#39;, &#39;E&#39;), (&#39;I&#39;, &#39;E&#39;)]
line 7: [(&#39;O&#39;, &#39;W&#39;), (&#39;O&#39;, &#39;C&#39;), (&#39;W&#39;, &#39;C&#39;)]
line 8: [(&#39;O&#39;, &#39;W&#39;), (&#39;O&#39;, &#39;E&#39;), (&#39;W&#39;, &#39;E&#39;)]
line 9: [(&#39;O&#39;, &#39;L&#39;), (&#39;O&#39;, &#39;C&#39;), (&#39;L&#39;, &#39;C&#39;)]
line 10: [(&#39;O&#39;, &#39;L&#39;), (&#39;O&#39;, &#39;E&#39;), (&#39;L&#39;, &#39;E&#39;)]
line 11: [(&#39;O&#39;, &#39;I&#39;), (&#39;O&#39;, &#39;C&#39;), (&#39;I&#39;, &#39;C&#39;)]
line 12: [(&#39;O&#39;, &#39;I&#39;), (&#39;O&#39;, &#39;E&#39;), (&#39;I&#39;, &#39;E&#39;)]
line 13: [(&#39;P&#39;, &#39;W&#39;), (&#39;P&#39;, &#39;C&#39;), (&#39;W&#39;, &#39;C&#39;)]
line 14: [(&#39;P&#39;, &#39;W&#39;), (&#39;P&#39;, &#39;E&#39;), (&#39;W&#39;, &#39;E&#39;)]
line 15: [(&#39;P&#39;, &#39;L&#39;), (&#39;P&#39;, &#39;C&#39;), (&#39;L&#39;, &#39;C&#39;)]
line 16: [(&#39;P&#39;, &#39;L&#39;), (&#39;P&#39;, &#39;E&#39;), (&#39;L&#39;, &#39;E&#39;)]
line 17: [(&#39;P&#39;, &#39;I&#39;), (&#39;P&#39;, &#39;C&#39;), (&#39;I&#39;, &#39;C&#39;)]
line 18: [(&#39;P&#39;, &#39;I&#39;), (&#39;P&#39;, &#39;E&#39;), (&#39;I&#39;, &#39;E&#39;)]  <----同第一行解释
--------------------------------------------------
保留元素列表：[1, 3, 4, 7, 9, 10, 12, 14, 17]  <----有效用例在数组中下标
匹配重复元素列表：[0, 2, 5, 6, 8, 11, 13, 15, 16]  <----被剔除的无效测试用例在数组中下标
最终保留测试用例个数：9 个
line 1: [(&#39;M&#39;, &#39;W&#39;), (&#39;M&#39;, &#39;E&#39;), (&#39;W&#39;, &#39;E&#39;)]
line 2: [(&#39;M&#39;, &#39;L&#39;), (&#39;M&#39;, &#39;E&#39;), (&#39;L&#39;, &#39;E&#39;)]
line 3: [(&#39;M&#39;, &#39;I&#39;), (&#39;M&#39;, &#39;C&#39;), (&#39;I&#39;, &#39;C&#39;)]
line 4: [(&#39;O&#39;, &#39;W&#39;), (&#39;O&#39;, &#39;E&#39;), (&#39;W&#39;, &#39;E&#39;)]
line 5: [(&#39;O&#39;, &#39;L&#39;), (&#39;O&#39;, &#39;E&#39;), (&#39;L&#39;, &#39;E&#39;)]
line 6: [(&#39;O&#39;, &#39;I&#39;), (&#39;O&#39;, &#39;C&#39;), (&#39;I&#39;, &#39;C&#39;)]
line 7: [(&#39;P&#39;, &#39;W&#39;), (&#39;P&#39;, &#39;C&#39;), (&#39;W&#39;, &#39;C&#39;)]
line 8: [(&#39;P&#39;, &#39;L&#39;), (&#39;P&#39;, &#39;C&#39;), (&#39;L&#39;, &#39;C&#39;)]
line 9: [(&#39;P&#39;, &#39;I&#39;), (&#39;P&#39;, &#39;E&#39;), (&#39;I&#39;, &#39;E&#39;)]
[Finished in 0.2s]

三、代码核心内容白话解释

pairwise(self,listb)函数包含3层for循环，先画一个二维数组：

i[0]  i[1]  i[2]
listb.index(i)=0 : [('M', 'W'), ('M', 'C'), ('W', 'C')]
listb.index(i)=1 : [('M', 'W'), ('M', 'E'), ('W', 'E')]
listb.index(i) : [('M', 'L'), ('M', 'C'), ('L', 'C')]
listb.index(i) : [('M', 'L'), ('M', 'E'), ('L', 'E')]
listb.index(i) : [('M', 'I'), ('M', 'C'), ('I', 'C')]
listb.index(i) : [('M', 'I'), ('M', 'E'), ('I', 'E')]
listb.index(i) : [('O', 'W'), ('O', 'E'), ('W', 'E')]
listb.index(i) : [('O', 'L'), ('O', 'C'), ('L', 'C')]
listb.index(i) : [('O', 'L'), ('O', 'E'), ('L', 'E')]
listb.index(i) : [('O', 'I'), ('O', 'C'), ('I', 'C')]
listb.index(i)=n : [('O', 'I'), ('O', 'E'), ('I', 'E')]

二维列表 listb ，其中的行（发音：hang，二声。横着的那排）从上到下就是第一层for循环 ；每一行中的i[0],i[1],i[2]就是第二层for循环从左至右；第三次for循环元素i[x]从上之下与有效组 templistb通位置元素的对比。

1、第n行的i[0]要和有效templistb的其他行的i[0]元素对比（第三for），如果有相等的，记录一个标识 如 flag1=True，如果没有相等的记录falg1=False；

2、直到第二for中的i[0],i[1],i[2]都进行对比后，会得到 [flag1，flag2,flag3 ]，所有flag=True则该行为无效用例

3、第一for遍历全部组合，最终得到保留下来的有效templistb

见图：

完结篇

以上是自己编写的pairwise的全部内容，此算法共耗时3天：

第一天在确定这究竟是什么算法，看了很多学术文献，看不懂；

第二天开始写程序，for的嵌套循环设计耽误很久；

第三天程序成型，有执行结果，发现与参考文章结论不同，随后再仔细研读参考文章，发现掉坑里了。重新推翻代码按照正确思路，用1个小时完成最终结果。

本人做测试的，还不是专业的测试开发，写代码比较费劲，真正应了设计占70%，编码占30%的理。如果像基础在差点，逻辑在乱点，就只能用时间堆了。

Das obige ist der detaillierte Inhalt vonWie Python den Organisationsalgorithmus paarweise implementiert (effiziente Testfälle). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!