Geekly articles weekly

Pengantar Unit Testing in Unity

gambar

Apakah Anda ingin tahu bagaimana pengujian unit bekerja di Unity? Tidak yakin apa pengujian unit secara umum? Jika Anda menjawab pertanyaan-pertanyaan ini secara positif, maka tutorial ini akan bermanfaat bagi Anda. Dari sini Anda akan mempelajari yang berikut tentang pengujian unit:

  • Apa ini
  • Manfaatnya
  • Keuntungan dan kerugian
  • Cara kerjanya di Unity menggunakan Test Runner
  • Cara menulis dan menjalankan unit test yang akan diuji

Catatan : tutorial ini mengasumsikan bahwa Anda terbiasa dengan C # dan dasar-dasar pengembangan di Unity. Jika Anda baru mengenal Unity, lihat tutorial lain di mesin ini terlebih dahulu .

Apa itu unit test?


Sebelum mempelajari kode, penting untuk mendapatkan pemahaman yang jelas tentang apa pengujian unit itu. Sederhananya, pengujian unit adalah pengujian ... unit.

Tes unit (idealnya) dirancang untuk menguji unit kode yang terpisah. Komposisi "unit" dapat bervariasi, tetapi penting untuk diingat bahwa pengujian unit harus menguji tepat satu "elemen" pada suatu waktu.

Tes unit perlu dibuat untuk memverifikasi bahwa sepotong kecil kode logis dalam skenario tertentu berjalan persis seperti yang Anda harapkan. Ini bisa sulit dipahami sebelum Anda mulai menulis unit test Anda sendiri, jadi mari kita lihat sebuah contoh:

