Saya seorang siswa yang mengerjakan BE (CS) saya dan pertanyaan saya adalah sebagai berikut:

1. Apakah pengujian di bidang perangkat lunak diperlukan?
2. Jika kita membuat perangkat lunak dengan sangat hati-hati, mengapa kita harus menguji?
3. Setelah pengujian, dapatkah kami yakin bahwa kami telah mencapai tujuan ini (produk / perangkat lunak berfungsi sebagaimana dimaksud) karena kami telah melakukan pengujian untuknya? Apa itu mungkin?

Pertanyaan saya: Apakah pengujian perangkat lunak diperlukan ?

Iya nih. Karena betapapun baiknya Anda, Anda tidak dapat memikirkan semuanya.

• Anda juga akan diminta untuk membuat perangkat lunak Anda melakukan hal-hal yang tidak pernah Anda inginkan.
• Anda juga tidak akan pernah memiliki persyaratan yang begitu jelas sehingga Anda akan dapat memikirkan setiap kemungkinan untuk memastikan kode tidak rusak.
• Anda juga akan bekerja dengan perangkat lunak dan apis orang lain yang tidak selalu berfungsi sebagaimana mestinya, tetapi Anda akan berasumsi bahwa itu memang, atau seharusnya, mengarah pada cacat dalam kasus "sempurna" Anda.

iya nih

Untuk alasan yang sama seorang koki mencicipi makanannya saat memasaknya.

Saya bekerja dengan seseorang yang berpikir seperti ini, dia berpikir bahwa karena dia adalah programmer senior, dia tidak perlu lagi menguji kodenya. Perusahaan tidak mengerti betapa berbahayanya sikap ini dan bukannya memecatnya langsung, mereka merekrut lebih banyak programmer untuk mengatasi tumpukan bug. Tidak tahu dari mana backlog ini berasal dari mereka pikir itu bagian dari pemrograman apa itu semua. Pada dasarnya kami memiliki 3 programmer yang bekerja di bawah mode ini dan 20 tim yang tidak melakukan apa pun selain menguji dan memperbaiki bug yang dibuat oleh ketiganya.

TIDAK ADANYA OF PROPER PENGUJIAN KEMATIAN .

Jadi kecuali Anda adalah ALLAH atau versi apa pun dari semua makhluk yang tahu segalanya (sekarang ini yang ingin saya lihat) atau kecuali Anda secara aktif ingin dipecat dengan sangat cepat, saya sangat menyarankan Anda memulai pengujian.

Perangkat lunak ditulis oleh orang-orang.

Orang tidak sempurna dan melakukan kesalahan.

Ketika kompleksitas usaha meningkat, jumlah potensial (dan dampak) kesalahan, pengawasan, atau hal-hal yang dilupakan naik - biasanya secara eksponensial.

Jadi ya, pengujian diperlukan. Ini membawa keseimbangan dan perspektif.

Apakah Anda akan mendapatkan penerbangan yang menjalankan OS yang Anda tahu Anda gunakan pada laptop Anda dan memberi Anda layar kematian dalam warna favorit Anda? Pikirkan tentang itu.

Tidak ada coder yang sempurna. Jauh, jauh, jauh dari itu kok. Anda perlu pengujian, dan penguji sering membawa perspektif (juga dikenal sebagai kasus penggunaan) yang hilang oleh pengembang.

Lakukan pencarian pada bug perangkat lunak paling terkenal di Google untuk mengetahui apa yang saya maksud.

Dan di tingkat perguruan tinggi, baca beberapa perkembangan yang digerakkan oleh tes, pengujian unit, dan praktik lincah untuk mengetahui di mana segalanya sekarang.

Pengujian adalah suatu keharusan mutlak untuk setiap aplikasi non sepele (dalam ukuran, atau fungsi) yang harus benar-benar digunakan. Anda tidak akan menemukan satu pengembang pun yang peduli tentang keahliannya (sebagaimana dibuktikan dengan kunjungan mereka ke situs ini) yang akan menanggapi dan mengatakan bahwa pengujian tidak diperlukan.

Selain apa yang telah diposting, memiliki rangkaian lengkap unit test otomatis pada aplikasi yang diberikan akan membuat Anda lebih percaya diri dalam perubahan kode di masa depan. Keyakinan yang lebih tinggi ini (karena tes unit memberikan jaring pengaman BESAR) akan menghasilkan perubahan kode yang lebih cepat untuk aplikasi yang ada (karena kurang mengulangi / mengecek ulang)

