Your SlideShare is downloading. ×
Minggu V
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×
Saving this for later? Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime – even offline.
Text the download link to your phone
Standard text messaging rates apply

Minggu V

751
views

Published on

Published in: Technology

0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total Views
751
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
46
Comments
0
Likes
0
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 1. Testing dan Implementasi Sistem Slamet Sn
  • 2. Outline
    • White box testing
    • Pembuatan flowgraph
    • Pembuatan testcase
  • 3. White box testing
    • Adalah testing yang diturunkan dari “pengetahuan” tentang struktur dan implementasi program
    • Nama lain : glass box, structural, clear box atau open box testing
    • harus tahu secara detail tetang perangkat lunak yang akan di uji.
    • Untuk pengujian yang lengkap maka suatu perangkat lunak harus diuji dengan white box dan black box testing
  • 4.
    • White Box Testing menggunakan 3 macam tahapan testing
          • Unit Testing
          • Integration testing
          • Regression Testing
    Cont’d
  • 5. Cont’d
    • Pembuatan testcase didasarkan pada alur logika
    • Alur logika : cara dimana suatu bagian dari program
      • tertentu dieksekusi saat menjalankan program.
    • Alur logika dapat direpresentasikan dengan menggunakan flowgraph
  • 6. Kegunaan
    • Menguji setiap jalur independent
    • Menguji keputusan logic (true atau falsa)
    • Menguji Loops dan batasannya
    • Menguji Data Struktur internalnya
  • 7.
    • Flowgraph
  • 8.  
  • 9. Komponen flowgrpah
    • Nodes (titik)  pernyataan (atau sub program) yang akan ditinjau saat eksekusi program.
    • Edges (anak panah)  jalur alur logika program untuk menghubungkan satu pernyataan (atau sub program) dengan yang lainnya.
    • Branch nodes (titik cabang)  titik-titik yang mempunyai lebih dari satu anak panah keluaran.
    • Branch edges (anak panah cabang)  anak panah yang keluar dari suatu titik cabang
    • Paths (jalur)  jalur yang mungkin untuk bergerak dari satu titik ke lainnya sejalan dengan keberadaan arah anak panah.
  • 10. Cont’d
    • Eksekusi suatu test case menyebabkan program untuk mengeksekusi pernyataan-pernyataan tertentu, yang berkaitan dengan jalur tertentu, sebagaimana tergambar pada flow graph .
    • Cakupan cabang, pernyataan dan jalur dibentuk dari eksekusi jalur program yang berkaitan dengan peninjauan titik, anak panah, dan jalur dalam flow graph .
  • 11. Cakupan pernyataan
    • Ditentukan dengan menilai proporsi dari pernyataan-pernyataan yang ditinjau oleh sekumpulan test cases yang ditentukan.
    • Cakupan pernyataan 100% jika tiap pernyataan pada program ditinjau setidaknya minimal sekali tes
    • Cakupan pernyataan berkaitan dengan nodes dari suatu flowgraph
  • 12. Contoh Cakupan Pernyataan
    • Pada contoh gambar flow graph di samping terdapat 10 titik.
    • Misal suatu jalur eksekusi program melewati titik-titik A, B, D, H, K.
    • Berarti ada 5 titik dari 10 titik yang dikunjungi, maka cakupan pernyataan sebesar 50%.
  • 13. Cakupan cabang
    • Cakupan cabang ditentukan dengan menilai proporsi dari cabang keputusan yang diuji oleh sekumpulan test cases yang telah ditentukan.
    • Cakupan cabang 100% adalah bilamana tiap cabang keputusan pada program ditinjau setidaknya minimal sekali tes.
    • Cakupan cabang berkaitan dengan peninjauan anak panah cabang ( branch edges) dari flow graph .
  • 14. Contoh Cakupan Cabang
    • Pada contoh gambar flow graph di samping, terdapat 6 anak panah cabang.
    • Mis. suatu jalur eksekusi program melewati titik-titik A, B, D, H, K,
    • maka jalur tersebut meninjau 2 dari 6 anak panah cabang yang ada, jadi cakupannya sebesar 33 %.
  • 15. Cakupan jalur
    • Cakupan jalur ditentukan dengan menilai proporsi eksekusi jalur program yang diuji oleh sekumpulan test cases yang telah ditentukan.
    • Cakupan jalur 100 % adalah bilamana tiap jalur pada program dikunjungi setidaknya minimal sekali tes.
    • Cakupan jalur berkaitan dengan peninjauan jalur sepanjang flow graph .
  • 16. Contoh Cakupan Jalur
    • Berdasarkan contoh flow graph di atas, terdapat 4 jalur.
    • Bila suatu eksekusi jalur pada program melalui titik-titik A, B, D, H, K, maka eksekusi tersebut meninjau 1 dari 4 jalur yang ada, jadi cakupannya sebesar 25%.
  • 17. Disain cakupan tes
    • Untuk mendisain cakupan dari tes, perlu diketahui tahap-
    • tahap sebagai berikut:
    • Menganalisa source code untuk membuat flow graph .
    • Mengidentifikasi jalur tes untuk mencapai pemenuhan tes berdasarkan pada flow graph .
    • Mengevaluasi kondisi tes yang akan dicapai dalam tiap tes.
    • Memberikan nilai masukan dan keluaran berdasarkan pada kondisi.
  • 18. Basis path testing
    • Merupakan teknik white box testing yang dikenalkan oleh Tom McCabe [MC76].
    • Memungkinkan pendisain test cases untuk melakukan pengukuran terhadap kompleksitas logika dari disain prosedural
    • Menggunakan ukuran kompleksitas tsb sebagai panduan dalam menentukan kelompok basis dari jalur eksekusi
    • dimana hal ini akan menjamin eksekusi tiap pernyataan dalam program sekurangnya sekali selama testing berlangsung.
  • 19. Cont’d
    • Identifikasi didasarkan pada jalur, struktur atau koneksi yang ada dari suatu sistem ( branch testing) , karena cabang-cabang dari kode atau fungsi logika diidentifikasi dan dites
    • Konsep utama basis path :
      • Tiap basis path harus diidentifikasi, tidak boleh ada yang terabaikan (setidaknya dites 1 kali).
      • Kombinasi dan permutasi dari suatu basis path tidak perlu dites.
  • 20. Cyclomatic complexity
    • Adalah pengukuran kuantitatif dari kompleksitas logika program.
    • Pada konteks metode basis path testing , nilai yang dihitung bagi cyclomatic complexity menentukan jumlah jalur-jalur yang independen dalam kumpulan basis suatu program dan memberikan jumlah tes minimal yang harus dilakukan untuk memastikan bahwa semua pernyataan telah dieksekusi sekurangnya satu kali.
  • 21. Cont’d
    • Jalur independen adalah tiap jalur pada program yang memperlihatkan 1 kelompok baru dari pernyataan proses atau kondisi baru.
    • [ Region / Complexity ] V(G) = E ( edges ) – N ( nodes ) + 2
  • 22.
    • Pembuatan testcase
  • 23. Pembuatan test cases dengan menggunakan cyclomatic complexity :
    • Tahapan :
    • Gunakan disain atau kode sebagai dasar, gambarlah flow graph
    • Berdasarkan flow graph , tentukan cyclomatic complexity
    • Tentukan kelompok basis dari jalur independen secara linier
    • Siapkan test cases yang akan melakukan eksekusi dari tiap jalur dalam kelompok basis
  • 24.
    • Pembuatan flowgraph
  • 25. public static int binarySearch( int key, int[] sequence ) { int bottom = 0; int top = sequence.length - 1; int mid = 0; int keyPosition = -1; while( bottom <= top && keyPosition == -1 ) { mid = ( top + bottom ) / 2; if( sequence[ mid ] == key ) { keyPosition = mid; } else { if( sequence[ mid ] < key ) { bottom = mid + 1; } else { top = mid - 1; } } } return keyPosition; }
  • 26. public static int binarySearch( int key, int[] sequence ) { int bottom = 0; int top = sequence.length - 1; int mid = 0; int keyPosition = -1; while( bottom <= top && keyPosition == -1 ) { mid = ( top + bottom ) / 2; if( sequence[ mid ] == key ) { keyPosition = mid; } else { if( sequence[ mid ] < key ) { bottom = mid + 1; } else { top = mid - 1; } } } return keyPosition; } 1 1
  • 27. public static int binarySearch( int key, int[] sequence ) { int bottom = 0; int top = sequence.length - 1; int mid = 0; int keyPosition = -1; while( bottom <= top && keyPosition == -1 ) { mid = ( top + bottom ) / 2; if( sequence[ mid ] == key ) { keyPosition = mid; } else { if( sequence[ mid ] < key ) { bottom = mid + 1; } else { top = mid - 1; } } } return keyPosition; } 1 2 1 2
  • 28. 1 2 10 F public static int binarySearch( int key, int[] sequence ) { int bottom = 0; int top = sequence.length - 1; int mid = 0; int keyPosition = -1; while( bottom <= top && keyPosition == -1 ) { mid = ( top + bottom ) / 2; if( sequence[ mid ] == key ) { keyPosition = mid; } else { if( sequence[ mid ] < key ) { bottom = mid + 1; } else { top = mid - 1; } } } return keyPosition; } 10 F 1 2
  • 29. 3 1 2 10 F T F public static int binarySearch( int key, int[] sequence ) { int bottom = 0; int top = sequence.length - 1; int mid = 0; int keyPosition = -1; while( bottom <= top && keyPosition == -1 ) { mid = ( top + bottom ) / 2; if( sequence[ mid ] == key ) { keyPosition = mid; } else { if( sequence[ mid ] < key ) { bottom = mid + 1; } else { top = mid - 1; } } } return keyPosition; } 10 3 T F 10 F 1 2
  • 30. 3 1 2 10 F T F 4 T 5 T public static int binarySearch( int key, int[] sequence ) { int bottom = 0; int top = sequence.length - 1; int mid = 0; int keyPosition = -1; while( bottom <= top && keyPosition == -1 ) { mid = ( top + bottom ) / 2; if( sequence[ mid ] == key ) { keyPosition = mid; } else { if( sequence[ mid ] < key ) { bottom = mid + 1; } else { top = mid - 1; } } } return keyPosition; } 4 T 5 T 10 3 T F F 1 2
  • 31. 3 1 2 10 F T F 4 T 5 T 6 F public static int binarySearch( int key, int[] sequence ) { int bottom = 0; int top = sequence.length - 1; int mid = 0; int keyPosition = -1; while( bottom <= top && keyPosition == -1 ) { mid = ( top + bottom ) / 2; if( sequence[ mid ] == key ) { keyPosition = mid; } else { if( sequence[ mid ] < key ) { bottom = mid + 1; } else { top = mid - 1; } } } return keyPosition; } 10 6 4 T 5 T 3 T F F 1 2 F
  • 32. 3 1 2 10 F T F 4 T 5 T 6 F 9 public static int binarySearch( int key, int[] sequence ) { int bottom = 0; int top = sequence.length - 1; int mid = 0; int keyPosition = -1; while( bottom <= top && keyPosition == -1 ) { mid = ( top + bottom ) / 2; if( sequence[ mid ] == key ) { keyPosition = mid; } else { if( sequence[ mid ] < key ) { bottom = mid + 1; } else { top = mid - 1; } } } return keyPosition; } 9 6 4 T 5 T 3 T F F 1 2 F 10
  • 33. 3 1 2 10 F T F 4 T 5 T 6 F 7 T 9 public static int binarySearch( int key, int[] sequence ) { int bottom = 0; int top = sequence.length - 1; int mid = 0; int keyPosition = -1; while( bottom <= top && keyPosition == -1 ) { mid = ( top + bottom ) / 2; if( sequence[ mid ] == key ) { keyPosition = mid; } else { if( sequence[ mid ] < key ) { bottom = mid + 1; } else { top = mid - 1; } } } return keyPosition; } 7 T 9 6 4 T 5 T 3 T F F 1 2 F 10
  • 34. 3 1 2 10 F T F 4 T 5 T 6 F 7 T 8 F 9 public static int binarySearch( int key, int[] sequence ) { int bottom = 0; int top = sequence.length - 1; int mid = 0; int keyPosition = -1; while( bottom <= top && keyPosition == -1 ) { mid = ( top + bottom ) / 2; if( sequence[ mid ] == key ) { keyPosition = mid; } else { if( sequence[ mid ] < key ) { bottom = mid + 1; } else { top = mid - 1; } } } return keyPosition; } 8 F 7 T 9 6 4 T 5 T 3 T F F 1 2 F 10
  • 35. 3 1 2 10 F T F 4 T 5 T 6 F 7 T 8 F 9 public static int binarySearch( int key, int[] sequence ) { int bottom = 0; int top = sequence.length - 1; int mid = 0; int keyPosition = -1; while( bottom <= top && keyPosition == -1 ) { mid = ( top + bottom ) / 2; if( sequence[ mid ] == key ) { keyPosition = mid; } else { if( sequence[ mid ] < key ) { bottom = mid + 1; } else { top = mid - 1; } } } return keyPosition; } 8 F 7 T 9 6 4 T 5 T 3 T F F 1 2 F 10
  • 36. 3 1 2 10 F T F 4 T 5 T 6 F 7 T 8 F 9 public static int binarySearch( int key, int[] sequence ) { int bottom = 0; int top = sequence.length - 1; int mid = 0; int keyPosition = -1; while( bottom <= top && keyPosition == -1 ) { mid = ( top + bottom ) / 2; if( sequence[ mid ] == key ) { keyPosition = mid; } else { if( sequence[ mid ] < key ) { bottom = mid + 1; } else { top = mid - 1; } } } return keyPosition; } 8 F 7 T 9 6 4 T 5 T 3 T F F 1 2 F 10
  • 37. public static int binarySearch( int key, int[] sequence ) { int bottom = 0; int top = sequence.length - 1; int mid = 0; int keyPosition = -1; while( bottom <= top && keyPosition == -1 ) { mid = ( top + bottom ) / 2; if( sequence[ mid ] == key ) { keyPosition = mid; } else { if( sequence[ mid ] < key ) { bottom = mid + 1; } else { top = mid - 1; } } } return keyPosition; } 3 1 2 10 F T F 4 T 5 T 6 F 7 T 8 F 9 8 F 7 T 9 6 4 T 5 T 3 T F F 1 2 F 10
  • 38.
    • Setelah pembuatan flowgraph, tahap selanjutnya adalah menghitung CC untuk menentukan jumlah jalur independen
    • CC = jml edges-jml nodes+2
    • CC = 13-10+2
    • = 5
    3 1 2 10 F T F 4 T 5 T 6 F 7 T 8 F 9
  • 39.
    • Berdasarkan urutan alurnya, didapatkan suatu kelompok basis flow graph :
      • Jalur 1 = 1-2-10
      • Jalur 2 = 1-2-3-10
      • Jalur 3 = 1-2-3-4-6-7-9-2-10
      • Jalur 4 = 1-2-3-4-6-8-9-2-10
      • Jalur 5 = 1-2-3-4-5-9-2-10
    3 1 2 10 F T F 4 T 5 T 6 F 7 T 8 F 9
  • 40.
    • Tahap selanjutnya adalah menyusun test cases yang akan melakukan eksekusi dari tiap jalur dalam kelompok basis
  • 41.
    • Testcase jalur 1
    • nilai bottom valid dimana nilai record bernilai false
    • hasil yang diharapkan :
    • sistem melakukan [return keyPosition] dan keluar dari subprogram
    public static int binarySearch( int key, int[] sequence ) { int bottom = 0; int top = sequence.length - 1; int mid = 0; int keyPosition = -1; while( bottom <= top && keyPosition == -1 ) { mid = ( top + bottom ) / 2; if( sequence[ mid ] == key ) { keyPosition = mid; } else { if( sequence[ mid ] < key ) { bottom = mid + 1; } else { top = mid - 1; } } } return keyPosition; }
  • 42.
    • Testcase jalur 3
    public static int binarySearch( int key, int[] sequence ) { int bottom = 0; int top = sequence.length - 1; int mid = 0; int keyPosition = -1; while( bottom <= top && keyPosition == -1 ) { mid = ( top + bottom ) / 2; if( sequence[ mid ] == key ) { keyPosition = mid; } else { if( sequence[ mid ] < key ) { bottom = mid + 1; } else { top = mid - 1; } } } return keyPosition; }
    • Jalur 3 = 1-2-3-4-6-7-9-2-10
    3 1 2 10 F T F 4 T 5 T 6 F 7 T 8 F 9
  • 43.
    • nilai bottom dan keyPosition valid dimana nilai record bernilai True
    • nilai mid = (top+bottom)/2
    • nilai sequence[mid] valid dimana nilai record bernilai False
    • nilai sequence[mid] valid dimana nilai record bernilai True
    • hasil yang diharapkan :
    • nilai bottom = mid+1
    • sistem keluar dari loop
    • sistem melakukan [return keyPosition] dan keluar dari subprogram
  • 44. Faktorial.java
    • public class Factorial
    • {
    • // Evaluate n!
    • public static long factorial( int n )
    • {
    • if( n <= 0 ) // base case
    • return 1;
    • else
    • return n * factorial( n - 1 );
    • }
    • // Simple test program
    • public static void main( String [ ] args )
    • {
    • for( int i = 1; i <= 10; i++ )
    • System.out.println( factorial( i ) );
    • }
    • }
    • Buat flowgraph
    • Hitung CC dan tentukan jalur independen
    • Buatkan satu testcase berdasarkan jalur independen yang telah ditentukan