Anda telah menulis metode yang memungkinkan pengguna memasukkan nama. Metode ini ditulis sehingga angka tidak diperbolehkan dalam nama, dan nama itu sendiri dapat terdiri dari hanya sepuluh karakter atau kurang. Metode Anda memotong ketukan tombol masing-masing dan menambahkan karakter yang sesuai ke bidang name :

 public string name = "" public void UpdateNameWithCharacter(char: character) { // 1 if (!Char.IsLetter(char)) { return; } // 2 if (name.Length > 10) { return; } // 3 name += character; }

Apa yang terjadi di sini:

  1. Jika karakter bukan huruf, maka kode keluar dari fungsi dan tidak menambahkan karakter ke string.
  2. Jika nama panjangnya sepuluh karakter atau lebih, kode tersebut tidak memungkinkan pengguna untuk menambahkan karakter lain.
  3. Jika dua pemeriksaan ini diteruskan, kode akan menambahkan karakter ke akhir nama.

Unit ini dapat diuji, karena merupakan "modul" dari pekerjaan yang dilakukan. Tes unit menegakkan logika metode.

Contoh Uji Unit


Bagaimana cara menulis unit test untuk metode UpdateNameWithCharacter ?

Sebelum kita mulai menerapkan tes unit ini, kita perlu mempertimbangkan dengan hati-hati apa yang dilakukan tes ini dan menghasilkan nama untuknya.

Lihatlah contoh-contoh nama tes unit di bawah ini. Dari nama-nama itu harus jelas bahwa mereka memeriksa:

UpdateNameDoesntAllowCharacterAddingToNameIfNameIsTenOrMoreCharactersInLength

UpdateNameAllowsLettersToBeAddedToName

UpdateNameDoesntAllowNonLettersToBeAddedToName

Dari nama-nama metode pengujian ini, kami melihat bahwa kami benar-benar memeriksa apakah "unit" pekerjaan UpdateNameWithCharacter oleh metode UpdateNameWithCharacter . Nama pengujian ini mungkin tampak terlalu panjang dan terperinci, tetapi bagus untuk kita.

Setiap tes unit yang Anda tulis adalah bagian dari serangkaian tes. Suite tes berisi semua tes unit yang terkait dengan grup logis fungsional (misalnya, "tes unit pertempuran"). Jika ada tes dari kit gagal tes, maka seluruh test suite gagal.


Peluncuran game


Buka proyek Crashteroids Starter (Anda dapat mengunduhnya dari sini ), lalu buka adegan Permainan dari folder Aset / RW / Adegan .


Klik Play untuk meluncurkan Crashteroids, dan kemudian klik tombol Start Game . Pindahkan pesawat ruang angkasa dengan panah kiri dan kanan di keyboard.

Untuk menembakkan sinar laser, tekan bilah spasi . Jika balok menyentuh asteroid, maka skor akan meningkat satu. Jika asteroid bertabrakan dengan sebuah kapal, kapal itu meledak dan permainan berakhir (dengan kemampuan untuk memulai lagi).


Cobalah untuk bermain sedikit dan pastikan bahwa setelah tabrakan asteroid dengan kapal muncul tulisan Game Over.


Memulai dengan Runner Uji Unity


Sekarang kita tahu bagaimana permainan berjalan, sekarang saatnya untuk menulis tes unit untuk memverifikasi bahwa semuanya berjalan sebagaimana mestinya. Jadi, jika Anda (atau orang lain) memutuskan untuk memperbarui game, Anda akan yakin bahwa pembaruan itu tidak akan merusak apa pun yang berhasil sebelumnya.

Untuk menulis tes, Anda harus terlebih dahulu belajar tentang Pelari Tes Persatuan. Test Runner memungkinkan Anda untuk menjalankan tes dan memeriksa apakah tes tersebut berhasil. Untuk membuka Unity Test Runner, pilih Window ▸ General ▸ Test Runner .


Setelah Test Runner terbuka di jendela baru, Anda dapat menyederhanakan hidup Anda dengan mengklik jendela Test Runner dan menariknya ke tempat di sebelah jendela Scene.


Mempersiapkan NUnit dan Folder Tes


Test Runner adalah fitur pengujian unit yang disediakan oleh Unity, tetapi menggunakan kerangka kerja NUnit . Ketika Anda mulai bekerja dengan unit test lebih serius, saya sarankan mempelajari wiki di NUnit untuk mempelajari lebih lanjut. Tentang semua yang Anda butuhkan untuk pertama kalinya akan dibahas dalam artikel ini.

Untuk menjalankan tes, pertama-tama kita perlu membuat folder tes di mana kelas tes akan disimpan.

Di jendela Proyek, pilih folder RW . Lihatlah jendela Test Runner dan pastikan PlayMode dipilih.

Klik tombol yang disebut Buat Folder Perakitan Tes PlayMode . Anda akan melihat folder baru muncul di folder RW. Kami puas dengan Tes nama standar, jadi Anda cukup menekan Enter .


Anda mungkin bertanya-tanya apa dua tab berbeda ini di dalam Test Runner.

Tab PlayMode digunakan untuk tes yang dilakukan dalam mode Play (saat game berjalan dalam waktu nyata). Tes pada tab EditMode dijalankan di luar mode Play, yang nyaman untuk menguji hal-hal seperti perilaku khusus di Inspektur.

Dalam tutorial ini, kita akan membahas tes PlayMode. Tetapi ketika Anda merasa nyaman, Anda dapat mencoba bereksperimen dengan pengujian di EditMode. Saat bekerja dengan Test Runner dalam tutorial ini, selalu pastikan bahwa tab PlayMode dipilih .

Apa yang ada di dalam test suite?


Seperti yang telah kita pelajari di atas, uji unit adalah fungsi yang menguji perilaku sepotong kecil kode tertentu. Karena unit test adalah metode, untuk menjalankannya, harus dalam file kelas.

Test Runner memintas semua file kelas uji dan melakukan tes unit dari mereka. File kelas yang berisi unit test disebut test suite.

Di dalam test suite, kami secara logis membagi pengujian kami. Kita harus memisahkan kode tes menjadi set logis yang terpisah (misalnya, satu set tes untuk fisika dan set terpisah untuk pertempuran). Dalam tutorial ini kita hanya perlu satu set tes, dan sekarang saatnya untuk membuatnya.

Mempersiapkan unit uji dan ruang uji


Pilih folder Tes dan di jendela Test Runner klik pada tombol Buat Skrip Tes di folder saat ini . Beri nama file TestSuite baru.


Selain file C # baru, mesin Unity juga membuat file lain yang disebut Tests.asmdef . Ini adalah file definisi rakitan , yang digunakan untuk menunjukkan Unity di mana dependensi file uji berada. Ini diperlukan karena kode aplikasi yang sudah selesai terkandung secara terpisah dari kode uji.

Jika Anda memiliki situasi di mana Unity tidak dapat menemukan file tes atau tes, maka pastikan bahwa ada file definisi rakitan yang menyertakan suite pengujian Anda. Langkah selanjutnya adalah mengkonfigurasinya.

Agar kode tes memiliki akses ke kelas game, kami akan membuat rakitan kode kelas dan mengatur tautan di rakitan Tes. Klik pada folder Script untuk memilihnya. Klik kanan pada folder ini dan pilih Create ▸ Assembly Definition .


Beri nama file GameAssembly .


Klik folder Tes , dan kemudian file definisi Tes membangun. Di Inspektur, klik tombol tambah di bawah judul Referensi Definisi Majelis .


Anda akan melihat bidang Referensi Hilang . Klik pada titik di sebelah bidang ini untuk membuka jendela pemilihan. Pilih file GameAssembly .


Anda harus melihat file rakitan GameAssembly di bagian tautan. Klik tombol Terapkan untuk menyimpan perubahan ini.


Jika Anda tidak mengikuti langkah-langkah ini, Anda tidak akan dapat merujuk file kelas gim di dalam file pengujian unit. Setelah berurusan dengan ini, Anda dapat melanjutkan ke kode.

Kami menulis unit test pertama


Klik dua kali pada skrip TestSuite untuk membukanya di editor kode. Ganti semua kode dengan ini:

 using UnityEngine; using UnityEngine.TestTools; using NUnit.Framework; using System.Collections; public class TestSuite { }

Tes apa yang perlu kita tulis? Jujur, bahkan dalam gim kecil seperti Crashteroids, Anda dapat menulis beberapa tes untuk memverifikasi bahwa semuanya berfungsi sebagaimana mestinya. Dalam tutorial ini, kami membatasi diri hanya pada bidang utama: pengenalan tabrakan dan mekanisme permainan dasar.

Catatan : dalam hal menulis unit test suatu produk pada tingkat produksi, Anda harus membayar cukup waktu untuk memperhitungkan semua kasus batas yang perlu diuji di semua area kode.

Sebagai tes pertama, senang memeriksa apakah asteroid benar-benar bergerak ke bawah. Akan sulit bagi mereka untuk bertabrakan dengan kapal jika mereka menjauh darinya! Tambahkan metode berikut dan variabel pribadi ke skrip TestSuite :

 private Game game; // 1 [UnityTest] public IEnumerator AsteroidsMoveDown() { // 2 GameObject gameGameObject = MonoBehaviour.Instantiate(Resources.Load<GameObject>("Prefabs/Game")); game = gameGameObject.GetComponent<Game>(); // 3 GameObject asteroid = game.GetSpawner().SpawnAsteroid(); // 4 float initialYPos = asteroid.transform.position.y; // 5 yield return new WaitForSeconds(0.1f); // 6 Assert.Less(asteroid.transform.position.y, initialYPos); // 7 Object.Destroy(game.gameObject); }

Hanya ada beberapa baris kode, tetapi mereka melakukan banyak hal. Jadi mari kita berhenti dan berurusan dengan setiap bagian:

  1. Ini adalah atribut . Atribut mendefinisikan perilaku kompiler tertentu. Atribut ini memberi tahu kompilator Unity bahwa kode tersebut adalah unit test. Karena ini, itu akan muncul di Test Runner ketika memulai tes.
  2. Buat instance dari Game. Semua yang lain tertanam dalam gim, jadi saat kami membuatnya, itu akan berisi semua yang perlu diuji. Dalam lingkungan produksi, kemungkinan besar semua elemen tidak akan berada di dalam cetakan yang sama. Oleh karena itu, Anda harus membuat ulang semua objek yang diperlukan dalam adegan.
  3. Di sini kita membuat asteroid sehingga kita bisa memantau apakah itu bergerak. Metode SpawnAsteroid mengembalikan turunan asteroid yang dibuat. Komponen Asteroid memiliki metode Move (jika Anda ingin tahu bagaimana gerakan bekerja, Anda dapat melihat skrip Asteroid di dalam RW / Script ).
  4. Pelacakan posisi awal diperlukan untuk memastikan bahwa asteroid telah bergerak turun.
  5. Semua tes unit Unity adalah coroutine, jadi Anda perlu menambahkan pengembalian lunak. Kami juga menambahkan langkah waktu 0,1 detik untuk mensimulasikan berlalunya waktu yang asteroid seharusnya turun. Jika Anda tidak perlu mensimulasikan langkah waktu, Anda dapat mengembalikan nol.
  6. Ini adalah tahap penegasan , di mana kami mengklaim bahwa posisi asteroid lebih kecil dari posisi awal (artinya, ia telah bergerak ke bawah). Memahami asersi adalah bagian penting dari pengujian unit, dan NUnit menyediakan berbagai metode asersi. Lulus atau tidak lulus tes ditentukan oleh baris ini.
  7. Tentu saja, tidak ada yang akan memarahi Anda karena kekacauan yang tersisa setelah menyelesaikan tes, tetapi tes lain mungkin gagal karena itu. Selalu penting untuk membersihkan (menghapus atau mengatur ulang) kode setelah pengujian unit, sehingga ketika Anda menjalankan tes unit berikutnya tidak ada artefak yang tersisa yang dapat mempengaruhi tes ini. Cukup bagi kita untuk menghapus objek game, karena untuk setiap tes kita membuat instance game yang sama sekali baru.

Lulus tes


Nah, Anda menulis unit test pertama Anda, tetapi bagaimana Anda tahu jika itu berhasil? Tentu saja, dengan Test Runner! Di jendela Test Runner, perluas semua garis dengan panah. Anda akan melihat tes AsteroidsMoveDown dalam daftar dengan lingkaran abu-abu:


Lingkaran abu-abu menunjukkan bahwa tes belum selesai. Jika tes telah dimulai dan lulus, maka panah hijau ditampilkan di sebelahnya. Jika tes gagal, maka X merah akan ditampilkan di sebelahnya.Jalankan tes dengan mengklik tombol RunAll .


Ini akan membuat adegan sementara dan menjalankan tes. Setelah selesai, Anda akan melihat bahwa tes lulus.


Anda telah berhasil menulis unit test pertama Anda yang menyatakan bahwa asteroid yang dibuat bergerak turun.

Catatan : sebelum Anda mulai menulis tes unit Anda sendiri, Anda harus memahami implementasi yang Anda uji. Jika Anda ingin tahu bagaimana logika yang Anda uji berfungsi, maka pelajari kode di folder RW / Script .

Menggunakan tes integrasi


Sebelum bergerak lebih jauh ke dalam lubang uji unit kelinci, inilah saatnya untuk mengetahui apa tes integrasi dan bagaimana mereka berbeda dari pengujian unit.

Tes integrasi adalah tes yang memverifikasi bagaimana "modul" kode bekerja bersama. "Modul" adalah istilah fuzzy lainnya. Perbedaan penting adalah bahwa tes integrasi harus menguji operasi perangkat lunak dalam produksi nyata (mis. Ketika seorang pemain benar-benar memainkan permainan).


Katakanlah Anda membuat game pertempuran di mana seorang pemain membunuh monster. Anda dapat membuat tes integrasi untuk memastikan bahwa ketika seorang pemain membunuh 100 musuh, sebuah prestasi dibuka ("Prestasi").

Tes ini akan memengaruhi beberapa modul kode. Kemungkinan besar, itu akan menyangkut mesin fisik (pengakuan tabrakan), dispatcher musuh (memantau kesehatan musuh dan memproses kerusakan, serta melewati ke peristiwa terkait lainnya) dan pelacak peristiwa yang melacak semua peristiwa yang dipicu (misalnya, "monster terbunuh"). Kemudian, ketika tiba saatnya untuk membuka pencapaian, ia dapat memanggil manajer prestasi.

Tes integrasi akan mensimulasikan pemain yang membunuh 100 monster dan memeriksa apakah pencapaiannya tidak terkunci. Ini sangat berbeda dari unit test karena ia menguji komponen kode besar yang bekerja bersama.

Dalam tutorial ini, kami tidak akan mempelajari tes integrasi, tetapi ini harus menunjukkan perbedaan antara unit kerja (dan mengapa itu sedang diuji unit) dan modul kode (dan mengapa itu sedang diuji integrasi).

Menambahkan tes ke suite tes


Tes selanjutnya akan menguji akhir pertandingan ketika kapal bertabrakan dengan asteroid. Dengan TestSuite terbuka di editor kode, tambahkan tes yang ditunjukkan di bawah ini di bawah tes unit pertama dan simpan file:

 [UnityTest] public IEnumerator GameOverOccursOnAsteroidCollision() { GameObject gameGameObject = MonoBehaviour.Instantiate(Resources.Load<GameObject>("Prefabs/Game")); Game game = gameGameObject.GetComponent<Game>(); GameObject asteroid = game.GetSpawner().SpawnAsteroid(); //1 asteroid.transform.position = game.GetShip().transform.position; //2 yield return new WaitForSeconds(0.1f); //3 Assert.True(game.isGameOver); Object.Destroy(game.gameObject); }

Kami sudah melihat sebagian besar kode ini dalam tes sebelumnya, tetapi ada beberapa perbedaan:

  1. Kami memaksa asteroid dan kapal bertabrakan, jelas memberikan asteroid posisi yang sama dengan kapal. Ini akan membuat tabrakan dari hitbox mereka dan mengarah ke akhir permainan. Jika Anda penasaran bagaimana kode ini bekerja, lihat file Ship , Game , dan Asteroid di folder Scripts.
  2. Sebuah langkah waktu diperlukan untuk acara Tabrakan dari mesin fisik untuk menyala, sehingga penundaan 0,1 detik dikembalikan.
  3. Pernyataan ini benar, dan itu memverifikasi bahwa flag gameOver dalam skrip Game itu benar. Bendera mengambil benar selama operasi game, ketika kapal dihancurkan, yaitu, kami menguji untuk memastikan bahwa itu disetel ke benar setelah kehancuran kapal.

Kembali ke jendela Test Runner dan Anda akan melihat bahwa tes unit baru telah muncul di sana.


Kali ini kita akan menjalankan yang ini bukan seluruh test suite. Klik pada GameOverOccursOnAsteroidCollision , dan kemudian pada tombol Run Selected .


Dan voila, kami lulus ujian lain.


Tahapan penyetelan dan penghancuran


Anda mungkin telah memperhatikan bahwa dalam dua pengujian kami ada kode berulang: di mana objek Game dibuat dan di mana tautan ke skrip Game diatur:

 GameObject gameGameObject = MonoBehaviour.Instantiate(Resources.Load<GameObject>("Prefabs/Game")); game = gameGameObject.GetComponent<Game>();

Anda juga akan melihat bahwa ada pengulangan dalam penghancuran objek Game:

 Object.Destroy(game.gameObject);

Ketika pengujian ini terjadi sangat sering. Ketika datang untuk menjalankan tes unit, sebenarnya ada dua fase: fase Pengaturan dan fase Tear Down .

Semua kode di dalam metode Pengaturan akan dieksekusi sebelum pengujian unit (dalam set ini), dan semua kode di dalam metode Tear Down akan dieksekusi setelah pengujian unit (dalam set ini).

Inilah saatnya menyederhanakan hidup kita dengan memindahkan pengaturan dan meruntuhkan kode ke metode khusus. Buka editor kode dan tambahkan kode berikut di awal file TestSuite , tepat sebelum atribut [UnityTest] pertama:

 [SetUp] public void Setup() { GameObject gameGameObject = MonoBehaviour.Instantiate(Resources.Load<GameObject>("Prefabs/Game")); game = gameGameObject.GetComponent<Game>(); }

Atribut SetUp menunjukkan bahwa metode ini dipanggil sebelum setiap tes SetUp .

Kemudian tambahkan metode berikut dan simpan file:

 [TearDown] public void Teardown() { Object.Destroy(game.gameObject); }

Atribut TearDown menunjukkan bahwa metode ini dipanggil setelah setiap tes TearDown .

Setelah menyiapkan kode pengaturan dan pemusnahan, hapus baris kode yang ada dalam metode ini dan ganti dengan panggilan ke metode yang sesuai. Setelah itu, kode akan terlihat seperti ini:

 public class TestSuite { private Game game; [SetUp] public void Setup() { GameObject gameGameObject = MonoBehaviour.Instantiate(Resources.Load<GameObject>("Prefabs/Game")); game = gameGameObject.GetComponent<Game>(); } [TearDown] public void Teardown() { Object.Destroy(game.gameObject); } [UnityTest] public IEnumerator AsteroidsMoveDown() { GameObject asteroid = game.GetSpawner().SpawnAsteroid(); float initialYPos = asteroid.transform.position.y; yield return new WaitForSeconds(0.1f); Assert.Less(asteroid.transform.position.y, initialYPos); } [UnityTest] public IEnumerator GameOverOccursOnAsteroidCollision() { GameObject asteroid = game.GetSpawner().SpawnAsteroid(); asteroid.transform.position = game.GetShip().transform.position; yield return new WaitForSeconds(0.1f); Assert.True(game.isGameOver); } }

Menguji Game Over dan Laser Shooting


Setelah menyiapkan metode penyetelan dan penghancuran yang menyederhanakan kehidupan kita, kita dapat mulai menambahkan tes baru di mana mereka digunakan. Tes selanjutnya adalah memverifikasi bahwa ketika seorang pemain mengklik Game Baru , nilai bool gameOver tidak benar. Tambahkan tes seperti itu ke akhir file dan simpan:

 [UnityTest] public IEnumerator NewGameRestartsGame() { //1 game.isGameOver = true; game.NewGame(); //2 Assert.False(game.isGameOver); yield return null; }

Ini seharusnya sudah akrab bagi Anda, tetapi yang berikut layak disebutkan:

  1. Sepotong kode ini mempersiapkan tes ini agar flag boolean gameOver menjadi benar. Saat memanggil metode NewGame , itu harus lagi mengatur flag ke false .
  2. Di sini kami berpendapat bahwa bool isGameOver false , yang seharusnya benar ketika menjalankan game baru.

Kembali ke Test Runner dan Anda akan melihat bahwa ada tes baru NewGameRestartsGame . Jalankan tes ini, seperti yang kami lakukan sebelumnya, dan Anda akan melihat bahwa itu berhasil:


Pernyataan Sinar Laser


Tes selanjutnya adalah menambahkan tes bahwa sinar laser yang ditembakkan oleh kapal terbang ke atas (mirip dengan tes unit pertama yang kami tulis). Buka file TestSuite di editor. Tambahkan metode berikut dan simpan file:

 [UnityTest] public IEnumerator LaserMovesUp() { // 1 GameObject laser = game.GetShip().SpawnLaser(); // 2 float initialYPos = laser.transform.position.y; yield return new WaitForSeconds(0.1f); // 3 Assert.Greater(laser.transform.position.y, initialYPos); }

Inilah yang dilakukan kode ini:

  1. Mendapat tautan ke sinar laser yang dihasilkan yang dipancarkan dari kapal.
  2. Posisi awal direkam sehingga kami dapat memverifikasi bahwa itu bergerak ke atas.
  3. Pernyataan ini konsisten dengan pernyataan dari tes unit AsteroidsMoveDown , hanya sekarang kami mengklaim bahwa nilainya lebih besar (yaitu, laser bergerak ke atas).

Simpan file dan kembali ke Test Runner. Jalankan tes LaserMovesUp dan amati bagaimana itu berlalu:


Sekarang Anda harus sudah mulai memahami cara kerja semuanya, jadi sekarang saatnya untuk menambahkan dua tes terakhir dan menyelesaikan tutorial.

Memverifikasi bahwa laser menghancurkan asteroid


Selanjutnya, kita akan memastikan bahwa ketika terkena, laser menghancurkan asteroid. Buka editor dan tambahkan tes berikut ke akhir TestSuite , dan kemudian simpan file:

 [UnityTest] public IEnumerator LaserDestroysAsteroid() { // 1 GameObject asteroid = game.GetSpawner().SpawnAsteroid(); asteroid.transform.position = Vector3.zero; GameObject laser = game.GetShip().SpawnLaser(); laser.transform.position = Vector3.zero; yield return new WaitForSeconds(0.1f); // 2 UnityEngine.Assertions.Assert.IsNull(asteroid); }

Begini cara kerjanya:

  1. Kami membuat asteroid dan sinar laser, dan menetapkan mereka posisi yang sama untuk memicu tabrakan.
  2. Ini adalah ujian khusus dengan perbedaan penting. Lihat bahwa kami secara eksplisit menggunakan UnityEngine.Assertions untuk tes ini ? Ini karena Unity memiliki kelas Null khusus yang berbeda dari kelas Null "reguler". Pernyataan kerangka kerja NUnit Assert.IsNull() tidak akan berfungsi di pemeriksaan Unity untuk null. Saat memeriksa null di Unity, Anda harus secara eksplisit menggunakan UnityEngine.Assertions.Assert, bukan Assert dari NUnit.

Kembali ke Test Runner dan jalankan tes baru. Anda akan melihat ikon hijau yang menyenangkan kami.


Untuk menguji atau tidak menguji - itulah pertanyaannya


Keputusan untuk tetap pada unit test bukanlah keputusan yang mudah dan tidak boleh dianggap enteng. Namun, manfaat dari tes ini sepadan dengan usaha. Bahkan ada metodologi pengembangan, yang disebut pengembangan uji-driven (Test Driven Development, TDD).

Bekerja dalam kerangka TDD, Anda menulis tes sebelum menulis logika aplikasi itu sendiri. Pertama, Anda membuat tes, pastikan program tidak lulus, dan kemudian tulis kode yang hanya dirancang untuk lulus tes. Ini mungkin pendekatan yang sangat berbeda untuk pengkodean, tetapi memastikan bahwa Anda menulis kode dengan cara yang sesuai untuk pengujian.

Ingatlah hal ini ketika Anda mulai mengerjakan proyek Anda berikutnya. Tetapi untuk saat ini, saatnya untuk menulis unit test Anda sendiri, yang untuk itu Anda membutuhkan game yang telah kami sediakan untuk Anda.

: — , . , . «» , , . , . , . , , .

Pengujian dapat menjadi investasi besar, jadi pertimbangkan kelebihan dan kekurangan dari menambahkan pengujian unit ke proyek Anda:

Keuntungan Pengujian Unit


Pengujian unit memiliki banyak keuntungan penting, termasuk yang berikut:

  • Ini memberi keyakinan bahwa metode berperilaku seperti yang diharapkan.
  • Berfungsi sebagai dokumentasi untuk orang baru yang mempelajari basis kode (tes unit sangat bagus untuk mengajar).
  • Membuat Anda menulis kode dengan cara yang dapat diuji.
  • Memungkinkan mengisolasi dan memperbaiki kesalahan lebih cepat.
  • Itu tidak memungkinkan pembaruan di masa depan untuk menambahkan bug baru ke kode kerja lama (mereka disebut kesalahan regresi).

Kekurangan Pengujian Unit


Namun, Anda mungkin tidak punya waktu atau anggaran untuk pengujian unit. Berikut adalah kekurangannya untuk dipertimbangkan:

  • Tes menulis bisa memakan waktu lebih lama daripada kode itu sendiri.
  • .
  • .
  • , .
  • , -.
  • ( ), .
  • - .
  • UI .
  • .
  • .

,


Saatnya menulis tes terakhir. Buka editor kode, tambahkan kode di bawah ini ke akhir file TestSuite dan simpan:

 [UnityTest] public IEnumerator DestroyedAsteroidRaisesScore() { // 1 GameObject asteroid = game.GetSpawner().SpawnAsteroid(); asteroid.transform.position = Vector3.zero; GameObject laser = game.GetShip().SpawnLaser(); laser.transform.position = Vector3.zero; yield return new WaitForSeconds(0.1f); // 2 Assert.AreEqual(game.score, 1); }

Ini adalah tes penting, memverifikasi bahwa ketika seorang pemain menghancurkan asteroid, skornya meningkat. Ini terdiri dari:

  1. Kami membuat asteroid dan sinar laser, dan menempatkannya di satu posisi. Karena ini, tabrakan muncul yang memicu peningkatan skor.
  2. Pernyataan bahwa game.score sekarang 1 (dan bukan 0, seperti di awal).

Simpan kode dan kembali ke Test Runner untuk menjalankan tes terakhir ini dan lihat apakah itu menjalankan permainan:


Luar biasa! Semua tes lulus.

Ke mana harus pergi selanjutnya?


Dalam artikel tersebut kami memeriksa sejumlah besar informasi. Jika Anda ingin membandingkan karya Anda dengan tugas akhir, maka lihatlah di arsip , tautan yang juga ditunjukkan di awal artikel.

Dalam tutorial ini, Anda mempelajari tes unit apa dan bagaimana menulisnya di Unity. Selain itu, Anda menulis enam unit pengujian yang berhasil melewati kode, dan berkenalan dengan beberapa pro dan kontra dari pengujian unit.

Merasa percaya diri? Maka Anda dapat menulis lebih banyak tes. Periksa file kelas gim dan coba tulis unit test untuk bagian kode lainnya. Pertimbangkan untuk menambahkan tes untuk skenario berikut:

  • Setiap jenis asteroid saat Anda menyentuh kapal mengarah ke akhir permainan.
  • Memulai game baru akan mengatur ulang skor.
  • Gerakan ke kiri dan ke kanan agar kapal bekerja dengan benar.

Jika Anda ingin meningkatkan pengetahuan Anda tentang pengujian unit, maka ada baiknya mengeksplorasi implementasi dependensi dan kerangka kerja untuk bekerja dengan objek tiruan . Ini dapat sangat menyederhanakan pengaturan pengujian.

Baca juga dokumentasi NUnit untuk mempelajari lebih lanjut tentang kerangka NUnit.

Dan jangan ragu untuk membagikan pemikiran dan pertanyaan Anda di forum.

Pengujian yang berhasil!

Source: https://habr.com/ru/post/id456090/

More articles:


All Articles