Salah humanum est

Tidak ada yang namanya perangkat lunak bebas bug.

Pengembang paling terampil menulis kode dengan bug. Bahkan jika ada pengembang yang sempurna, masih ada bug karena perbedaan antara:

• kebutuhan pengguna dan dokumen spesifikasi
• spesifikasi dan desain
• lingkungan perangkat keras dan perangkat lunak yang diharapkan dan aktual
• kebenaran kemarin dan hari ini: semua yang tercantum di atas dapat berubah yang tidak dilaporkan secara sempurna dalam setiap langkah proses pengembangan.

Pengembang yang sempurna hanya sebagian saja. Dan pengembang yang sempurna tidak ada.

Sebagian besar program kehidupan nyata:

a) berisi ratusan baris kode atau lebih, tersebar di banyak file;
b) dikembangkan oleh lebih dari satu programmer;
c) digunakan dalam lingkungan yang berbeda dari lingkungan pengembang

Jadi, jika Anda tidak akan memeriksa bagaimana program bekerja dalam situasi kehidupan nyata, kemungkinan itu tidak akan bekerja sama sekali akan mendekati 100%.

Selain semua jawaban hebat lainnya, bahkan jika Anda tahu itu sempurna dan bebas bug, pikirkan tentang programmer lain yang harus berurusan dengan kode Anda di masa depan. Mereka tidak akan mengetahuinya seperti yang Anda lakukan dan akan ingin mengandalkan tes Anda untuk memastikan mereka tidak merusak apa pun setelah mereka melakukan perubahan. Ini tentu saja juga berlaku untuk diri Anda setelah Anda belum melihat kode Anda dalam waktu satu tahun!

IYA NIH.

Berikut ini perspektif lain yang sedikit lebih halus yang belum dibahas:

Jangan pernah meremehkan perlunya "verifikasi independen" . Itulah alasan yang sama mengapa ada baiknya beberapa editor independen memeriksa pekerjaan Anda sebelum mengirimkan karya tulis besar untuk diterbitkan. Tidak peduli sebagus apa pun penulis Anda, kadang-kadang Anda akan berpikir - dan menulis sesuatu seperti "di" sebagai ganti "itu", atau sesuatu. Jika Anda membacanya sendiri, bahkan dengan sangat hati-hati, Anda biasanya masih akan melewatkannya, karena otak Anda secara otomatis menerima aliran proses berpikir Anda sebagai hal yang benar, dan menjelaskan kesalahannya. Untuk mata baru, kesalahan semacam itu biasanya cukup mencolok.

Anda mendapatkan hal yang sama dalam pemrograman: cukup mudah untuk masuk ke aliran di mana kode Anda, atau "pengujian pengembangan" dasar dari kode Anda sendiri - terlihat benar karena Anda mengujinya dan menggunakannya dengan cara tertentu. Tetapi kemudian ketika sepasang tangan lain datang dan mengklik sesuatu dengan cara atau urutan yang sedikit berbeda, semuanya hancur.

Sekarang, tentu saja, secara teori Anda bisa menyusuri jalur verifikasi secara formal setiap kemungkinan tunggal dan cabang logika dalam kode Anda sendiri, tetapi untuk perangkat lunak non-sepele ini akan jauh lebih mahal dan memakan waktu daripada meminta orang lain menggedornya. kode untuk Anda. Dan Anda mungkin masih akan melewatkan hal-hal yang tidak pernah Anda pikirkan.

Apa yang belum tersentuh: meskipun kode Anda sempurna, Anda masih tidak aman. Compiler memiliki bug yang dapat menyebabkan kode yang bahkan sempurna untuk berperilaku tidak benar setelah kompilasi. Sistem operasi memiliki bug yang dapat menyebabkan biner sempurna berperilaku tidak benar ketika dijalankan. Perangkat keras memiliki bug yang dapat menyebabkan masalah.

Itu juga mengapa pengujian pada satu mesin tidak cukup untuk produk komersial. Mereka perlu diuji di bawah sebanyak mungkin kombinasi perangkat keras dan perangkat lunak yang dapat mereka temui di alam liar.

Pemimpin tim yang menulis perangkat lunak untuk pesawat ulang-alik keluar sebelum setiap peluncuran untuk menandatangani bahwa perangkat lunak tidak akan membahayakan pesawat ulang-alik.

Menurut Anda apa yang memberinya kepercayaan diri untuk melakukannya?

