Kerangka UnitTest - Pernyataan

Kerangka pengujian Python menggunakan fungsi assert () bawaan Python yang menguji kondisi tertentu. Jika pernyataan gagal, AssertionError akan dimunculkan. Kerangka pengujian kemudian akan mengidentifikasi pengujian sebagai Kegagalan. Pengecualian lain diperlakukan sebagai Error.

Tiga set fungsi pernyataan berikut didefinisikan dalam modul unittest -

  • Boolean Asserts Dasar
  • Comparative Asserts
  • Ditegaskan untuk Koleksi

Fungsi pernyataan dasar mengevaluasi apakah hasil operasi True atau False. Semua metode assert menerima amsg argumen yang, jika ditentukan, digunakan sebagai pesan kesalahan tentang kegagalan.

Sr.No. Metode & Deskripsi
1

assertEqual(arg1, arg2, msg = None)

Uji apakah arg1 dan arg2 sama. Jika nilainya tidak sama, pengujian akan gagal.
2

assertNotEqual(arg1, arg2, msg = None)

Uji bahwa arg1 dan arg2 tidak sama. Jika nilainya sama, pengujian akan gagal.
3

assertTrue(expr, msg = None)

Uji bahwa expr benar. Jika salah, pengujian gagal
4

assertFalse(expr, msg = None)

Uji bahwa expr salah. Jika benar, pengujian gagal
5

assertIs(arg1, arg2, msg = None)

Uji apakah arg1 dan arg2 mengevaluasi ke objek yang sama.
6

assertIsNot(arg1, arg2, msg = None)

Uji bahwa arg1 dan arg2 tidak mengevaluasi objek yang sama.
7

assertIsNone(expr, msg = None)

Uji bahwa expr adalah None. Jika tidak ada, pengujian gagal
8

assertIsNotNone(expr, msg = None)

Uji bahwa expr bukan Tidak ada. Jika Tidak Ada, pengujian gagal
9

assertIn(arg1, arg2, msg = None)

Uji apakah arg1 ada dalam arg2 .
10

assertNotIn(arg1, arg2, msg = None)

Uji bahwa arg1 tidak ada dalam arg2 .
11

assertIsInstance(obj, cls, msg = None)

Uji bahwa obj adalah turunan dari cls
12

assertNotIsInstance(obj, cls, msg = None)

Uji bahwa obj bukan merupakan turunan dari cls

Beberapa fungsi pernyataan di atas diimplementasikan dalam kode berikut -

import unittest

class SimpleTest(unittest.TestCase):
   def test1(self):
      self.assertEqual(4 + 5,9)
   def test2(self):
      self.assertNotEqual(5 * 2,10)
   def test3(self):
      self.assertTrue(4 + 5 == 9,"The result is False")
   def test4(self):
      self.assertTrue(4 + 5 == 10,"assertion fails")
   def test5(self):
      self.assertIn(3,[1,2,3])
   def test6(self):
      self.assertNotIn(3, range(5))

if __name__ == '__main__':
   unittest.main()

Ketika skrip di atas dijalankan, test2, test4 dan test6 akan menunjukkan kegagalan dan lainnya berjalan dengan sukses.

FAIL: test2 (__main__.SimpleTest)
----------------------------------------------------------------------
Traceback (most recent call last):
   File "C:\Python27\SimpleTest.py", line 9, in test2
      self.assertNotEqual(5*2,10)
AssertionError: 10 == 10

FAIL: test4 (__main__.SimpleTest)
----------------------------------------------------------------------
Traceback (most recent call last):
   File "C:\Python27\SimpleTest.py", line 13, in test4
      self.assertTrue(4+5==10,"assertion fails")
AssertionError: assertion fails

FAIL: test6 (__main__.SimpleTest)
----------------------------------------------------------------------
Traceback (most recent call last):
   File "C:\Python27\SimpleTest.py", line 17, in test6
      self.assertNotIn(3, range(5))
AssertionError: 3 unexpectedly found in [0, 1, 2, 3, 4]

----------------------------------------------------------------------            
Ran 6 tests in 0.001s                                                             
                                                                                  
FAILED (failures = 3)

Kumpulan fungsi pernyataan kedua adalah comparative asserts −

  • assertAlmostEqual (pertama, kedua, tempat = 7, msg = Tidak ada, delta = Tidak ada)

    Uji bahwa pertama dan kedua kira-kira (atau tidak kira-kira) sama dengan menghitung selisihnya, membulatkan ke jumlah tempat desimal yang ditentukan (default 7),

  • assertNotAlmostEqual (pertama, kedua, tempat, pesan, delta)

    Ujilah bahwa pertama dan kedua tidak kira-kira sama dengan menghitung selisihnya, membulatkan ke jumlah tempat desimal tertentu (default 7), dan membandingkannya dengan nol.

    Dalam kedua fungsi di atas, jika delta disuplai dan bukan tempat, maka perbedaan antara pertama dan kedua harus kurang atau sama dengan (atau lebih besar dari) delta.

    Memasok delta dan tempat memunculkan TypeError.

  • assertGreater (pertama, kedua, msg = Tidak Ada)

    Uji yang pertama lebih besar dari yang kedua tergantung pada nama metode. Jika tidak, pengujian akan gagal.

  • assertGreaterEqual (pertama, kedua, msg = Tidak Ada)

    Uji yang pertama lebih besar dari atau sama dengan kedua tergantung pada nama metode. Jika tidak, pengujian akan gagal

  • assertLess (pertama, kedua, msg = Tidak Ada)

    Uji yang pertama kurang dari yang kedua tergantung pada nama metode. Jika tidak, pengujian akan gagal

  • assertLessEqual (pertama, kedua, msg = Tidak Ada)

    Uji yang pertama kurang dari atau sama dengan yang kedua tergantung pada nama metode. Jika tidak, pengujian akan gagal.

  • assertRegexpMatches (teks, ekspresi reguler, msg = Tidak Ada)

    Uji apakah pencarian regexp cocok dengan teks. Jika terjadi kegagalan, pesan kesalahan akan menyertakan pola dan teks. regexp dapat berupa objek ekspresi reguler atau string yang berisi ekspresi reguler yang cocok untuk digunakan olehre.search().

  • assertNotRegexpMatches (teks, ekspresi reguler, msg = Tidak Ada)

    Memverifikasi bahwa pencarian regexp tidak cocok dengan teks . Gagal dengan pesan kesalahan termasuk pola dan bagian teks yang cocok. regexp dapat berupa objek ekspresi reguler atau string yang berisi ekspresi reguler yang cocok untuk digunakan oleh re.search () .

