Modificaciones para que funcionen los tests de los alumnos

daw1b_calculadora/test_adrian_calculadora.py

@@ -1,6 +1,6 @@
 import pytest
 
-from src.probar_cosas import es_resultado_negativo, multiplicar, dividir, potencia
+from daw1b_calculadora.adrian_calculadora_alumnos import es_resultado_negativo, multiplicar, dividir, potencia
 
 
 # TODO: Crear el test unitario para la función es_resultado_negativo. Verifica lo siguiente:

daw1b_calculadora/test_alfonso_calculadora.py

@@ -0,0 +1,72 @@
+
+import pytest
+
+from daw1b_calculadora.alfonso_calculadora_alumnos import es_resultado_negativo, multiplicar, dividir, potencia
+
+
+# TODO: Crear el test unitario para la función es_resultado_negativo. Verifica lo siguiente:
+# Casos donde el resultado debe ser negativo (2 casos)
+# Casos donde el resultado debe ser positivo (2 casos)
+
+
+def test_es_resultado_negativo():
+    assert es_resultado_negativo(-1, 1) == "negativo"
+    assert es_resultado_negativo(1,1) == "positivo"
+    assert es_resultado_negativo(-2,-3) == "positivo"
+    assert es_resultado_negativo(5,-5) == "negativo"
+
+def test_multiplicar():
+    # Multiplicación con números positivos
+    assert multiplicar(3.421, 3.922) == 12
+    assert multiplicar(7.11, 2.1) == 14
+
+    # Multiplicación con un número negativo
+    assert multiplicar(-3.477, 4.1) == -12
+    assert multiplicar(5, -2) == -10
+
+    # Multiplicación de dos números negativos
+    assert multiplicar(-5, -3) == 15
+
+    # Multiplicación con cero
+    assert multiplicar(0, 5) == 0
+    assert multiplicar(3, 0) == 0
+
+def test_dividir():
+    # División con números positivos
+    assert dividir(9.33, 3.122) == 3
+    assert dividir(14.757, 4.968) == 3
+
+    # División con un número negativo
+    assert dividir(-12, 3) == -4
+    assert dividir(14.223, -2) == -7
+
+    # División de dos números negativos
+    assert dividir(-15.899, -4.499) == 4
+
+    # División con redondeo a entero
+    assert dividir(10, 3.101) == 3  # 10 // 3 = 3 (redondeo esperado)
+
+    # División por cero
+    with pytest.raises(ZeroDivisionError):
+        dividir(5, 0)
+
+
+@pytest.mark.parametrize(
+    "base, exponente, expected",
+    [
+        (2, 3, 8),           # 2^3 = 8
+        (5, 0, 1),           # 5^0 = 1
+        (-2, 3, -8),         # -2^3 = -8 (base negativa con exponente impar)
+        (-2.09, 4.44, 16),         # -2^4 = 16 (base negativa con exponente par)
+        (10, 1, 10),         # 10^1 = 10
+        (3, -2, 0),          # 3^-2 = 0 (se devuelve 0 para exponentes negativos)
+        (0, 5, 0),           # 0^5 = 0
+        (0, 0, 1),           # 0^0 = 1 (por convención en muchas calculadoras)
+        (5, 2, 25),          # 5^2 = 25
+    ]
+)
+def test_potencia(base, exponente, expected):
+    """
+    Prueba para la función potencia.
+    """
+    assert potencia(base, exponente) == expected

daw1b_calculadora/test_beni_calculadora.py

@@ -1,14 +1,18 @@
 
 import pytest
 
-from src.calculadora_alumnos import es_resultado_negativo, multiplicar, dividir, potencia
+from daw1b_calculadora.beni_calculadora_alumnos import es_resultado_negativo, multiplicar, dividir, potencia
 
 
 # TODO: Crear el test unitario para la función es_resultado_negativo. Verifica lo siguiente:
 # Casos donde el resultado debe ser negativo (2 casos)
 # Casos donde el resultado debe ser positivo (2 casos)
 
 def test_es_resultado_negativo():
+    assert es_resultado_negativo(0, 0) == False
+    assert es_resultado_negativo(0, -23.43) == False
+    assert es_resultado_negativo(-4.3, 0) == False
+
     #Resultado positivo
     assert es_resultado_negativo(-4.03, 9) == True
     assert es_resultado_negativo(2, -23.43) == True