Anda terus menguji kode hanya dengan kompilasi dan menggunakannya. Dalam beberapa IDE Anda mendapatkan cek kewarasan saat Anda mengetik. Kecuali Anda tidak pernah benar-benar menjalankan kode Anda, Anda melakukan pengujian.

Seberapa banyak Anda menguji sebenarnya adalah akar dari pertanyaan semacam ini dan jawaban untuk itu beresiko. Anda menguji sebanyak yang masuk akal untuk menguji dari sudut pandang manajemen risiko. Menguji segalanya atau tidak sama sekali biasanya tidak mungkin. Menguji hampir tidak ada biasanya merupakan langkah yang buruk. Segala sesuatu di antaranya adalah permainan yang adil, tergantung pada tingkat risiko dan paparan kiriman Anda.

Baunya seperti pekerjaan rumah.

Apakah pengujian di bidang perangkat lunak diperlukan?

Iya nih. Benar. Di semua tingkatan. Di luar beberapa domain khusus, kami belum pada tahap di mana kami dapat membuktikan secara matematis kode kami benar terhadap bug tertentu (setidaknya tidak dalam jangka waktu yang masuk akal), jadi kami harus melempar batu ke sana untuk melihat apakah dan dimana itu rusak.

Jika kita membuat perangkat lunak dengan sangat hati-hati, mengapa kita harus menguji?

Pengujian bukan hanya tentang menemukan kesalahan pengkodean. Ini juga tentang memastikan bahwa Anda telah memenuhi semua persyaratan Anda, dan bahwa keseluruhan sistem berkinerja seperti yang diharapkan. Jika saya memiliki persyaratan bahwa transaksi yang gagal harus mengembalikan kode kesalahan tertentu, maka saya perlu menulis tes untuk memverifikasi bahwa fungsionalitasnya ada dan berfungsi dengan benar.

Dan semua itu mengasumsikan bahwa spesifikasi dan desainnya lengkap, benar, dan konsisten secara internal, yang seringkali tidak demikian. Bahkan jika Anda memenuhi spesifikasi untuk surat itu dan mengikuti desain ke titik dan titik koma terakhir, jika spesifikasi atau desain buruk, maka akan ada masalah pada waktu integrasi. Seringkali, pengujian sistem atau integrasi adalah ketika Anda mengetahui bahwa spesifikasi itu sendiri bermasalah dan perlu direvisi (lihat kisah perang di bawah).

Setelah pengujian, dapatkah kami yakin bahwa kami telah mencapai tujuan ini (produk / perangkat lunak berfungsi sebagaimana dimaksud) karena kami telah melakukan pengujian untuknya? Apa itu mungkin?

Tidak, tidak sampai 100%. Kami tidak dapat menguji setiap kombinasi input atau jalur eksekusi yang dimungkinkan dalam kode apa pun kecuali yang paling sederhana. Kami tidak dapat menjelaskan semua faktor lingkungan. Kami tidak dapat membayangkan semua mode kegagalan yang memungkinkan.

Kami dapat menguji ke titik di mana kami cukup yakin tidak ada masalah besar. Sekali lagi, inilah mengapa kita perlu menguji di semua tingkatan. Tulis serangkaian tes untuk memastikan kode Anda menangani kondisi tepi dengan benar (input buruk, hasil yang tidak terduga, pengecualian, dll.). Uji unit untuk memverifikasi bahwa kode Anda memenuhi persyaratannya. Tes sistem untuk memverifikasi pemrosesan end-to-end. Tes integrasi untuk memverifikasi bahwa semua komponen saling berbicara dengan benar. Lakukan pengujian kegunaan untuk memastikan bahwa semuanya berfungsi sedemikian rupa sehingga pelanggan tidak ingin menembak Anda.

Skenario dunia nyata - Saya sedang mengerjakan sistem back-end yang sesekali mengirim pembaruan ke layanan GUI untuk ditampilkan dalam tabel di layar. Selama proyek, persyaratan ditambahkan untuk menambahkan pemfilteran pada tampilan (misalnya, operator dapat memilih untuk menampilkan subset dari entri dalam tabel). Kesalahan desain # 1 - pemfilteran seharusnya dilakukan oleh layanan GUI (Saya memiliki gagasan kuno dan kuno bahwa fungsi manajemen tampilan harus menjadi tanggung jawab perangkat lunak manajemen display), tetapi karena politik dan ketidakmampuan saya untuk mengenali masalah sebelum menjadi masalah , persyaratan itu ditempatkan pada layanan back-end. Baiklah, oke, tidak masalah, saya bisa melakukannya. Filter menyatakan perubahan, saya menerima pesan, dan kemudian saya mengirim pesan buat atau hapussetiap baris dalam tabel , karena itulah cara kerja antarmuka (kesalahan desain # 2 - tidak ada cara untuk mengirim pembaruan ke beberapa baris dalam satu pesan; kami bahkan tidak bisa mengirim satu pesan "jelas" atau "hapus" untuk menghapus seluruh tabel).

