# ETS-UT3-AE1. Diseño y realización de pruebas. Prueba práctica
## 1. Pruebas de caja blanca. Camino básico

La siguiente función se utiliza para calcular el importe total de una vivienda de alquiler vacacional:

def total_alquiler(n_dias, n_personas):
    precio_dia = 50
    extra_persona_dia = 5
    min_dias = 3
    min_personas = 2
    total = extra_personas = 0
    
    # Se calcula el total a pagar por la duración del alquiler
    
    if n_dias < min_dias:
        total = precio_dia * min_dias
        n_dias = min_dias
    
    else:
        
        total = precio_dia * n_dias
    
    # Se calcula el total extra por personas que pasen de min_personas
    
    if n_personas > min_personas:
        n_personas_extra = n_personas - min_personas
        extra_personas = n_personas_extra * n_dias * extra_persona_dia 
    
    # Se añade al total el extra por personas de más
    
    total += extra_personas
    
    return total

* Cada día se paga a 50€
* Como mínimo se pagan 3 días aunque se alquile por menos días.
* Por cada persona que pase de 2 se paga un extra de 5€ por persona y día. Si es una sola persona paga como si fuesen 2.

El diagrama de flujo es el siguiente:

st3=>start: start total_alquiler
io5=>inputoutput: input: n_dias, n_personas
op8=>operation: precio_dia = 50,  extra_persona_dia = 5, min_dias = 3, min_personas = 2, total = extra_personas = 0
cond19=>condition: if (n_dias < min_dias)
op23=>operation: total = (precio_dia * min_dias)
op25=>operation: n_dias = min_dias
cond33=>condition: if (n_personas > min_personas)
op37=>operation: n_personas_extra = n_personas - min_personas
op39=>operation: extra_personas = n_personas_extra * n_dias * extra_persona_dia
op44=>operation: total += extra_personas
io49=>inputoutput: output:  total
e47=>end: end function return
op29=>operation: total = (precio_dia * n_dias)

st3->io5
io5->op8
op8->cond19
cond19(yes)->op23
op23->op25
op25->cond33
cond33(yes)->op37
op37->op39
op39->op44
op44->io49
io49->e47
cond33(no)->op44
cond19(no)->op29
op29->cond33

Se pide:

### 1.1. Obtener el grafo de flujo de la función (1p):

### 1.2. Calcula de la complejidad ciclomática usando los tres métodos posibles (1p)

### 1.3. Caminos independientes con longitudes de mayor a menor (1p)

### 1.4. Tabla con casos de prueba (1,5p)

Completa:

| Camino | Entrada | Prueba | Salida |
| ------ | ------- | ------ | ------ |
| | | | |
| | | | |

## 2. Pruebas de caja negra. Clases de equivalencia

Una empresa de coches de alquiler tiene una aplicación que permite calcular el total a cobrar a un cliente. Los campos de entrada son:

* El **código** del vehículo: número de 4 dígitos que no puede empezar ni por 0 ni por 1
* La **categoría** del vehículo: "A", "B", "C" o elije categoría
* El **n_dias**: número de días del alquiler. Debe estar entre 1 y 20.
*
Si la entrada es correcta el programa calcula el importe de la siguiente forma:

* **S1**: Si el vehículo es de Categoría **A** -> n_dias x 100
* **S2**: Si el vehículo es de Categoría **B** -> n_dias x 50
* **S3**: Si el vehículo es de Categoría **C** -> n_dias x 20

Si la entrada es incorrecta el programa muestra mensaje indicando la entrada incorr4ecta:

* **ER1** si el código del vehículo es incorrecto
* **ER2** si no se ha elegido la categoría del vehículo
* **ER3** si el número de días seleccionado es incorrecto.

Tenemos la siguiente función de Python, de la que no disponemos del código, que recibe los parámetros de entrada y debe generar la salida correspondiente:

def total_alquiler(codigo, categoria, n_dias):
    """
    Calcula total del alquiler a partir de la categoría y el 
    :param codigo: int
    :param categoria: str
    :param n_dias: int
    :return int
    """

### 2.1. Crea la tabla que representa las cláses de equivalencia (1,5p)
| Condición de entrada | Clase de equivalencia | Clases Válidas | COD | Clases no válidas | COD |
| -------------------- | --------------------- | ---------------------- | --- | ----------------- | --- |
| | | | | | |

### 2.2. Crea la tabla con los casos de prueba (1,5p)

| Caso de prueba | Clases de equivalencia | codigo | categoria | n_dias | Resultado esperado |
| -------------- | ---------------------- | ------ | --------- | ----------- | ------------------ |
| | | | | | |

### 2.3. Añade a la función los casos de pruebas usando Doctest (1p)

Completa:

def total_alquiler(codigo, categoria, n_dias):
    """
    Calcula total del alquiler a partir de la categoría y el 
    :param codigo: int
    :param categoria: str
    :param n_dias: int
    :return int
    """

## 3. Análisis de valores límite. Casos de prueba (1,5p)

Determina los casos de prueba para los siguientes elementos según las condiciones de entrada o salida del mismo. Completar tabla

| Elementos | Condiciones | Casos de prueba |
| --------- | ----------------------------------------------------------------------------------------- | -------------------- |
| Código | Entero de 1 a 100 | Valores: 0,1,100,101 |
| Puesto | Cadena de hasta 4 caracteres | Longitud caracteres: 0, 1, 4, 5 |
| Edad | De 15 a 65 años con descuento para menores de 20 | |
| Salario | Debe ser mayor de 500. Hasta 1000 no paga impuestos. A partir de 1000 paga 5%. A partir de 2000 paga 7% | |
| Nombre | Cadena de entre 10 y 20 caracteres | |

###### tags: `ets` `ut3` `prueba` `práctica` `pruebas` `tests`