daw1b_calculadora/test_daniel_calculadora.py

@@ -1,7 +1,7 @@
 
 import pytest
 
-from src.calculadora_alumnos import es_resultado_negativo, multiplicar, dividir, potencia
+from daw1b_calculadora.daniel_calculadora_alumnos import es_resultado_negativo, multiplicar, dividir, potencia
 
 
 # TODO: Crear el test unitario para la función es_resultado_negativo. Verifica lo siguiente:
@@ -66,6 +66,9 @@ def test_potencia(base, exponente, expected):
     assert potencia(base, exponente) == expected
 
 def test_es_resultado_negativo():
+    assert (es_resultado_negativo(0,0)) == False
+    assert (es_resultado_negativo(0,-3)) == False
+    assert (es_resultado_negativo(-4,0)) == False
     assert (es_resultado_negativo(4,3)) == False
     assert (es_resultado_negativo(4,-3)) == True
     assert (es_resultado_negativo(-4,3)) == True

daw1b_calculadora/test_david_calculadora.py

@@ -1,14 +1,17 @@
 
 import pytest
 
-from src.calculadora_alumnos import es_resultado_negativo, multiplicar, dividir, potencia
+from daw1b_calculadora.david_calculadora_alumnos import es_resultado_negativo, multiplicar, dividir, potencia
 
 
 # TODO: Crear el test unitario para la función es_resultado_negativo. Verifica lo siguiente:
 # Casos donde el resultado debe ser negativo (2 casos)
 # Casos donde el resultado debe ser positivo (2 casos)
 
 def test_es_resultado_negativo():
+    assert es_resultado_negativo(0, 0) == False
+    assert es_resultado_negativo(-4, 0) == False
+    assert es_resultado_negativo(0, -4) == False
     # Casos donde el resultado es negativo.
     assert es_resultado_negativo(-4, 4) == True
     assert es_resultado_negativo(5, -3) == True

daw1b_calculadora/test_inda_calculadora.py

@@ -1,6 +1,6 @@
 
 import pytest
-from src.calculadora_alumnos import es_resultado_negativo, multiplicar, dividir, potencia
+from daw1b_calculadora.inda_calculadora_alumnos import es_resultado_negativo, multiplicar, dividir, potencia
 
 
 # TODO: Crear el test unitario para la función es_resultado_negativo. Verifica lo siguiente:

daw1b_calculadora/test_jangel_calculadora.py

@@ -1,7 +1,7 @@
 
 import pytest
 
-from src.calculadora_alumnos import es_resultado_negativo, multiplicar, dividir, potencia
+from daw1b_calculadora.jangel_calculadora_alumnos import es_resultado_negativo, multiplicar, dividir, potencia
 
 
 # TODO: Crear el test unitario para la función es_resultado_negativo. Verifica lo siguiente:

daw1b_calculadora/rocio_test_calculadora.py → daw1b_calculadora/test_rocio_calculadora.py

@@ -1,7 +1,7 @@
 
 import pytest
 
-from src.calculadora_alumnos import es_resultado_negativo, multiplicar, dividir, potencia
+from daw1b_calculadora.rocio_calculadora_alumnos import es_resultado_negativo, multiplicar, dividir, potencia
 
 
 # TODO: Crear el test unitario para la función es_resultado_negativo. Verifica lo siguiente:
@@ -67,6 +67,10 @@ def test_potencia(base, exponente, expected):
 
 
 def test_es_resultado_negativo():
+    assert es_resultado_negativo(0, 0) == False
+    assert es_resultado_negativo(0, -3) == False
+    assert es_resultado_negativo(-2, 0) == False
+
     assert es_resultado_negativo(-2, -3) == False
     assert es_resultado_negativo(12, 3) == False
     assert es_resultado_negativo(-4, 3) == True

daw1b_calculadora/test_sergio_calculadora.py

@@ -1,14 +1,17 @@
 
 import pytest
 
-from src.calculadora_alumnos import es_resultado_negativo, multiplicar, dividir, potencia
+from daw1b_calculadora.sergio_calculadora_alumnos import es_resultado_negativo, multiplicar, dividir, potencia
 
 
 # TODO: Crear el test unitario para la función es_resultado_negativo. Verifica lo siguiente:
 # Casos donde el resultado debe ser negativo (2 casos)
 # Casos donde el resultado debe ser positivo (2 casos)
 
 def test_es_resultado_negativo():