Fungsi pernyataan diimplementasikan dalam contoh berikut -

import unittest
import math
import re

class SimpleTest(unittest.TestCase):
   def test1(self):
      self.assertAlmostEqual(22.0/7,3.14)
   def test2(self):
      self.assertNotAlmostEqual(10.0/3,3)
   def test3(self):
      self.assertGreater(math.pi,3)
   def test4(self):
      self.assertNotRegexpMatches("Tutorials Point (I) Private Limited","Point")

if __name__ == '__main__':
   unittest.main()

Skrip di atas melaporkan test1 dan test4 sebagai Kegagalan. Dalam test1, pembagian 22/7 tidak berada dalam 7 tempat desimal 3,14. Demikian pula, karena argumen kedua cocok dengan teks dalam argumen pertama, test4 menghasilkan AssertionError.

=====================================================FAIL: test1 (__main__.SimpleTest)
----------------------------------------------------------------------
Traceback (most recent call last):
   File "asserttest.py", line 7, in test1
      self.assertAlmostEqual(22.0/7,3.14)
AssertionError: 3.142857142857143 != 3.14 within 7 places
================================================================
FAIL: test4 (__main__.SimpleTest)
----------------------------------------------------------------------
Traceback (most recent call last):
   File "asserttest.py", line 13, in test4
      self.assertNotRegexpMatches("Tutorials Point (I) Private Limited","Point")
AssertionError: Regexp matched: 'Point' matches 'Point' in 'Tutorials Point (I)
Private Limited'
----------------------------------------------------------------------

Ran 4 tests in 0.001s                                                             
                                                                                  
FAILED (failures = 2)

Tegaskan untuk Koleksi

Kumpulan fungsi assert ini dimaksudkan untuk digunakan dengan tipe data kumpulan di Python, seperti List, Tuple, Dictionary dan Set.

Sr.No. Metode & Deskripsi
1

assertListEqual (list1, list2, msg = None)

Menguji bahwa dua daftar sama. Jika tidak, pesan kesalahan dibuat yang hanya menunjukkan perbedaan antara keduanya.
2

assertTupleEqual (tuple1, tuple2, msg = None)

Menguji bahwa dua tupel sama. Jika tidak, pesan kesalahan dibuat yang hanya menunjukkan perbedaan antara keduanya.
3

assertSetEqual (set1, set2, msg = None)

Menguji bahwa dua set sama. Jika tidak, pesan kesalahan dibuat yang mencantumkan perbedaan antara set.
4

assertDictEqual (expected, actual, msg = None)

Ujilah bahwa dua kamus itu sama. Jika tidak, pesan kesalahan akan dibuat yang menunjukkan perbedaan dalam kamus.

Contoh berikut mengimplementasikan metode di atas -

import unittest

class SimpleTest(unittest.TestCase):
   def test1(self):
      self.assertListEqual([2,3,4], [1,2,3,4,5])
   def test2(self):
      self.assertTupleEqual((1*2,2*2,3*2), (2,4,6))
   def test3(self):
      self.assertDictEqual({1:11,2:22},{3:33,2:22,1:11})

if __name__ == '__main__':
   unittest.main()

Dalam contoh di atas, test1 dan test3 menampilkan AssertionError. Pesan kesalahan menampilkan perbedaan dalam objek Daftar dan Kamus.

FAIL: test1 (__main__.SimpleTest)
----------------------------------------------------------------------
Traceback (most recent call last):
   File "asserttest.py", line 5, in test1
      self.assertListEqual([2,3,4], [1,2,3,4,5])
AssertionError: Lists differ: [2, 3, 4] != [1, 2, 3, 4, 5]

First differing element 0:
2
1

Second list contains 2 additional elements.
First extra element 3:
4

- [2, 3, 4]
+ [1, 2, 3, 4, 5]
? +++       +++

FAIL: test3 (__main__.SimpleTest)
----------------------------------------------------------------------
Traceback (most recent call last):
   File "asserttest.py", line 9, in test3
      self.assertDictEqual({1:11,2:22},{3:33,2:22,1:11})
AssertionError: {1: 11, 2: 22} != {1: 11, 2: 22, 3: 33}
- {1: 11, 2: 22}
+ {1: 11, 2: 22, 3: 33}
?              +++++++
                                                                                  
----------------------------------------------------------------------            
Ran 3 tests in 0.001s                                                             
                                                                                  
FAILED (failures = 2)
ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved