diff --git a/OpenSeries/fisika.py b/OpenSeries/fisika.py
index e38661e..1700afe 100644
--- a/OpenSeries/fisika.py
+++ b/OpenSeries/fisika.py
@@ -137,7 +137,7 @@ def masa_jenis(
         volume (float atau int): volume benda
 
     Return:
-        (int, flloat): hasil dari kalkulasi fungsi dari masa jenis
+        (int, float): hasil dari kalkulasi fungsi dari masa jenis
         error.ErrorTipeData: error jika tipe data data salah
         error.ErrorDibagiNol: error jika angka dibagikan dengan 0
     """
@@ -153,6 +153,164 @@ def masa_jenis(
         return error.ErrorTipeData(["int", "float"])
 
 
+def kecepatan_sudut(
+    sudut: Union[int, float], time: Union[int, float]
+) -> Union[int, float, error.ErrorTipeData, error.ErrorDibagiNol]:
+    """
+    Menghitung kecepatan sudut
+
+    Parameter:
+        sudut (float atau int): sudut tempuh benda
+        time (float atau int): waktu tempuh benda
+
+    Return:
+        (int,float): hasil dari kalkulasi fungsi kecepatan sudut
+        error.ErrorTipeData : error jika tipe data salah
+        error.ErrorDibagiNol: error jika angka dibagikan dengan 0
+    """
+    # mengecek apakah variable tersebut bertipe data int atau float
+    # jika tidak maka error
+    if all(isinstance(data, (float, int)) for data in [sudut, time]):
+        try:
+            return sudut / time
+        except ZeroDivisionError:
+            return error.ErrorDibagiNol()
+    else:
+        return error.ErrorTipeData(["int", "float"])
+
+
+def percepatan_sudut(
+    w_sudut: Union[int, float], time: Union[int, float]
+) -> Union[int, float, error.ErrorTipeData, error.ErrorDibagiNol]:
+    """
+    Menghitung percepatan sudut
+
+    Parameter:
+        w_sudut (int atau float) : kecepatan sudut
+        time    (int atau float) : waktu
+
+    Return:
+        (int,float): hasil dari kalkulasi fungsi percepatan sudut
+        error.ErrorTipeData : error jika tipe data salah
+        error.DibagiNol : error jika angka dibagikan dengan 0
+    """
+    # mengecek apakah variable tersebut bertipe data int atau float
+    # jika tidak maka error
+    if all(isinstance(data, (float, int)) for data in [w_sudut, time]):
+        try:
+            return w_sudut / time
+        except ZeroDivisionError:
+            return error.ErrorDibagiNol()
+    else:
+        return error.ErrorTipeData(["int", "float"])
+
+
+def percepatan_sentripetal_linear(
+    kecepatan: Union[int, float], jari_jari: Union[int, float]
+) -> Union[int, float, error.ErrorTipeData, error.ErrorDibagiNol]:
+    """
+    Menghitung percepatan sentripetal linear
+
+    Parameter :
+        kecepatan (int,float) : kecepatan
+        jari_jari (int,float) : jari-jari lintasan
+    Return :
+        (int,float) : hasil kalkulasi percepatan sentripetal linear
+        error.ErrorTipeData : error jika tipe data salah
+        error.ErrorDibagiNol : error jika dibagi dengan nol
+    """
+    # mengecek apakah variable tersebut bertipe data int atau float
+    # jika tidak maka error
+    if all(isinstance(data, (float, int)) for data in [kecepatan, jari_jari]):
+        try:
+            return kecepatan**2 / jari_jari
+        except ZeroDivisionError:
+            return error.ErrorDibagiNol()
+    else:
+        return error.ErrorTipeData(["int", "float"])
+
+
+def percepatan_sentripetal_sudut(
+    jari_jari: Union[int, float], kecepatan_sudut: Union[int, float]
+) -> Union[int, float, error.ErrorTipeData]:
+    """
+    Menghitung percepatan sentripetal sudut
+
+    Parameter :
+        kecepatan_sudut (int,float) : kecepatan sudut
+        jari_jari (int,float) : jari-jari lintasan
+    Return :
+        (int,float) : hasil kalkulasi percepatan sentripetal sudut
+        error.ErrorTipeData : error jika tipe data salah
+    """
+    # mengecek apakah variable tersebut bertipe data int atau float
+    # jika tidak maka error
+    if all(isinstance(data, (int, float)) for data in [kecepatan_sudut, jari_jari]):
+        return jari_jari * (kecepatan_sudut**2)
+    else:
+        return error.ErrorTipeData(["int", "float"])
+
+
+def gerak_melingkar_beraturan(
+    w_awal: Union[int, float], a_sudut: Union[int, float], t: Union[int, float]
+) -> Union[int, float, error.Error, error.ErrorTipeData]:
+    """
+    menghitung hasil dari gerak melingkar beraturan
+
+    Parameter:
+        w_awal (float atau int) : kecepatan sudut awal
+        a_sudur (float atau int): percepatan sudut
+    Return:
+        (int atau float) : hasil kalkulasi dari gerak melingkar beraturan
+        error.ErrorTipeData : error jika tipe data salah
+        error.Errorvalue : error jika waktu kurang dari 0
+    """
+    if all(isinstance(data, (int, float)) for data in [w_awal, a_sudut, t]):
+        return w_awal + a_sudut * t
+    else:
+        return error.ErrorTipeData(["Tipe data tidak sesuai"])
+
+
+def inersia(
+    m: Union[float, int], r: Union[float, int]
+) -> Union[float, int, error.Error, error.ErrorTipeData]:
+    """
+    Menghitung inersia dari suatu benda
+
+    Parameter:
+        m (float atau int): massa benda
+        r (float atau int): jari-jari
+
+    Return:
+        (int atau float) : hasil dari kalkulasi fungsi inersia
+        error.ErrorValue : error jika massa kurang dari 0
+        error.ErrorTipeData : error jika tipe data salah
+    """
+    if all(isinstance(data, (float, int)) for data in [m, r]):
+        return m * (r**2)
+    else:
+        return error.ErrorTipeData(["int", "float"])
+
+
+def energi_kinetik_rotasi(
+    inersia: Union[float, int], kecepatan_sudut: Union[int, float]
+) -> Union[int, float, error.ErrorTipeData]:
+    """
+    menghitung energi kinetik rotasi
+
+    Parameter:
+        inersia (float atau int): inersia benda
+        kecepatan_sudut (float atau int): kecepatan benda
+    Return:
+        (int atau float) : hasil kalkulasi dari energi kinetik rotasi
+        error.ErrorTipeData : error jika tipe data salah
+    """
+    if all(isinstance(data, (float, int)) for data in [inersia, kecepatan_sudut]):
+        return (1 / 2) * inersia * (kecepatan_sudut**2)
+    else:
+        return error.ErrorTipeData(["int", "float"])
+
+
 def energi_potensial(
     m: Union[int, float], g: Union[int, float], h: Union[int, float]
 ) -> Union[float, int, error.ErrorTipeData]:
@@ -293,3 +451,239 @@ def efek_doppler(
             "frekuensi tidak positif, kecepatan sumber relatif lebih besar dari kecepatan gelombang dalam medium"
         )
     return doppler
+
+
+def celcius_farenheit(celcius: Union[int, float]) -> Union[float, int]:
+    """
+    mengubah nilai celcius ke farenheit
+
+    Paramieter:
+        celcius (float atau int): nilai celcius
+
+    Return:
+        (float atau int): hasil dari kalkulasi celcius ke farenheit
+        error.ErrorTipeData: error jika tipe data salah
+    """
+    # mengecek apakah variable tersebut bertipe data int atau float
+    # jika tidak maka error
+    if not isinstance(celcius, (float, int)):
+        return error.ErrorTipeData(["float", "int"])
+    else:
+        return celcius * (9 / 5) + 32
+
+
+def farenheit_celcius(farenheit: Union[int, float]) -> Union[int, float]:
+    """
+    mengubah nilai farenheit ke celcius
+
+    Parameter:
+        farenheit(int atau float): nilai farenheit
+
+    Return:
+        (float atau int): hasil dari kalkulasi farenheit ke celcius
+        errot.ErrorTiperData: error jika data salah
+    """
+    # mengecek apakah variable tersebut bertipe data int atau float
+    # jika tidak maka error
+    if not isinstance(farenheit, (float, int)):
+        return error.ErrorTipeData(["float", "int"])
+    else:
+        return (farenheit - 32) * (5 / 9)
+
+
+def celcius_reaumur(celcius: Union[int, float]) -> Union[int, float]:
+    """
+    mengubah nilai celcius ke reaumur
+
+    Parameter:
+        celcius(int atau float): nilai celcius
+
+    Return:
+        (float atau int): hasil dari kalkulasi celcius ke reaumur
+        errot.ErrorTiperData: error jika data salah
+    """
+    # mengecek apakah variable tersebut bertipe data int atau float
+    # jika tidak maka error
+    if not isinstance(celcius, (float, int)):
+        return error.ErrorTipeData(["float", "int"])
+    else:
+        return celcius * (4 / 5)
+
+
+def reamur_celcius(reamur: Union[int, float]) -> Union[int, float]:
+    """
+    mengubah nilai reamur ke celcius
+
+    Parameter:
+        reamur(int atau float): nilai reamur
+
+    Return:
+        (float atau int): hasil dari kalkulasi celcius ke reamur
+        errot.ErrorTiperData: error jika data salah
+    """
+    # mengecek apakah variable tersebut bertipe data int atau float
+    # jika tidak maka error
+    if not isinstance(reamur, (float, int)):
+        return error.ErrorTipeData(["float", "int"])
+    else:
+        return reamur * (5 / 4)
+
+
+def celcius_kelvin(celcius: Union[int, float]) -> Union[int, float]:
+    """
+    mengubah nilai celcius ke reaumur
+
+    Parameter:
+        celcius(int atau float): nilai celcius
+
+    Return:
+        (float atau int): hasil dari kalkulasi celcius ke kelvin
+        errot.ErrorTiperData: error jika data salah
+    """
+    # mengecek apakah variable tersebut bertipe data int atau float
+    # jika tidak maka error
+    if not isinstance(celcius, (float, int)):
+        return error.ErrorTipeData(["float", "int"])
+    else:
+        return celcius + 273.15
+
+
+def kelvin_celcius(kelvin: Union[int, float]) -> Union[int, float, error.Error]:
+    """
+    mengubah celcius ke kelvin
+
+    Parameter:
+        kelvin(int atau float): nilai kelvin
+
+    Return:
+        (float atau int): hasil dari kalkulasi kelvin ke celcius
+        error.ErrorTiperData: error jika data salah
+        erro.Error: error jika nilai kelvin kurang dari nol
+    """
+    # mengecek apakah variable tersebut bertipe data int atau float
+    # jika tidak maka error
+    if not isinstance(kelvin, (float, int)):
+        return error.ErrorTipeData(["float", "int"])
+    elif kelvin < 0:
+        return error.Error("Nilai kelvin tidak boleh kurang dari 0")
+    else:
+        return 273.15 - kelvin
+
+
+def kelvin_fahrenheit(kelvin: Union[int, float]) -> Union[int, float, error.Error]:
+    """
+    mengubah kelvin ke fahrenheit
+
+    Parameter:
+        kelvin(int atau float): nilai kelvin
+
+    Return:
+        (float atau int): hasil dari kalkulasi kelvin ke fahrenheit
+        error.ErrorTiperData: error jika data salah
+        errot.Error ; error jika nilai kelvin kurang dari nol
+    """
+    # mengecek apakah variable tersebut bertipe data int atau float
+    # jika tidak maka error
+    if not isinstance(kelvin, (float, int)):
+        return error.ErrorTipeData(["float", "int"])
+    elif kelvin < 0:
+        return error.Error("Kelvin tidak boleh kurang dari 0")
+    else:
+        return kelvin * (9 / 5) - 459.67
+
+
+def fahrenheit_kelvin(fahrenheit: Union[int, float]) -> Union[int, float]:
+    """
+    mengubah fahrenheit ke kelvin
+
+    Parameter:
+        fahrenheit(int atau float): nilai fahrenheit
+
+    Return:
+        (float atau int): hasil dari kalkulasi fahrenheit ke kelvin
+        errot.ErrorTiperData: error jika data salah
+    """
+    # mengecek apakah variable tersebut bertipe data int atau float
+    # jika tidak maka error
+    if not isinstance(fahrenheit, (float, int)):
+        return error.ErrorTipeData(["float", "int"])
+    else:
+        return (fahrenheit + 459.67) * (5 / 9)
+
+
+def kelvin_reamur(kelvin: Union[int, float]) -> Union[int, float, error.Error]:
+    """
+    mengubah kelvin ke reamur
+
+    Parameter:
+        kelvin(int atau float): nilai kelvin
+
+    Return:
+        (float atau int): hasil dari kalkulasi kelvin ke reamur
+        errot.ErrorTiperData: error jika data salah
+    """
+    # mengecek apakah variable tersebut bertipe data int atau float
+    # jika tidak maka error
+    if not isinstance(kelvin, (float, int)):
+        return error.ErrorTipeData(["int", "float"])
+    elif kelvin < 0:
+        return error.Error("Kelvin tidak boleh kurang dari 0")
+    else:
+        return (kelvin - 273.15) * (4 / 5)
+
+
+def reamur_kelvin(reamur: Union[int, float]) -> Union[int, float]:
+    """
+    mengubah reamur ke kelvin
+
+    Parameter:
+        reamur(int atau float): nilai reamur
+
+    Return:
+        (float atau int): hasil dari kalkulasi reamur ke kelvin
+        errot.ErrorTiperData: error jika data salah
+    """
+    # mengecek apakah variable tersebut bertipe data int atau float
+    # jika tidak maka error
+    if not isinstance(reamur, (float, int)):
+        return error.ErrorTipeData(["float", "int"])
+    else:
+        return (reamur * (5 / 4)) + 273.15
+
+
+def reamur_fahrenheit(reamur: Union[int, float]) -> Union[int, float]:
+    """
+    mengubah reamur ke fahrenheit
+
+    Parameter:
+        reamur(int atau float): nilai reamur
+
+    Return:
+        (float atau int): hasil dari kalkulasi reamur ke fahrenheit
+        errot.ErrorTiperData: error jika data salah
+    """
+    # mengecek apakah variable tersebut bertipe data int atau float
+    # jika tidak maka error
+    if not isinstance(reamur, (float, int)):
+        return error.ErrorTipeData(["float", "int"])
+    else:
+        return (reamur * (9 / 4)) + 32
+
+
+def fahrenheit_reamur(fahrenheit: Union[int, float]) -> Union[int, float]:
+    """
+    mengubah fahrenheit ke reamur
+
+    Parameter:
+        fahrenheit(int atau float): nilai fahrenheit
+
+    Return:
+        (float atau int): hasil dari kalkulasi fahrenheit ke reamur
+        errot.ErrorTiperData: error jika data salah
+    """
+    # mengecek apakah variable tersebut bertipe data int atau float
+    # jika tidak maka error
+    if not isinstance(fahrenheit, (float, int)):
+        return error.ErrorTipeData(["float", "int"])
+    else:
+        return (fahrenheit - 32) * (4 / 9)
diff --git a/example/fisika/efek_doppler.py b/example/fisika/efek_doppler.py
index ebad7c3..e3491fb 100644
--- a/example/fisika/efek_doppler.py
+++ b/example/fisika/efek_doppler.py
@@ -1,5 +1,5 @@
 import OpenSeries.fisika as fisika
 
 # menghitung fungsi dari efek doppler
-doppler_efek = fisika.efek_doppler(100, 330, 10)
+doppler_efek = fisika.efek_doppler(100, 330, 10, 10)
 print(doppler_efek)
diff --git a/testing/fisika_test.py b/testing/fisika_test.py
index 84efb50..de3cc8e 100644
--- a/testing/fisika_test.py
+++ b/testing/fisika_test.py
@@ -9,10 +9,380 @@ def test_angka_valid(self):
         hasil = kecepatan(100.0, 10.0)
         self.assertEqual(hasil, 10.0)
 
-    def test_angka_list(self):
-        hasil = kecepatan([20, 30, 40], [20, 30, 40])
-        self.assertEqual(hasil, [1.0, 1.0, 1.0])
+    def test_dibagi_nol(self):
+        hasil = fisika.kecepatan(150.0, 0)
+        with self.assertRaises(error.ErrorDibagiNol):
+            raise hasil
 
-    def test_numpy_list(self):
-        hasil = kecepatan(np.array([20, 30, 40]), np.array([20, 30, 40]))
-        self.assertEqual(hasil, [1.0, 1.0, 1.0])
+    def test_invalid_input(self):
+        with self.assertRaises(error.ErrorTipeData):
+            raise fisika.kecepatan("12", 30)
+
+    def test_kecepatan_invalid_input2(self):
+        hasil = fisika.kecepatan("12", "50")
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class TestPercepatan(unittest.TestCase):
+    def test_percepatan_valid(self):
+        hasil = fisika.percepatan(20.0, 5.0)
+        self.assertEqual(hasil, 4.0)
+
+    def test_percepatan_dibagi_nol(self):
+        hasil = fisika.percepatan(30.0, 0)
+        with self.assertRaises(error.ErrorDibagiNol):
+            raise hasil
+
+    def test_percepatan_nilai_tidak_valid(self):
+        hasil = fisika.percepatan("20", 30)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class TestKecepatanSudut(unittest.TestCase):
+    def test_kecepatan_sudut_valid(self):
+        hasil = fisika.kecepatan_sudut(30, 2)
+        self.assertEqual(hasil, 15)
+
+    def test_kecepatan_sudut_dibagi_nol(self):
+        hasil = fisika.kecepatan_sudut(30.0, 0)
+        with self.assertRaises(error.ErrorDibagiNol):
+            raise hasil
+
+    def test_kecepatan_sudut_tidak_valid(self):
+        hasil = fisika.kecepatan_sudut("30.0", 2)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class TestPercepatanSudut(unittest.TestCase):
+    def test_percepatan_sudut_valid(self):
+        hasil = fisika.percepatan_sudut(50, 2)
+        self.assertEqual(hasil, 25)
+
+    def test_percepatan_sudut_dibagi_nol(self):
+        hasil = fisika.percepatan_sudut(50.0, 0)
+        with self.assertRaises(error.ErrorDibagiNol):
+            raise hasil
+
+    def test_percepatan_sudut_tidak_valid(self):
+        hasil = fisika.percepatan_sudut("50.0", 2)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class TestPercepatanSentripetallinear(unittest.TestCase):
+    def test_percepatanSentripetal_linear_valid(self):
+        hasil = fisika.percepatan_sentripetal_linear(5.0, 2)
+        self.assertEqual(hasil, 12.5)
+
+    def test_percepatan_sudut_dibagi_nol(self):
+        hasil = fisika.percepatan_sudut(50.0, 0)
+        with self.assertRaises(error.ErrorDibagiNol):
+            raise hasil
+
+    def test_percepatan_sudut_tidak_valid(self):
+        hasil = fisika.percepatan_sudut("50.0", 2)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class TestPercepatanSentripetalSudut(unittest.TestCase):
+    def test_percepatansentripetal_sudut_valid(self):
+        hasil = fisika.percepatan_sentripetal_sudut(5, 8)
+        self.assertEqual(hasil, 320)
+
+    def test_percepatan_sudut_tidak_valid(self):
+        hasil = fisika.percepatan_sentripetal_sudut("5", 8)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class TestGerakLurusBeraturan(unittest.TestCase):
+    def test_valid(self):
+        hasil = fisika.gerak_lurus_beraturan(10.0, 2.0, 3.0)
+        self.assertAlmostEqual(hasil, 39.0)
+
+    def test_invalid_int(self):
+        hasil = fisika.gerak_lurus_beraturan(8, 1.5, 2)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class TesGerakMelingkarBeraturan(unittest.TestCase):
+    def test_valid(self):
+        hasil = fisika.gerak_melingkar_beraturan(5, 6, 3)
+        self.assertAlmostEqual(hasil, 23)
+
+    def test_invalid(self):
+        hasil = fisika.gerak_melingkar_beraturan("5", "6", 3)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class TestInersia(unittest.TestCase):
+    def test_valid(self):
+        hasil = fisika.inersia(2, 4)
+        self.assertAlmostEqual(hasil, 32)
+
+    def test_invalid(self):
+        hasil = fisika.inersia("2", 4)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class TestEnergiKinetik(unittest.TestCase):
+    def test_valid_input(self):
+        hasil = fisika.energi_kinetik(2.0, 5.0)
+        self.assertAlmostEqual(hasil, 25.0)
+
+    def test_invalid_input_mix_tipe_data(self):
+        hasil = fisika.energi_kinetik("3", 4.5)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class TestEnergiKinetikRotasi(unittest.TestCase):
+    def test_valid(self):
+        hasil = fisika.energi_kinetik_rotasi(2, 6)
+        self.assertAlmostEqual(hasil, 36)
+
+    def test_invalid(self):
+        hasil = fisika.energi_kinetik_rotasi("2", 6)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class TestKetinggianBarometrik(unittest.TestCase):
+    def test_valid_input_tekanan(self):
+        hasil = fisika.ketinggian_barometrik(101325.0)
+        self.assertIsInstance(hasil, float)
+
+    def test_tekanan_lebih_besar_daripada_air(self):
+        hasil = fisika.ketinggian_barometrik(110000.0)
+        with self.assertRaises(error.Error):
+            raise hasil
+
+    def test_tekanan_angka_negatif(self):
+        hasil = fisika.ketinggian_barometrik(-820.3)
+        with self.assertRaises(error.Error):
+            raise hasil
+
+    def test_tekanan_tipe_data_salah(self):
+        hasil = fisika.ketinggian_barometrik("12")
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class TestGayaSentripental(unittest.TestCase):
+    def test_gaya_sentripental(self):
+        hasil = fisika.gaya_sentripental(10, 5, 2)
+        self.assertEqual(hasil, 125.0)
+
+    def test_gaya_sentripental_error_tipe_data(self):
+        hasil = fisika.gaya_sentripental("12", 5, 2)
+        self.assertIsInstance(hasil, error.ErrorTipeData)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+    def test_gaya_sentripental_minus(self):
+        hasil = fisika.gaya_sentripental(-10, 5, 2)
+        self.assertIsInstance(hasil, error.Error)
+        with self.assertRaises(error.Error):
+            raise hasil
+
+    def test_gaya_sentripental_nol(self):
+        hasil = fisika.gaya_sentripental(10, 5, 0)
+        self.assertIsInstance(hasil, error.Error)
+        with self.assertRaises(error.Error):
+            raise hasil
+
+
+class TestEfekDoppler(unittest.TestCase):
+    def test_efek_doppler(self):
+        hasil = fisika.efek_doppler(100, 340, 20, 10)
+        rounding_hasil = round(hasil)
+        self.assertEqual(rounding_hasil, 109)
+
+    def test_efek_doppler_invalid_tipe_data(self):
+        hasil = fisika.efek_doppler("12", "340", "20", 10)
+        self.assertIsInstance(hasil, error.ErrorTipeData)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+    def test_efek_doppler_dibagi_nol(self):
+        hasil = fisika.efek_doppler(0, 0, 0, 0)
+        self.assertIsInstance(hasil, error.ErrorDibagiNol)
+        with self.assertRaises(error.ErrorDibagiNol):
+            raise hasil
+
+    def test_efek_doppler_nilai_negatif(self):
+        hasil = fisika.efek_doppler(-100, -340, 20, 10)
+        self.assertIsInstance(hasil, error.Error)
+        with self.assertRaises(error.Error):
+            raise hasil
+
+
+class TestCelciusFarenheit(unittest.TestCase):
+    def test_CelciusFarenheit(self):
+        hasil = fisika.celcius_farenheit(0)
+        rounding_hasil = round(hasil)
+        self.assertEqual(rounding_hasil, 32)
+
+    def test_CelciusFarenheit_invalid_tipe_data(self):
+        hasil = fisika.celcius_farenheit("0")
+        self.assertIsInstance(hasil, error.ErrorTipeData)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class TestFarenheitCelcius(unittest.TestCase):
+    def test_FarenheitCelcius(self):
+        hasil = fisika.farenheit_celcius(32)
+        rounding_hasil = round(hasil)
+        self.assertEqual(rounding_hasil, 0)
+
+    def test_FarenheitCelcius_invalid_tipe_data(self):
+        hasil = fisika.farenheit_celcius("32")
+        self.assertIsInstance(hasil, error.ErrorTipeData)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class TestCelciusReamur(unittest.TestCase):
+    def test_CelciusReamur(self):
+        hasil = fisika.celcius_reaumur(32)
+        self.assertEqual(hasil, 25.6)
+
+    def test_CelciusReamur_invalid_tipe_data(self):
+        hasil = fisika.farenheit_celcius("32")
+        self.assertIsInstance(hasil, error.ErrorTipeData)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class TestReamurCelcius(unittest.TestCase):
+    def test_ReamurCelcius(self):
+        hasil = fisika.reamur_celcius(32)
+        self.assertEqual(hasil, 40)
+
+    def test_ReamurCelcius_invalid_tipe_data(self):
+        hasil = fisika.farenheit_celcius("32")
+        self.assertIsInstance(hasil, error.ErrorTipeData)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class TestCelciusKelvin(unittest.TestCase):
+    def test_CelciusKelvin(self):
+        hasil = fisika.celcius_kelvin(0)
+        self.assertEqual(hasil, 273.15)
+
+    def test_CelciusKelvin_invalid_tipe_data(self):
+        hasil = fisika.farenheit_celcius("0")
+        self.assertIsInstance(hasil, error.ErrorTipeData)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class TestKelvinCelcius(unittest.TestCase):
+    def test_KelvinCelcius(self):
+        hasil = fisika.kelvin_celcius(273.15)
+        self.assertEqual(hasil, 0)
+
+    def test_kelvin_nilai_negatif(self):
+        hasil = fisika.kelvin_celcius(-10)
+        self.assertIsInstance(hasil, error.Error)
+        with self.assertRaises(error.Error):
+            raise hasil
+
+    def test_KelvinCelcius_invalid_tipe_data(self):
+        hasil = fisika.kelvin_celcius("273.15")
+        self.assertIsInstance(hasil, error.ErrorTipeData)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class TestKelvinFarenheit(unittest.TestCase):
+    def test_KelvinFarenheit(self):
+        hasil = fisika.kelvin_fahrenheit(300)
+        self.assertEqual(hasil, 80.32999999999998)
+
+    def test_kelvin_nilai_negatif(self):
+        hasil = fisika.kelvin_fahrenheit(-10)
+        self.assertIsInstance(hasil, error.Error)
+        with self.assertRaises(error.Error):
+            raise hasil
+
+    def test_KelvinFarenheit_invalid_tipe_data(self):
+        hasil = fisika.kelvin_fahrenheit("0")
+        self.assertIsInstance(hasil, error.ErrorTipeData)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class TestFarenheitKelvin(unittest.TestCase):
+    def test_FarenheitKelvin(self):
+        hasil = fisika.fahrenheit_kelvin(-459.67)
+        self.assertEqual(hasil, 0)
+
+    def test_FarenheitKelvin_invalid_tipe_data(self):
+        hasil = fisika.fahrenheit_kelvin("-459.67")
+        self.assertIsInstance(hasil, error.ErrorTipeData)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class TestKelvinReamur(unittest.TestCase):
+    def test_KelvinReamur(self):
+        hasil = fisika.kelvin_reamur(300)
+        self.assertEqual(hasil, 21.480000000000018)
+
+    def test_kelvin_nilai_negatif(self):
+        hasil = fisika.kelvin_reamur(-10)
+        self.assertIsInstance(hasil, error.Error)
+        with self.assertRaises(error.Error):
+            raise hasil
+
+    def test_KelvinReamur_invalid_tipe_data(self):
+        hasil = fisika.kelvin_reamur("300")
+        self.assertIsInstance(hasil, error.ErrorTipeData)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class TestReamurKelvin(unittest.TestCase):
+    def test_ReamurKelvin(self):
+        hasil = fisika.reamur_kelvin(0)
+        self.assertEqual(hasil, 273.15)
+
+    def test_ReamurFahrenheit_invalid_tipe_data(self):
+        hasil = fisika.reamur_fahrenheit("-218.52")
+        self.assertIsInstance(hasil, error.ErrorTipeData)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class TestReamurFahrenheit(unittest.TestCase):
+    def test_ReamurFahrenheit(self):
+        hasil = fisika.reamur_fahrenheit(0)
+        self.assertEqual(hasil, 32)
+
+    def test_ReamurFahrenheit_invalid_tipe_data(self):
+        hasil = fisika.reamur_fahrenheit("0")
+        self.assertIsInstance(hasil, error.ErrorTipeData)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil
+
+
+class TestFahrenheitReamur(unittest.TestCase):
+    def test_FahrenheitReamur(self):
+        hasil = fisika.fahrenheit_reamur(40)
+        self.assertEqual(hasil, 3.5555555555555554)
+
+    def test_FahrenheitReamur_invalid_tipe_data(self):
+        hasil = fisika.fahrenheit_reamur("0")
+        self.assertIsInstance(hasil, error.ErrorTipeData)
+        with self.assertRaises(error.ErrorTipeData):
+            raise hasil