+    assert es_resultado_negativo(0,2) == False
+    assert es_resultado_negativo(0,0) == False
+    assert es_resultado_negativo(-6,0) == True
     assert es_resultado_negativo(-12,2) == True
     assert es_resultado_negativo(12,-2) == True
     assert es_resultado_negativo(-12,-2) == False

daw1b_calculadora/test_victor_calculadora.py

@@ -1,11 +1,14 @@
 
 import pytest
 
-from src.calculadora_alumnos import es_resultado_negativo, multiplicar, dividir, potencia
+from daw1b_calculadora.victor_calculadora_alumnos import es_resultado_negativo, multiplicar, dividir, potencia
 
 
 # TODO: Crear el test unitario para la función es_resultado_negativo. Verifica lo siguiente:
 def test_es_resultado_negativo():
+    assert es_resultado_negativo(0, 0) == False
+    assert es_resultado_negativo(-5, 0) == False
+    assert es_resultado_negativo(0, -2.1) == False
 # Casos donde el resultado debe ser negativo (2 casos)
     assert es_resultado_negativo(3.421, 3.922) == False
     assert es_resultado_negativo(7.11, 2.1) == False

otros/calculadora.py

@@ -84,13 +84,8 @@ def restar(num1: float, num2: float) -> float:
     return num1 - num2
 
 
-def es_resultado_negativo(num1: float, num2: float, es_potencia: bool = False) -> bool:
-    """Determina si el resultado de una operación entre num1 y num2 debe ser negativo.
-
-    Esta función verifica si el resultado de una operación matemática entre `num1` y `num2`
-    tendría un valor negativo. Si el parámetro `es_potencia` es `True`, se considera una
-    operación de potencia; de lo contrario, se considera una operación de multiplicación o
-    división.
+def es_resultado_negativo(num1: float, num2: float) -> bool:
+    """Determina si el resultado de una operación de multiplicación o división entre num1 y num2 debe ser negativo.
 
     Args:
         num1 (float): El primer número de la operación.
@@ -100,19 +95,8 @@ def es_resultado_negativo(num1: float, num2: float, es_potencia: bool = False) -
     Returns:
         bool: `True` si el resultado debería ser negativo, `False` en caso contrario. 
               Valor por defecto es `False`.
-
-    Note:
-        * Si es_potencia es `True` (potencia), el resultado es negativo si `num1` (base)
-          es negativo y `num2` (exponente) es impar. 
-        * Si es_potencia es `False` (multiplicación y división), el resultado es negativo 
-         si solo uno de los números es negativo.
     """
-    if es_potencia:
-        es_negativo = (num1 < 0) and (num2 % 2 != 0)
-    else:
-        es_negativo = (num1 < 0) != (num2 < 0)
-
-    return es_negativo
+    return (num1 != 0) and (num2 != 0) and (num1 < 0) != (num2 < 0)
 
 
 def multiplicar(num1: float, num2: float) -> int:
@@ -228,11 +212,9 @@ def potencia(base: float, exponente: float) -> int:
         Utiliza la función multiplicar para realizar la operación de potencia.
         Este método está diseñado para exponentes enteros no negativos.
     """
-    resultado_negativo = es_resultado_negativo(base, exponente, True)
-
-    # Redondeamos a entero. La base no debe tener signo para realizar los cálculos
+    # Redondeamos a entero
     exponente = round(exponente)
-    base = round(abs(base))
+    base = round(base)
 
     # Cualquier número elevado a 0 es 1
     if exponente == 0:
@@ -248,10 +230,6 @@ def potencia(base: float, exponente: float) -> int:
         for _ in range(exponente - 1):
             resultado = multiplicar(resultado, base)
 
-        # Ajusta el signo del resultado si el cálculo debe ser negativo
-        if resultado_negativo:
-            resultado = 0 - resultado
-
     return resultado
 
 

tests/test_calculadora.py

@@ -5,6 +5,11 @@
 
 
 def test_es_resultado_negativo():
+    # Casos con números 0
+    assert es_resultado_negativo(0, 0) is False
+    assert es_resultado_negativo(0, -7) is False
+    assert es_resultado_negativo(-4, 0) is False
+
     # Casos donde el resultado debe ser negativo
     assert es_resultado_negativo(-5, 3) is True
     assert es_resultado_negativo(4, -7) is True