class: center, middle, inverse
# Proves de programari (Testing)
### Altres etiquetes i reports

---
# Testing floats
```
 @Test
    fun divideFloatTest() {
        assertEquals(1.54f, divideFloat(5.4f , 3.5f))
    }
```
expected: <1.54> but was: <1.5428572>

---
# Afegim el paràmetre delta
```
 @Test
    fun divideFloatTest() {
        assertEquals(1.54f, divideFloat(5.4f , 3.5f),0.01f)
    }
```

---
# @BeforeEach
- Mètode que s'executa abans de cada un dels testos
- És útil per inicialitzar recursos

```
@BeforeEach
    fun setUp(){
        println("@BeforeEach -> setUp()")
    }
```
---
# @AfterEach
- Mètode que s'executa després de cada un dels testos
- Per alliberar recursos i destruir recursos

```
@AfterEach
    fun tearDown(){
        println("@AfterEach -> tearDown()")
    }
```
---

# Fail
Suposem el mètode següent:
```
fun divide (x: Int, y: Int){
	return x/y
}
```
- Sabem que si y és 0 la operació no es pot fer.
- Més endavant aprendrem a tractar les excepcions (ArithmeticException)

---
# Fail
- A nivell de testing podem fer el següent:

```

@Test
    fun `divide test valid input`() {
        assertEquals(2, divide(4, 2))
    }
    @Test
    fun `divide test invalid input`() {
        fail<Int>("Invalid input no`es pot dividir per 0. Cal solucionar-ho")
    }
 ```

---
# Disable
 - Podem fer servir aquesta etiqueta per deshabilitar un test que temporalment no volem executar
 ```
 @Disabled("missatge")
    @Test
    fun `divide test invalid input`() {
        fail<Int>("Invalid input noes pot dividir per 0. Cal solucionar-ho")
    }
 ```

---
# Obrir el test report del gradle

.full_width[![icon test report gradle](img/testReport.png)]

---
# Report html

.full_width[![test result report](img/testResult.png)]

---
# AssertAll
- Normalment posarem un únic asser per funció
- Si en algun cas ens interessa fer varis testos es pot fer amb l' __assertAll()__:
```
@Test
    fun `divide test valid input`() {
        assertAll(
            {assertEquals(2, divide(4, 2))},
            {assertEquals(1, divide(10, 10))},
            {assertEquals(3, divide(12, 4))}
            )
    }
 ```
---
# @Nested
- Aquesta etiqueta ens permet ordenar per subcasos de test

.full_width[![nested](img/nested.png)]

---
# @Nested

```
internal class DivideTest {
	
	//...

@Nested
    inner class DivideCases {
        @Test
        fun `divide test positives`() {
            assertEquals(2, divide(4,2))
        }
        @Test
        fun `divide test negatives`() {
            assertEquals(2, divide(-4,-2))
        }
    }
 }
```
---
# TimeOut
- Per quan ens interessi saber el rendiment d'un mètode
- Poder millorar l'eficiència dels nostres algorismes
```
@Test
        fun timeOutTest(){
            assertTimeout(Duration.ofMillis(500)){nomDelMetodeQueTestejo()}
        }

fun nomDelMetodeQueTestejo(){
    Thread.sleep(1000)
}
```
execution exceeded timeout of 500 ms by 500 ms

---

# assertThrows
```
fun divide(x:Int, y:Int):Int {
    if (y == 0) throw ArithmeticException("No es pot dividir per 0")
    return x/y
}

```
---
# assertThrows

```
@Test
fun `Dividing by zero should throw the ArithmeticException`() {
    assertThrows(ArithmeticException::class.java, divide(5, 0))   
}
```
---

# @BeforeAll
- Per mètodes estàtics
- Podria servir per inicialitzar una base de dades, inicialitzar objectes...
```
class CalculatorTest{
 companion object {
    var calculator: Calculator? = null
    @JVMStatic
    @BeforeAll
    fun beforeAll() {
        calculator = Calculator()
    }
 }
}
```

---
# @AfterAll
- Per exemple pot servir per alliberar recursos
```
class CalculatorTest{
 companion object {
    ...
    @JVMStatic
    @AfterAll
    fun afterAll() {
        calculator = null
    }
 }
}
```
---