Gestion des exceptions

// prévenir que cette fonction est susceptible de générer une exception (SqlException)
public void insertIntoTable(Connection con, String table) throws SqlException

public void changerPhotoTrombino(String nomImage)
          throws ChangementPhotoImpossibleException {
  try {
    // tentative de chargement et remplacement de l'image
  }catch (FileNotFoundException e){
    // marquer la photo actuelle comme obsolète, puis
    throw new ChangementPhotoImpossibleException(e.getMessage());
  }finally {
    // fin de l'opération, inscription dans un fichier de log
  }
}

// class Controller

    // réponse directe au client (sans vue)
    @GetMapping("/demo-ge")
    fun demoException(response: HttpServletResponse) {
        response.contentType = "text/plain"
        response.characterEncoding = "UTF-8"
        val tab1 = intArrayOf(2, 3, 0, 1, 7)
        val tab2 = intArrayOf(2, 2, 2, 2, 2)
        val tab3 = intArrayOf() // vide
        val tab4 = intArrayOf(2, -3, 4, 1, 7)
        val tabOfTab = arrayListOf<IntArray>(tab1, tab2, tab3, tab4)
        val writer: PrintWriter = response.getWriter()
        writer.println("Test de la fonction min")
        for (tab  in  tabOfTab){
            try {
                writer.println("le minmum de tab = " + min(tab))
            } catch (e: IllegalArgumentException) {
                writer.println("ERREUR : " + e.message)
            }
        }
        writer.println("Fin du test.");
    }

// Fonction utilitaire (sans classe)

/**
 * Obtenir la valeur minimum d'une liste
 *
 * @param list d'entiers
 * @return la valeur minimale de la liste
 * @throws IllegalArgumentException si liste est vide
 */
@Throws(IllegalArgumentException::class)
fun min(list: IntArray): Int {
    if (list.isEmpty()) {
        throw IllegalArgumentException("min sur liste vide IMPOSSIBLE")
    }
    var minNb: Int = list[0]

    for (i in list.indices) {
        if (minNb > list[i]) minNb = list[i]
    }
    return minNb
}

package fr.vincimelun.sbfirst

import fr.vincimelun.sbfirst.controller.min
import org.junit.jupiter.api.Assertions.*
import org.junit.jupiter.api.Test
import java.lang.IllegalArgumentException

class UnitTests constructor() {

    @Test
    fun `minimum tab normal`() {
        val tab1 = intArrayOf(2, 3, 0, 1, 7)
        val tab2 = intArrayOf(2, 2, 2, 2, 2)
        val min: Int = min(tab2)
        assertEquals(0, min(tab1))
        assertEquals(2, min)
    }

    @Test
    fun `minimum tab vide`() {
        val tabVide = intArrayOf()
        try {
            val min: Int = min(tabVide)
            fail("Ne devrait pas passer par là")
        }catch (e: IllegalArgumentException) {
            assertTrue(1==1) // Tautologie pour le fun :)
        }

    }
}

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

  
function f() {
 try {
   console.log("instuction 1")
   console.log("instuction 2")
   throw new Error("exception 1")
   console.log("instuction 3")
 }
 catch(e) {
   console.log("e attrapée : " + e)
   throw new Error("exception 2")
 }
 finally {
   console.log("dans le finally")
 }
}

  
1
2
3
4
5
6

  
[LOG]: "instuction 1"
[LOG]: "instuction 2"
[LOG]: "e attrapée : Error: exception 1"
[LOG]: "dans le finally"
[ERR]: "Executed JavaScript Failed:"
[ERR]: exception 2