Ya, semua berjalan baik selama pengembangan; pengujian unit, sistem, dan integrasi menunjukkan bahwa saya mengirim informasi yang benar dan menangani perubahan filter dengan benar. Kemudian kita sampai ke pengujian kegunaan, dan semuanya jatuh dengan keras , karena volume data luar biasa. Latensi jaringan antara layanan backend saya dan GUI berada di urutan .15 hingga .25 detik. Tidak buruk jika Anda hanya perlu mengirim pembaruan untuk selusin baris atau lebih. Mematikan ketika Anda harus mengirim pembaruan untuk beberapa ratus. Kami mulai mendapatkan laporan bug bahwa GUI membeku setelah mengubah status filter; yah, tidak, yang terjadi adalah mengambil beberapa menit untuk memperbarui tampilan karena protokol pesan update-satu-baris-pada-waktu-berkepala tulang tidak bisa menangani skenario dunia nyata.

Perhatikan bahwa semua itu dapat dan seharusnya telah diantisipasi oleh semua orang dari kontraktor utama hingga saya yang kecil jika kita repot-repot melakukan bahkan analisis yang paling mendasar sebelumnya. Satu-satunya pembelaan yang akan saya tawarkan adalah bahwa kami menutup tahun kedua dari proyek enam bulan yang akan segera dibuang setelah melahirkan, dan kami semua hanya ingin melihat bagian belakangnya.

Yang membawa kita pada alasan terakhir untuk menguji - CYA. Proyek dunia nyata gagal karena berbagai alasan, banyak di antaranya bersifat politis, dan tidak semua orang bertindak dengan itikad baik ketika ada yang salah. Jari diarahkan, tuduhan dibuat, dan pada akhirnya Anda harus dapat menunjuk ke sebuah catatan yang menunjukkan bahwa setidaknya barang - barang Anda bekerja sebagaimana mestinya.

Pengujian akan selalu dilakukan dan bug akan selalu ditemukan. Hanya saja pengujian akan dilakukan secara internal oleh tim Anda, atau pengguna akhir akan menjadi tester. Biaya bug yang ditemukan oleh pengguna akhir jauh lebih tinggi daripada jika ditemukan selama pengujian.

Saya akan menyarankan mengambil kursus Computing-Tolerant Computing yang bagus. Desain perangkat lunak yang cermat adalah salah satu pilar untuk mencapai ketahanan dalam produk perangkat lunak Anda. Dua pilar lainnya adalah pengujian yang cukup dan desain yang berlebihan. Tujuan dasarnya adalah untuk mengakomodasi sejumlah besar kondisi kegagalan yang tidak diketahui dan untuk memprioritaskan berurusan dengan beberapa yang diketahui:

1.) menghilangkan kegagalan sebanyak mungkin melalui desain dan implementasi yang tepat 2.) menghilangkan kegagalan yang tidak terduga dari fase desain dan implementasi yang salah melalui berbagai bentuk pengujian (unit, integrasi, acak) 3.) menangani setiap kegagalan sisa melalui redundansi ( temporal => kompilasi ulang, coba lagi atau spasi => simpan salinan, paritas)

Jika Anda menghilangkan fase pengujian, Anda hanya memiliki fase desain dan redundansi untuk mengatasi kegagalan.

Selain itu, dari sudut pandang produk, pemangku kepentingan Anda (misalnya manajemen, pengguna, investor) akan menginginkan semacam jaminan bahwa produk Anda memenuhi spesifikasi kualitas dan keamanan tertentu, kriteria, dll. Selain semua ini, belumkah Anda menguji perangkat lunak yang Anda membangun hanya untuk memiliki 'cek kewarasanan'? Semua alasan ini membuat pengujian perangkat lunak lebih menarik.

Semua program memiliki bug, setidaknya untuk memulainya.

Ada beberapa penelitian yang menyatu pada sekitar 1 bug per setiap lima baris kode yang belum diuji.

Pelajaran sejarah:

