{"id":3562976,"date":"2021-04-14T09:00:00","date_gmt":"2021-04-14T07:00:00","guid":{"rendered":"https:\/\/www.johner-institut.de\/blog\/?p=3562976"},"modified":"2024-05-24T11:27:04","modified_gmt":"2024-05-24T09:27:04","slug":"kombinatorische-testen-nicht-nur-bei-software","status":"publish","type":"post","link":"https:\/\/www.johner-institut.de\/blog\/iec-62304-medizinische-software\/kombinatorische-testen-nicht-nur-bei-software\/","title":{"rendered":"Weshalb Sie das kombinatorische Testen nicht nur bei Software anwenden sollten"},"content":{"rendered":"\n

Testverfahren wie das kombinatorische Testen (z.B. das paarweise Testen) sind bei Software seit Jahrzehnten bekannt und in Normen wie der ISO 29119 beschrieben.<\/p>\n\n\n\n

Viele Hersteller wenden diese Verfahren jedoch nicht einmal bei Produkten, die Software enthalten, angemessen an. Damit erh\u00f6hen sie zum einen die Risiken f\u00fcr Anwender und Patienten<\/strong> und zum anderen die Risiken f\u00fcr die Firma<\/strong> selbst: Denn Benannte Stellen fordern diesen Stand der Technik bei Audits und Zulassungen<\/strong> zunehmend ein.<\/p>\n\n\n\n\n\n\n\n

A) Kombinatorisches Testen: Welches Dilemma Auditoren und Hersteller verstehen m\u00fcssen<\/h2>\n\n\n\n

1. Die Pflicht, die Sicherheit nachzuweisen, bedeutet nicht, Fehlerfreiheit nachzuweisen<\/h3>\n\n\n\n

Gesetze und EU-Verordnungen wie die MDR<\/a> und IVDR<\/a> verpflichten Hersteller dazu, die Sicherheit, die Leistungsf\u00e4higkeit und den Nutzen ihrer Produkte nachzuweisen.<\/p>\n\n\n\n

Viele Pr\u00fcfer und Benannte Stellen<\/a> leiten daraus die Forderung ab, dass der Hersteller nachzuweisen habe, dass das Produkt inklusive dessen Software fehlerfrei ist. Doch dieser Nachweis l\u00e4sst sich nicht erbringen.<\/p>\n\n\n\n

2. Vollst\u00e4ndiges Testen ist unm\u00f6glich<\/h3>\n\n\n\n

Schon ein System wie ein Software-System oder eine Software-Komponente<\/a> mit nur drei Eing\u00e4ngen, deren Werte ganze Zahlen von Null bis 32.000 annehmen k\u00f6nnen, br\u00e4uchte 32.0003<\/sup> = 32.768.000.000.000 Testf\u00e4lle.<\/p>\n\n\n\n

Selbst bei 10.000 Testf\u00e4llen pro Sekunde w\u00fcrde der Test \u00fcber 100 Jahre<\/strong> laufen.<\/p>\n\n\n\n

Dabei w\u00e4re selbst ein Test inakzeptabel, der f\u00fcr diese drei Eingabewerte nur eine Minute ben\u00f6tigt. Schlie\u00dflich m\u00fcssen in einem System zehntausende dieser Pr\u00fcfungen durchgef\u00fchrt werden.<\/p>\n\n\n\n

Daraus folgt, dass solch ein System niemals zu 100 % getestet werden kann. Im obigen Beispiel sind nicht einmal 0,000001 % realistisch. Genau zu dieser Erkenntnis kommt auch die ISO 29119:<\/p>\n\n\n\n

Es ist unm\u00f6glich, ein Softwaresystem 100 % zu pr\u00fcfen, deshalb ist Pr\u00fcfen nur eine Probenahme.<\/em><\/p>ISO 29119-1<\/cite><\/blockquote>\n\n\n\n

3. Die Schlussfolgerungen<\/h3>\n\n\n\n

Daher sollten Sie mit Ihren Auditoren oder Pr\u00fcfern immer kl\u00e4ren, was diese unter einer 100%-Pr\u00fcfung verstehen. Dass eine Pr\u00fcfung aller Kombinationen von Eingangswerten unm\u00f6glich ist, hatten wir gerade dargelegt.<\/p>\n\n\n\n

Allerdings ist auch der Umkehrschluss falsch, dass man sich das Testen gleich sparen k\u00f6nne, weil man nur einen verschwindend kleinen Teil der Kombinationen von Inputs pr\u00fcfen kann.<\/p>\n\n\n\n

Vielmehr m\u00fcssen Hersteller gem\u00e4\u00df dem Stand der Technik testen. Diesen Stand reflektieren Normen wie die ISO 29119.<\/p>\n\n\n\n

So beschreibt die ISO 29119-4 im Kapitel 5.2.5 die \u201eCombinatorial Test Design Techniques\u201c<\/em> und im Kapitel 6.2.5 die \u201eCombinatorial Test Design Technique Coverage\u201c<\/em>.<\/p>\n\n\n\n

Das n\u00e4chste Kapitel stellt die wichtigsten Aspekte dieses Verfahrens vor.<\/p>\n\n\n\n

B) Wie kombinatorisches (z.B. paarweises) Testen funktioniert<\/h2>\n\n\n\n

