Python MIT 6.100L: Testing, Debugging, Exception, dan Assertion

1
def akar_kuadrat(x, epsilon=0.001):
2
    """
3
    Mengembalikan aproksimasi akar kuadrat x.
4
    x: float >= 0
5
    epsilon: float > 0, toleransi error
6
    Returns: float y sedemikian sehingga abs(y*y - x) < epsilon
7
    """
8
    # implementasi tidak terlihat oleh black-box tester
9
    ...

1
def cari_nilai(L, x):
2
    """Cari x di list L, return True jika ada."""
3
    for item in L:
4
        if item == x:
5
            return True    # jalur 1: ketemu
6
    return False           # jalur 2: tidak ketemu

1
# Uji jalur 1: x ada di L
2
assert cari_nilai([1, 2, 3], 2) == True
3

4
# Uji jalur 2: x tidak ada di L
5
assert cari_nilai([1, 2, 3], 5) == False
6

7
# Uji edge: list kosong
8
assert cari_nilai([], 1) == False
9

10
# Uji edge: x ada di posisi pertama dan terakhir
11
assert cari_nilai([5, 1, 2], 5) == True
12
assert cari_nilai([1, 2, 5], 5) == True

1
def faktorial(n):
2
    """Hitung n! untuk n >= 0."""
3
    if n == 0:
4
        return 1
5
    return n * faktorial(n - 1)
6

7
# Test manual
8
def test_faktorial():
9
    assert faktorial(0) == 1,   "0! harus 1"
10
    assert faktorial(1) == 1,   "1! harus 1"
11
    assert faktorial(5) == 120, "5! harus 120"
12
    assert faktorial(10) == 3628800
13
    print("Semua test lulus!")
14

15
test_faktorial()

1
def hitung_rata_rata(angka):
2
    total = 0
3
    for i, x in enumerate(angka):
4
        total += x
5
        print(f"  step {i}: x={x}, total={total}")  # debug
6
    rata = total / len(angka)
7
    print(f"  hasil: {rata}")  # debug
8
    return rata
9

10
hasil = hitung_rata_rata([10, 20, 30])
11
# Hapus print setelah bug ditemukan

1
# Program panjang dengan bug di suatu tempat
2
# Daripada cek baris per baris...
3

4
def proses_data(data):
5
    # --- checkpoint 1 ---
6
    hasil_a = langkah_a(data)
7
    print(f"[DEBUG] setelah langkah_a: {hasil_a}")  # cek di sini
8

9
    # --- checkpoint 2 ---
10
    hasil_b = langkah_b(hasil_a)
11
    print(f"[DEBUG] setelah langkah_b: {hasil_b}")  # lalu di sini
12

13
    # Kalau checkpoint 1 benar tapi 2 salah → bug di langkah_b
14
    return langkah_c(hasil_b)

1
# Contoh: bug pada fungsi penjumlahan list
2
def jumlah(L):
3
    total = 0
4
    for i in range(len(L) + 1):  # BUG: seharusnya range(len(L))
5
        total += L[i]
6
    return total
7

8
# Error: IndexError: list index out of range
9
# Hipotesis: range terlalu besar
10
# Eksperimen: print i dan len(L)
11
# Perbaikan: ubah len(L)+1 jadi len(L)

1
# ZeroDivisionError
2
10 / 0
3

4
# TypeError
5
"5" + 3
6

7
# ValueError
8
int("abc")
9

10
# IndexError
11
L = [1, 2, 3]
12
L[10]
13

14
# KeyError
15
d = {"a": 1}
16
d["z"]
17

18
# NameError
19
print(variabel_tidak_ada)
20

21
# FileNotFoundError
22
open("file_yang_tidak_ada.txt")

1
try:
2
    angka = int(input("Masukkan angka: "))
3
    hasil = 100 / angka
4
    print(f"100 / {angka} = {hasil}")
5
except ValueError:
6
    print("Input bukan angka yang valid!")
7
except ZeroDivisionError:
8
    print("Tidak bisa dibagi nol!")

1
try:
2
    f = open("data.txt", "r")
3
    isi = f.read()
4
except FileNotFoundError:
5
    print("File tidak ditemukan")
6
    isi = ""
7
except PermissionError:
8
    print("Tidak punya akses ke file")
9
    isi = ""
10
else:
11
    # Dijalankan HANYA jika try berhasil tanpa exception
12
    print(f"File berhasil dibaca: {len(isi)} karakter")
13
finally:
14
    # SELALU dijalankan, exception atau tidak
15
    print("Selesai membaca file")
16
    # Tutup file jika berhasil dibuka
17
    try:
18
        f.close()
19
    except:
20
        pass

1
def bagi(a, b):
2
    if b == 0:
3
        raise ValueError("Pembagi tidak boleh nol")
4
    return a / b
5

6
def ambil_elemen(L, i):
7
    if not isinstance(i, int):
8
        raise TypeError(f"Index harus integer, bukan {type(i)}")
9
    if i < 0 or i >= len(L):
10
        raise IndexError(f"Index {i} di luar range [0, {len(L)-1}]")
11
    return L[i]
12

13
# Pakai fungsi di atas
14
try:
15
    print(bagi(10, 0))
16
except ValueError as e:
17
    print(f"Error: {e}")

1
class NilaiNegatifError(Exception):
2
    """Raised saat nilai yang diharapkan positif ternyata negatif."""
3
    pass
4

5
def akar_kuadrat(x):
6
    if x < 0:
7
        raise NilaiNegatifError(f"Tidak bisa menghitung akar dari {x}")
8
    return x ** 0.5
9

10
try:
11
    print(akar_kuadrat(-4))
12
except NilaiNegatifError as e:
13
    print(f"Input tidak valid: {e}")

1
def hitung_diskon(harga, persen):
2
    assert 0 <= persen <= 100, f"Persen diskon harus 0-100, dapat: {persen}"
3
    assert harga >= 0, f"Harga tidak boleh negatif, dapat: {harga}"
4

5
    diskon = harga * persen / 100
6
    harga_akhir = harga - diskon
7

8
    assert harga_akhir <= harga, "Bug: harga akhir melebihi harga awal"
9
    return harga_akhir
10

11
print(hitung_diskon(100000, 20))   # 80000.0
12
print(hitung_diskon(100000, 150))  # AssertionError!

1
# Assert: untuk kondisi internal yang "pasti" benar
2
def bagi_list(L, n):
3
    assert len(L) % n == 0, "Panjang list harus habis dibagi n"
4
    # ...
5

6
# Exception: untuk input dari luar yang tidak terprediksi
7
def konversi_suhu(nilai, dari):
8
    if dari not in ["C", "F", "K"]:
9
        raise ValueError(f"Satuan '{dari}' tidak dikenal")
10
    # ...