Kembali pada tahun 1960-an IBM membutuhkan program "NOP" sehingga mereka dapat menjalankan beberapa fungsi di JCL tanpa benar-benar menjalankan program. Para pengembang datang dengan program assembler satu baris di mana seluruh kode terkandung dalam namanya "IEFBR14" kode sebenarnya adalah:

       BR 14 * brach to return address in register 14

Selama liftime panjang, program satu baris ini telah mengalami 2 laporan bug dan lima amandemen.

Refactoring kode sangat cepat ketika Anda memiliki unit test. Tes unit juga menunjukkan penggunaan fungsi konkret yang sederhana, sehingga Anda memiliki sedikit "howto" yang dapat sangat berguna dalam proyek besar di mana programmer tidak tahu persis seluruh kode.

Ketika Anda Berkembang dengan TDD (test driven development) Anda tidak memiliki pengambil / setter yang tidak perlu dll. Anda hanya menciptakan apa yang Anda butuhkan.

Untuk menjawab # 3 pertanyaan Anda:

Setelah menjadi programmer dan penguji perangkat lunak, ya, Anda dapat memastikan Anda memenuhi persyaratan perangkat lunak selama pengujian.

{memakai topi QA}

Bagaimana? Anda dapat melakukan ini dengan melacak tes Anda dari kode uji ke kriteria penerimaan, kriteria penerimaan hingga fitur, dan fitur hingga persyaratan. Jika Anda melacak setiap tes hingga rantai desain dan mereka memetakan ke satu atau lebih persyaratan, Anda dapat yakin bahwa tes Anda digunakan untuk memastikan kode memenuhi persyaratannya (meskipun ini memunculkan gagasan tentang cakupan uji yang memadai, yang merupakan topik lain). Jika Anda tidak dapat melacak tes hingga rantai desain, maka Anda kemungkinan menguji hal-hal yang tidak diperlukan, dan ini buang-buang waktu. Kriteria penerimaan juga dapat mencakup memeriksa perilaku yang tidak diinginkan - Anda dapat menguji mereka juga, yang membuat Anda selangkah lebih dekat dengan rilis kualitas.

{QA hat off}

Tidak ada kode yang bebas bug, hanya lebih murah dari waktu ke waktu ketika lebih banyak upaya dihabiskan untuk menilai kualitasnya selama pengembangan.

Saya telah menjadi penguji Perangkat Lunak selama 3 tahun sekarang. Awalnya saya sendiri merasa skeptis tentang perlunya menguji, karena saya pikir jika departemen pengembangan dan manajemen proyek melakukan pekerjaan mereka maka tidak ada kesalahan dalam perangkat lunak yang seharusnya muncul.

TAPI ini bukan masalahnya. +++++++++

Kesalahan sering terjadi, beberapa di antaranya penting untuk pengoperasian proyek. Ada juga pengujian lintas-browser (yang berarti pengujian pada berbagai browser yang ada seperti SAFARI, FIREFOX, CHROME dan Internet Explorer) dan saya bekerja pada proyek di mana tombol antarmuka sederhana seperti YA dan TIDAK pada jendela survei di mana tidak hanya bekerja di semua browser saja beberapa dari mereka.

Saya bekerja pada pengujian halaman internet, dan sedang menguji PERUBAHAN TEKS sederhana dan berpikir pada diri sendiri bahwa tidak ada cara di bumi mungkin ada cacat pada pekerjaan sederhana ini, tetapi tidak ada itu terjadi.

Saya juga telah melihat ketika pengembang baru bergabung dengan tim dan diberi pembaruan karya untuk formulir aplikasi internet kompleks yang ada dengan sejumlah tautan / panggilan ke halaman eksternal, kesalahan terjadi karena kurangnya komunikasi antara pengembang lama dan baru, karena berbagai alasan (tidak ada waktu untuk mendidik, tidak ada keinginan untuk mendidik dan sebagainya).

IYA NIH

Bayangkan perangkat lunak Anda hanya fungsi logis DAN (b1, b2) di mana b1 dan b2 hanya bit. Dengan itu Anda perlu 4 kasus uji untuk memastikan bahwa perangkat lunak Anda bebas dari kesalahan, jika lingkungan sekitar Anda memberikan apa yang ditentukan untuknya.

Sekarang sistem Anda dibuat oleh banyak fungsi yang yang paling sederhana jauh lebih rumit daripada fungsi logis itu. Bagaimana Anda memastikan itu bebas dari kesalahan?

(bersambung)