1. Die Anzahl der gefundenen Fehler ist nicht proportional zur Anzahl der getesteten Parameter<\/h3>\n\n\n\n

Es hat sich gezeigt, dass es h\u00e4ufig nicht notwendig ist, alle m\u00f6glichen Kombinationen von Eingabewerten zu testen. Vielmehr gelingt es, bereits mit wenigen Kombinationen (\u2264 6) die meisten Fehler zu finden.<\/p>\n\n\n\n

\"Die
Abb. 1: Die Anzahl der gefundenen Fehler steigt mit der Anzahl der getesteten Kombinationen von Input-Werten (Quelle<\/a>). Allerdings werden schon mit paarweisem Testen die meisten Fehler gefunden.<\/figcaption><\/figure>\n\n\n\n

Das liegt daran, dass die meisten Fehler dadurch entstehen, dass die Verarbeitung einer Variablen nicht korrekt ist.<\/p>\n\n\n\n

Etwas weniger Fehler treten dadurch auf, dass die Verarbeitung erst in Kombination von zwei oder mehr Variablen nicht spezifikationsgem\u00e4\u00df erfolgt wie im folgenden Beispiel zu sehen.<\/p>\n\n\n\n

\"Ausschnitt
Abb. 2: Der fehlerhafte Code betrifft nur Patienten, deren Gewicht gr\u00f6\u00dfer als 120 (kg) und deren Laborwert kleiner als 20 (mg\/dl) ist. Durch paarweises Testen k\u00f6nnen solche Fehler systematisch entdeckt werden.<\/figcaption><\/figure>\n\n\n\n

Nur im Fall von Patienten, deren Gewicht \u00fcber 120 kg und deren Laborwert unter 20 mg\/dl betr\u00e4gt, ist die Fehlerwirkung \u00fcberhaupt sichtbar.<\/p>\n\n\n\n

Die NIST formuliert diese Erkenntnis<\/a> wie folgt:<\/p>\n\n\n\n

Interaction Rule: Most failures are induced by single factor faults or by the joint combinatorial effect (interaction) of two factors, with progressively fewer failures induced by interactions between three or more factors. <\/em><\/p><\/blockquote>\n\n\n\n

Folglich sollten Hersteller einen Fokus auf das Testen der Kombination weniger<\/strong> Input-Werte legen. Die Herausforderung beim kombinatorischen Testen besteht also darin, mit m\u00f6glichst wenigen Testf\u00e4llen m\u00f6glichst viele Kombinationen abzupr\u00fcfen.<\/p>\n\n\n\n

2. Ableiten der Testf\u00e4lle<\/h3>\n\n\n\n

Das kombinatorische Testen z\u00e4hlt zur Klasse der Blackbox-Testmethoden, denn es leitet die Testf\u00e4lle nicht aus der Kenntnis des Innenlebens der Methode, der Komponente oder des Systems ab. Vielmehr besteht der Ansatz darin, Testf\u00e4lle abzuleiten, in dem man systematisch verschiedene Input-Kombinationen bildet.<\/p>\n\n\n\n

Weil man nicht alle Kombinationen testen kann, beschr\u00e4nkt man sich darauf, mit Inputs zu testen, die paarweise, zu dritt, zu viert usw. gruppiert werden.<\/p>\n\n\n\n

Beispiel f\u00fcr paarweises Testen<\/h4>\n\n\n\n

