exercicio para segunda - calculadora - zênite

exercicios/para-casa/calculo_media.py

@@ -0,0 +1,6 @@
+def calcular_media(numeros):
+    if not numeros:
+        return 0
+
+    return sum(numeros)/len(numeros)
+

exercicios/para-casa/exercicio_obrigatorio_para_segunda.py

@@ -0,0 +1,83 @@
+# ## Calculadora :calling:
+
+# - Explicação do exercício: Desenvolva uma calculadora (utilizando a metodologia TDD) 
+# que tenha as 4 operações básicas e teste ela usando testes unitários.
+# - Operações básicas: 
+#     - Soma 
+#     - Subtração
+#     - Multiplicação
+#     - Divisão
+
+def soma(a, b):
+    return a + b
+
+def subtracao(a, b):
+    return a - b
+
+def multiplicacao(a, b):
+    return a * b
+
+def divisao(a, b):
+    return a / b
+
+import unittest
+
+class TestSoma(unittest.TestCase):
+    def teste_soma_positivos(self):
+        self.assertEqual(soma(2,3), 5)
+
+    def teste_soma_negativos(self):
+        self.assertEqual(soma(-3, -4), -7)
+
+    def teste_soma_zero(self):
+        self.assertEqual(soma(0,0), 0)
+
+    def teste_soma_pos_neg(self):
+        self.assertEqual(soma(-5,8), 3)
+        self.assertEqual(soma(-2,1), -1)
+
+class TestSubtracao(unittest.TestCase):
+    def teste_subt_positivos(self):
+        self.assertEqual(subtracao(5,4), 1)
+
+    def teste_subt_negativos(self):
+        self.assertEqual(subtracao(-5,-7), 2)
+        self.assertEqual(subtracao(-5,-3), -2)
+
+    def teste_subt_pos_e_neg(self):
+        self.assertEqual(subtracao(5,-4), 9)
+        self.assertEqual(subtracao(-5,4), -9)
+
+    def teste_subt_zero(self):
+        self.assertEqual(subtracao(0,0), 0)
+
+class TestMultiplicacao(unittest.TestCase):
+    def teste_mult_positivos(self):
+        self.assertEqual(multiplicacao(5,4), 20)
+
+    def teste_mult_negativos(self):
+        self.assertEqual(multiplicacao(-5,-7), 35)
+
+    def teste_mult_pos_e_neg(self):
+        self.assertEqual(multiplicacao(5,-4), -20)
+
+    def teste_mult_zero(self):
+        self.assertEqual(multiplicacao(0,0), 0)
+        self.assertEqual(multiplicacao(0,4), 0)
+
+class TestDivisao(unittest.TestCase):
+    def teste_div_positivos(self):
+        self.assertEqual(divisao(20,2), 10)
+
+    def teste_div_negativos(self):
+        self.assertEqual(divisao(-30,-10), 3)
+
+    def teste_div_pos_e_neg(self):
+        self.assertEqual(divisao(10,-2), -5)
+
+    def teste_div_zero(self):
+        self.assertEqual(divisao(0,1), 0)
+
+if __name__ == '__main__':
+    unittest.main()
+

exercicios/para-casa/test_calculo_media.py

@@ -0,0 +1,64 @@
+import unittest
+from calculo_media import calcular_media
+
+# Cenários de teste
+## 1. uma lista vazia - resultado zero
+## 2. uma lista composta por zeros - resultado zero
+## 3. uma lista composta apenas por números negativos - resultado negativo
+## 4. uma lista composta apenas por números positivos - resultado positivo
+## 5. uma lista composta por números positivos e negativos (cenário 1) - resultado negativo
+## 6. uma lista composta por números positivos e negativos (cenário 2) - resultado positivo
+## 7. uma lista composta por str - resultado erro (TypeError)
+## 8. argumentos booleanos para função calcular_media() - resultado erro (TypeError)
+## 9. lista composta por um único elemento - retorna o próprio elemento
+
+# Cenário descartado:
+## uma lista composta por ao menos um número tipo float - resultado float
+###     def test_media_lista_float(self):
+###         resultado = calcular_media([1.0, 2, 3, 4, 5])
+###         self.assertEqual(resultado,3.0)
+###         print(type(resultado))
+# foi descartado quando se percebeu que o retorno da função calcular_media(), e portanto, 
+# o tipo da variável "resultado" em qualquer cenário de teste é float
+
+class TestCalcularMedia(unittest.TestCase):
+    def test_media_lista_vazia(self):
+        resultado = calcular_media([])
+        self.assertEqual(resultado, 0)
+
+    def test_media_lista_zeros(self):
+        resultado = calcular_media([0,0,0])
+        self.assertEqual(resultado,0)
+
+    def test_media_lista_negativos(self):
+        resultado = calcular_media([-1,-2,-3])
+        self.assertEqual(resultado,-2)
+
+    def test_media_lista_positivos(self):
+        resultado = calcular_media([1,2,3])
+        self.assertEqual(resultado,2)
+
+    def test_media_lista_positivosenegativos_cenario1(self):
+        # em que a soma dos módulos dos números negativos da lista é maior que a soma dos números positivos
+        resultado = calcular_media([1,2,3,-3,-6,-9])
+        self.assertEqual(resultado,-2)
+
+    def test_media_lista_positivosenegativos_cenario2(self):
+        # em que a soma dos módulos dos números negativos da lista é menor que a soma dos números positivos
+        resultado = calcular_media([-1,-2,-3,3,6,9])
+        self.assertEqual(resultado,2)
+
+    def test_media_lista_str(self):
+        with self.assertRaises(TypeError):
+            calcular_media(['hello', 'world'])
+
+    def test_media_bool(self):
+        with self.assertRaises(TypeError):
+            calcular_media(True, False)
+
+    def test_media_lista_elemento(self):
+        resultado = calcular_media([1])
+        self.assertEqual(resultado,1)
+
+if __name__ == '__main__':
+    unittest.main()