Wir können alles außer Testen Andreas Zeller Universität des Saarlandes

Transkript

1 Wir können alles außer Testen Andreas Zeller Universität des Saarlandes

2 Testen

3 Testen

4 Mehr Testen

5 Noch mehr Testen

6 Software ist vielfältig

7 Software ist vielfältig

8 Software ist vielfältig

9 Software ist vielfältig

10 Software ist vielfältig

11 Software ist vielfältig

12 Testen Konfigurationen

13 Tester

14 Ziel des Testens 1956 Fehlersuche Demonstration Zerstörung Evaluation 1988 heute Prävention

15 Testen Konfigurationen

16 Was testen? Wie decken wir soviel Verhalten wie möglich ab? Konfigurationen

17 Black-Box Testen Fehlschlag (wertvoll) Erfolg Fehlschläge sind im Eingaberaum dünn gesät doch dicht in einigen Bereichen Menge der Eingabewerte (der Heuhaufen) Wenn wir jeden Bereich testen, werden wir Fehler finden Ziel: Eingabebereiche partitionieren, um Bereiche mit Fehlern zu finden

18 int cgi_decode(char *encoded, char *decoded) White-Box-Testen { char *eptr = encoded; A char *dptr = decoded; int ok = 0; while (*eptr) { B char c; c = *eptr; if (c == '+') { C C elseif (c == '%') { D D *dptr = ' '; E else *dptr = *eptr; F F int digit_high = Hex_Values[*(++eptr)]; int digit_low = Hex_Values[*(++eptr)]; if (digit_high == -1 digit_low == -1) { G H else { H *dptr = 16 * digit_high + digit_low; ok = 1; I *dptr = '\0'; return ok; M M ++dptr; ++eptr; L L

19 int cgi_decode(char *encoded, char *decoded) { char *eptr = encoded; char *dptr = decoded; int ok = 0; A test while (*eptr) { B char c; c = *eptr; if (c == '+') { C C elseif (c == '%') { D D *dptr = ' '; E else *dptr = *eptr; F int digit_high = Hex_Values[*(++eptr)]; int digit_low = Hex_Values[*(++eptr)]; if (digit_high == -1 digit_low == -1) { G H else { H *dptr = 16 * digit_high + digit_low; ok = 1; I *dptr = '\0'; return ok; M ++dptr; ++eptr; L L

20 100% int cgi_decode(char *encoded, char *decoded) { char *eptr = encoded; char *dptr = decoded; int ok = 0; A test 75% 50% 63% while (*eptr) { char c; c = *eptr; if (c == '+') { B C 25% elseif (c == '%') { D *dptr = ' '; E 0% Abdeckung else *dptr = *eptr; F int digit_high = Hex_Values[*(++eptr)]; int digit_low = Hex_Values[*(++eptr)]; if (digit_high == -1 digit_low == -1) { H else { H *dptr = 16 * digit_high + digit_low; ok = 1; G I *dptr = '\0'; return ok; M M ++dptr; ++eptr; L L

21 100% int cgi_decode(char *encoded, char *decoded) { char *eptr = encoded; char *dptr = decoded; int ok = 0; A test a+b 75% 50% 72% while (*eptr) { char c; c = *eptr; if (c == '+') { B C 25% elseif (c == '%') { D *dptr = ' '; E E 0% Abdeckung else *dptr = *eptr; F int digit_high = Hex_Values[*(++eptr)]; int digit_low = Hex_Values[*(++eptr)]; if (digit_high == -1 digit_low == -1) { H else { H *dptr = 16 * digit_high + digit_low; ok = 1; G I *dptr = '\0'; return ok; M M ++dptr; ++eptr; L L

22 100% int cgi_decode(char *encoded, char *decoded) { char *eptr = encoded; char *dptr = decoded; int ok = 0; A test a+b %3d 75% 50% 91% while (*eptr) { char c; c = *eptr; if (c == '+') { B C 25% elseif (c == '%') { D *dptr = ' '; E E 0% Abdeckung else *dptr = *eptr; F int digit_high = Hex_Values[*(++eptr)]; int digit_low = Hex_Values[*(++eptr)]; if (digit_high == -1 digit_low == -1) { H else { H *dptr = 16 * digit_high + digit_low; ok = 1; G I *dptr = '\0'; return ok; M M ++dptr; ++eptr; L L

23 100% 75% 50% 100% int cgi_decode(char *encoded, char *decoded) { char *eptr = encoded; char *dptr = decoded; int ok = 0; while (*eptr) { char c; c = *eptr; if (c == '+') { B A C test a+b %3d %g 25% elseif (c == '%') { D *dptr = ' '; E E 0% Abdeckung else *dptr = *eptr; F int digit_high = Hex_Values[*(++eptr)]; int digit_low = Hex_Values[*(++eptr)]; if (digit_high == -1 digit_low == -1) { H else { H *dptr = 16 * digit_high + digit_low; ok = 1; G I *dptr = '\0'; return ok; M M ++dptr; ++eptr; L L

24

25 Testkriterien Path testing Boundary interior testing LCSAJ testing Branch testing deckt ab Compound condition testing MC/DC testing Branch and condition testing Praktische Kriterien Theoretische Kriterien Loop boundary testing Statement testing Basic condition testing

26 Weyukers Hypothese Ob ein Abdeckungskriterium angemessen ist, kann nur intuitiv definiert werden

27 Dijkstras Fluch Testen kann nur die Anwesenheit von Fehlern feststellen, nicht jedoch ihre Abwesenheit Konfigurationen

28 Formale Verifikation Konfigurationen

29 Formale Verifikation Abstraktion Konfigurationen

30 Formale Verifikation Abstraktion Konfigurationen

31 Beste zweier Welten Abstraktion Konfigurationen

32 Tests generieren Abstraktion Konfigurationen

33 Infinite Monkey Theorem

34 100% 100% int cgi_decode(char *encoded, char *decoded) { char *eptr = encoded; char *dptr = decoded; int ok = 0; A fdsakfh+ew%3gfhdi%4f 75% 50% while (*eptr) { char c; c = *eptr; if (c == '+') { B C 25% elseif (c == '%') { D *dptr = ' '; E E 0% Abdeckung else *dptr = *eptr; F int digit_high = Hex_Values[*(++eptr)]; int digit_low = Hex_Values[*(++eptr)]; if (digit_high == -1 digit_low == -1) { H else { H *dptr = 16 * digit_high + digit_low; ok = 1; G I *dptr = '\0'; return ok; M M ++dptr; ++eptr; L L

35 if (winkel = 47 kraft = 532) {

36 if (winkel = 47 kraft = 532) { 2 32 = verschiedene Werte 2 32 = = verschiedene Werte 2 64 = verschiedene Abläufe

37 2 64 = verschiedene Abläufe

38 int cgi_decode(char *encoded, char *decoded) { char *eptr = encoded; char *dptr = decoded; int ok = 0; while (*eptr) { elseif (c == '%') { char c; c = *eptr; if (c == '+') { D D B C A Ich möchte diese Stelle in meinem Code erreichen C *dptr = ' '; E else *dptr = *eptr; F F int digit_high = Hex_Values[*(++eptr)]; int digit_low = Hex_Values[*(++eptr)]; if (digit_high == -1 digit_low == -1) { G H else { H *dptr = 16 * digit_high + digit_low; ok = 1; I *dptr = '\0'; return ok; M M ++dptr; ++eptr; L L

39 Evolutionäre Algorithmen Population erzeugen Mutationen erzeugen Ranking Auswahl Neu kombinieren

40 Population erzeugen fdsakfh+ew%3gfhdi%4f fwe8^ru786234jä Mutation fdsakfh+br%3gfhdi%4f fdsakfh+ew%4gfhdi%4f fwe8^ru&26234jä xb3#ru786234jä Neu kombinieren fdsakfh+ew%4gfhdi%4f xb3#ru786234jä xb3#ru7%4gfhdi%4f

41 Auswahl und Ranking if (winkel = 47 kraft = 532) { fdsakfh+ew%4gfhdi%4f winkel = 31 xb3#ru786234jä winkel = 48 xb3#ru7%4gfhdi%4f winkel = 65

42 Auswahl und Ranking if (winkel = 47 kraft = 532) { winkel = 51 xb4%ru786234jä xb3#ru78^^&1jä xb3#ru786234jä winkel = 48 winkel = 47

43 100% 75% 50% 100% int cgi_decode(char *encoded, char *decoded) { char *eptr = encoded; char *dptr = decoded; int ok = 0; while (*eptr) { char c; c = *eptr; if (c == '+') { B A C test a+b %3d %g 25% elseif (c == '%') { D *dptr = ' '; E E 0% Abdeckung else *dptr = *eptr; F int digit_high = Hex_Values[*(++eptr)]; int digit_low = Hex_Values[*(++eptr)]; if (digit_high == -1 digit_low == -1) { H else { H *dptr = 16 * digit_high + digit_low; ok = 1; G I *dptr = '\0'; return ok; M M ++dptr; ++eptr; L L

44 public class Test0 extends TestCase { Unit-Tests XML-Tests GUI-Tests Web-Tests

45 Unit-Tests public class Test0 extends TestCase { public void test8() throws Throwable { AddressBook a1 = new AddressBook(); AddressBook a2 = new AddressBook(); Category a1c = a1.createcategory(a1.getrootcategory(), "a1c"); Category a2c = a2.createcategory(a1c, "a2c");

46 <math> <mrow> <munderover> <mo> </mo> <mrow> <mi>x</mi> <mo>=</mo> <mn>1</mn> </mrow> <mi>n</mi> </munderover> <mrow> <apply> <power/> <ci>x</ci> <cn>2</cn> </apply> </mrow> </mrow> </math> XML-Tests nx x=1 x 2

47 <math> <mrow> <munderover> <mo> </mo> <mrow> <mi>x</mi> <mo>=</mo> <mn>1</mn> </mrow> <mi>n</mi> </munderover> <mrow> <apply> <power/> <ci>x</ci> <cn>2</cn> </apply> </mrow> </mrow> </math> XML-Tests

48 EXSYST Florian Groß, Andreas Zeller gefördert durch 2.5 Mio ERC Advanced Grant Demo auf CeBIT

49 DROIDMATE Konrad Jamrozik, Andreas Zeller gefördert durch $750,000 Google Focused Research Award Demo auf CeBIT

50 DROIDMATE

51 Testabdeckung Unit Test Generators GUI Test Generators Randoop Evosuite GUItar Exsyst 100 % 75 % 50 % 25 % 0 % Addressbook Calculator TerpPresent TerpSpreadSheet TerpWord

52

53

54 Ergebnisse prüfen Abstürze Zusicherungen Regression

55 Abstürze Generische Laufzeitfehler werden frei Haus erkannt

56 Zusicherungen class RedBlackTree { boolean repok() { assert (roothasnoparent()); assert (rootisblack()); assert (rednodeshaveonlyblackchildren()); assert (equalnumberofblacknodesonsubtrees()); assert (treeisacyclic()); assert (parentsareconsistent()); return true; Testgeneratoren zielen auf Zweigabdeckung und versuchen, jede Zusicherung zu verletzen!

57 Regression nx n X x 2 x 3 x=1 x=1 Vergleich mit früherer oder alternativer Version

58

59 59

60 Wir können alles außer testen 60