In unserem Beispiel berechnet das System eine Behandlungsempfehlung auf Basis von f\u00fcnf Inputs:<\/p>\n\n\n\n

  1. Geschlecht: m\u00e4nnlich, weiblich<\/li>
  2. Diabetiker: kein Diabetes, Typ1-Diabetiker, Typ2-Diabetiker<\/li>
  3. Bestehende Medikamentenbehandlung: ja, nein<\/li>
  4. Allergiker: Keine Allergien, Hausstaubmilbenallergie, Pollenallergie<\/li>
  5. Altersklasse: Kind, Erwachsener<\/li><\/ol>\n\n\n\n

    Um alle Kombinationen zu testen, br\u00e4uchte man 2 x 3 x 2 x 3 x 2 = 72 Tests. Das ist eine handhabbare Menge. Doch bei mehr Inputs (Variablen) oder einer gr\u00f6\u00dferen Anzahl an m\u00f6glichen Variablenwerten w\u00e4re das nicht mehr der Fall.<\/p>\n\n\n\n

    Beim paarweisen Testen stellt man sicher, dass alle m\u00f6glichen Kombinationen zweier Input-Werte getestet werden. Beispielsweise m\u00fcssten f\u00fcr die beiden ersten Inputs (Geschlecht, Diabetiker) die Testf\u00e4lle aus dem Kreuzprodukt des Vektors 1 (m\u00e4nnlich, weiblich) und dem Vektor 2 (kein Diabetes, Typ1-Diabetiker, Typ2-Diabetiker) gebildet werden. Das f\u00fchrt zu sechs Testf\u00e4llen.<\/p>\n\n\n\n

    Durch kluges Kombinieren gelingt es in unserem Beispiel mit f\u00fcnf Inputs, die paarweisen Kombinationen mit nur neun Testf\u00e4llen zu \u00fcberpr\u00fcfen:<\/p>\n\n\n\n

    Test Case<\/th>sex<\/th>diabetic<\/th>medicated<\/th>allergy<\/th>age<\/th><\/tr>
    1<\/td>female<\/strong><\/td>no<\/strong><\/td>false<\/td>no<\/td>adult<\/td><\/tr>
    2<\/td>male<\/strong><\/td>no<\/strong><\/td>true<\/td>dust<\/td>child<\/td><\/tr>
    3<\/td>female<\/td>no<\/td>true<\/td>pollen<\/td>adult<\/td><\/tr>
    4<\/td>male<\/strong><\/td>type1<\/strong><\/td>false<\/td>no<\/td>child<\/td><\/tr>
    5<\/td>female<\/strong><\/td>type1<\/strong><\/td>true<\/td>dust<\/td>adult<\/td><\/tr>
    6<\/td>male<\/td>type1<\/td>false<\/td>pollen<\/td>child<\/td><\/tr>
    7<\/td>female<\/strong><\/td>type2<\/strong><\/td>true<\/td>no<\/td>child<\/td><\/tr>
    8<\/td>male<\/strong><\/td>type2<\/strong><\/td>false<\/td>dust<\/td>adult<\/td><\/tr>
    9<\/td>male<\/td>type2<\/td>true<\/td>pollen<\/td>adult<\/td><\/tr><\/tbody><\/table>
    Tabelle 1: Mit 9 Testf\u00e4llen l\u00e4sst sich das System aus f\u00fcnf Inputs paarweise testen. Fett hervorgehoben sind die Kombinationen der ersten beiden Variablen.<\/figcaption><\/figure>\n\n\n\n

    Sie finden in Tabelle 1 auch die eben erw\u00e4hnten sechs Testf\u00e4lle wieder, die die Kombination der Werte f\u00fcr \u201eGeschlecht\u201c und \u201eDiabetiker\u201c repr\u00e4sentieren.<\/p>\n\n\n\n

    Das paarweise Testen ben\u00f6tigt in diesem Beispiel<\/strong><\/strong> nur neun statt 72 Testf\u00e4lle.<\/strong><\/p>\n\n\n\n

    Beispiel f\u00fcr Testen von Dreierkombinationen<\/h4>\n\n\n\n

    Beim Testen von Dreierkombinationen (3-way testing<\/em>) gilt es, die m\u00f6glichen Kombinationen von drei Input-Variablen zu pr\u00fcfen. Bei den Variablen \u201eGeschlecht\u201c, \u201eDiabetiker\u201c, \u201eBestehende Medikamentenbehandlung\u201c w\u00e4ren das 2 x 3 x 2 = 12 Tupel.<\/p>\n\n\n\n

    Diese 12 Tupel sind in Tabelle 2 fett hervorgehoben.<\/p>\n\n\n\n

    Test Case No.<\/th>sex<\/th>diabetic<\/th>medicated<\/th>allergy<\/th>age<\/th><\/tr>
    1<\/td>male<\/strong><\/td>no<\/strong><\/td>true<\/strong><\/td>no<\/td>child<\/td><\/tr>
    2<\/td>female<\/strong><\/td>no<\/strong><\/td>false<\/strong><\/td>no<\/td>adult<\/td><\/tr>
    3<\/td>male<\/strong><\/td>no<\/strong><\/td>false<\/strong><\/td>dust<\/td>child<\/td><\/tr>
    4<\/td>female<\/strong><\/td>no<\/strong><\/td>true<\/strong><\/td>dust<\/td>adult<\/td><\/tr>
    5<\/td>male<\/td>no<\/td>true<\/td>pollen<\/td>adult<\/td><\/tr>
    6<\/td>female<\/td>no<\/td>false<\/td>pollen<\/td>child<\/td><\/tr>
    7<\/td>male<\/strong><\/td>type1<\/strong><\/td>false<\/strong><\/td>no<\/td>adult<\/td><\/tr>
    8<\/td>female<\/strong><\/td>type1<\/strong><\/td>true<\/strong><\/td>no<\/td>child<\/td><\/tr>
    9<\/td>male<\/strong><\/td>type1<\/strong><\/td>true<\/strong><\/td>dust<\/td>child<\/td><\/tr>
    10<\/td>female<\/strong><\/td>type1<\/strong><\/td>false<\/strong><\/td>dust<\/td>adult<\/td><\/tr>
    11<\/td>male<\/td>type1<\/td>false<\/td>pollen<\/td>child<\/td><\/tr>
    12<\/td>female<\/td>type1<\/td>true<\/td>pollen<\/td>adult<\/td><\/tr>
    13<\/td>male<\/strong><\/td>type2<\/strong><\/td>true<\/strong><\/td>no<\/td>adult<\/td><\/tr>
    14<\/td>female<\/strong><\/td>type2<\/strong><\/td>false<\/strong><\/td>no<\/td>child<\/td><\/tr>
    15<\/td>male<\/strong><\/td>type2<\/strong><\/td>false<\/strong><\/td>dust<\/td>adult<\/td><\/tr>
    16<\/td>female<\/strong><\/td>type2<\/strong><\/td>true<\/strong><\/td>dust<\/td>child<\/td><\/tr>
    17<\/td>male<\/td>type2<\/td>true<\/td>pollen<\/td>child<\/td><\/tr>
    18<\/td>female<\/td>type2<\/td>false<\/td>pollen<\/td>adult<\/td><\/tr><\/tbody><\/table>
    Tabelle 2: Mit 19 Testf\u00e4llen l\u00e4sst sich das System aus f\u00fcnf Inputs „3-way“ testen. Fett hervorgehoben sind die Kombinationen der ersten drei Variablen.<\/figcaption><\/figure>\n\n\n\n

    Die Testf\u00e4lle in dieser Tabelle enthalten auch alle anderen m\u00f6glichen Kombinationen aus drei beliebigen Input-Variablen.<\/p>\n\n\n\n

    Das Testen von Dreierkombinationen ben\u00f6tigt in diesem Beispiel nur 18 statt 72 Testf\u00e4lle.<\/strong><\/p>\n\n\n\n

    \n
    <\/i> Tipp<\/div>\n

    Je gr\u00f6\u00dfer die Anzahl der Variablen ist und damit die Anzahl m\u00f6glicher Kombinationen an Input-Werten, umso gr\u00f6\u00dfter wird der Vorteil durch die Verwendung des kombinatorischen Testens.<\/p>\n

    Beispielsweise bedarf es bei 10 bin\u00e4ren Inputs, f\u00fcr die normalerweise 1024 Testf\u00e4lle notwendig w\u00e4ren, beim paarweise Testen nur 10 Testf\u00e4lle, beim Testen von Dreierkombinationen nur 20 Testf\u00e4lle. Das entspricht 1 % bzw. 2 %.<\/p>\n<\/div>\n\n\n\n

    3. Kombinatorisches Testen von Zustandsautomaten<\/h3>\n\n\n\n

    H\u00e4ufig treten Fehler nicht nur bei bestimmten Kombinationen von Eingabewerten auf, sondern auch dann, wenn Systeme nicht in der richtigen Reihenfolge<\/strong> bedient werden. Eine solche Reihenfolge k\u00f6nnte sein:<\/p>\n\n\n\n