Projet : un outil en ligne de commande, modules et cargo test

numero;type;marque;prix_ht;annee;statut
PC-0001;portable;Dell;89900;2023;affecte:Julie Lefèvre
PC-0002;fixe;HP;64900;2020;affecte:Karim Morel
PC-0003;portable;Lenovo;104900;2024;affecte:Sofiane Benali
PC-0004;fixe;HP;61900;2019;reforme
PC-0005;serveur;Dell;349000;2021;affecte:Salle serveur
PC-0006;portable;Lenovo;99900;2021;reparation
PC-0007;fixe;Dell;72900;2025;stock

parc/
├── Cargo.toml
├── Cargo.lock
├── parc.csv
├── src/
│   ├── lib.rs        la crate bibliothèque : déclare les modules
│   ├── main.rs       la crate exécutable : la ligne de commande
│   ├── erreur.rs     le type ErreurParc
│   ├── poste.rs      TypePoste, Statut, Poste et les montants
│   ├── stockage.rs   lecture et écriture du CSV
│   └── stats.rs      calculs sur le parc
└── tests/
    └── fichier.rs    tests d'intégration

//! Gestion du parc informatique de Sorbier Logistique.

pub mod erreur;
pub mod poste;
pub mod stats;
pub mod stockage;

cargo add clap --features derive
cargo add chrono

[package]
name = "parc"
version = "0.1.0"
edition = "2024"

[dependencies]
chrono = "0.4.45"
clap = { version = "4.6.7", features = ["derive"] }

use std::fmt;
use std::io;

/// Toutes les erreurs que l'outil `parc` peut rencontrer.
#[derive(Debug)]
pub enum ErreurParc {
    /// Une ligne du fichier n'a pas ses six champs.
    NombreDeChamps(usize),
    /// Un type de poste autre que fixe, portable ou serveur.
    TypeInconnu(String),
    /// Un statut que l'outil ne connaît pas.
    StatutInconnu(String),
    /// Un prix ou une année qui n'est pas un nombre valable.
    NombreInvalide(String),
    /// Aucun poste ne porte ce numéro.
    PosteInconnu(String),
    /// Un poste porte déjà ce numéro.
    NumeroDejaPris(String),
    /// On ne peut pas affecter un poste réformé.
    PosteReforme(String),
    /// Une erreur dans une ligne précise du fichier.
    Ligne { numero: usize, message: String },
    /// Le fichier ne peut pas être lu ou écrit.
    Fichier(io::Error),
}

impl fmt::Display for ErreurParc {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            ErreurParc::NombreDeChamps(n) => write!(f, "6 champs attendus, {n} trouvés"),
            ErreurParc::TypeInconnu(t) => write!(f, "type de poste inconnu : « {t} »"),
            ErreurParc::StatutInconnu(s) => write!(f, "statut inconnu : « {s} »"),
            ErreurParc::NombreInvalide(n) => write!(f, "nombre invalide : « {n} »"),
            ErreurParc::PosteInconnu(n) => write!(f, "aucun poste ne porte le numéro {n}"),
            ErreurParc::NumeroDejaPris(n) => write!(f, "le numéro {n} est déjà pris"),
            ErreurParc::PosteReforme(n) => write!(f, "le poste {n} est réformé"),
            ErreurParc::Ligne { numero, message } => write!(f, "ligne {numero} : {message}"),
            ErreurParc::Fichier(e) => write!(f, "fichier illisible : {e}"),
        }
    }
}

impl std::error::Error for ErreurParc {}

/// Permet à `?` de convertir une erreur d'entrée-sortie en `ErreurParc`.
impl From<io::Error> for ErreurParc {
    fn from(e: io::Error) -> Self {
        ErreurParc::Fichier(e)
    }
}

use std::fmt;
use std::str::FromStr;

use crate::erreur::ErreurParc;

/// Taux normal de TVA, en pour cent.
pub const TVA: u64 = 20;
/// Âge, en années, à partir duquel un poste est à renouveler.
pub const AGE_RENOUVELLEMENT: i32 = 5;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub enum TypePoste {
    Fixe,
    Portable,
    Serveur,
}

impl FromStr for TypePoste {
    type Err = ErreurParc;

    fn from_str(texte: &str) -> Result<Self, Self::Err> {
        match texte.trim().to_lowercase().as_str() {
            "fixe" => Ok(TypePoste::Fixe),
            "portable" => Ok(TypePoste::Portable),
            "serveur" => Ok(TypePoste::Serveur),
            autre => Err(ErreurParc::TypeInconnu(autre.to_string())),
        }
    }
}

impl fmt::Display for TypePoste {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let nom = match self {
            TypePoste::Fixe => "fixe",
            TypePoste::Portable => "portable",
            TypePoste::Serveur => "serveur",
        };
        // `pad` respecte la largeur demandée, comme dans {:<9}.
        f.pad(nom)
    }
}

#[derive(Debug, Clone, PartialEq)]
pub enum Statut {
    EnStock,
    Affecte(String),
    EnReparation,
    Reforme,
}

impl Statut {
    /// Le statut tel qu'il est écrit dans le fichier CSV.
    pub fn vers_csv(&self) -> String {
        match self {
            Statut::EnStock => "stock".to_string(),
            Statut::Affecte(nom) => format!("affecte:{nom}"),
            Statut::EnReparation => "reparation".to_string(),
            Statut::Reforme => "reforme".to_string(),
        }
    }
}

impl FromStr for Statut {
    type Err = ErreurParc;

    fn from_str(texte: &str) -> Result<Self, Self::Err> {
        match texte.trim() {
            "stock" => Ok(Statut::EnStock),
            "reparation" => Ok(Statut::EnReparation),
            "reforme" => Ok(Statut::Reforme),
            autre => match autre.strip_prefix("affecte:") {
                Some(nom) if !nom.trim().is_empty() => Ok(Statut::Affecte(nom.trim().to_string())),
                _ => Err(ErreurParc::StatutInconnu(autre.to_string())),
            },
        }
    }
}

impl fmt::Display for Statut {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Statut::EnStock => write!(f, "en stock"),
            Statut::Affecte(nom) => write!(f, "affecté à {nom}"),
            Statut::EnReparation => write!(f, "en réparation"),
            Statut::Reforme => write!(f, "réformé"),
        }
    }
}

#[derive(Debug, Clone, PartialEq)]
pub struct Poste {
    pub numero: String,
    pub type_poste: TypePoste,
    pub marque: String,
    /// Prix d'achat hors taxes, en centimes.
    pub prix_ht: u32,
    pub annee_achat: i32,
    pub statut: Statut,
}

impl Poste {
    /// Un poste neuf arrive toujours en stock.
    pub fn new(numero: &str, type_poste: TypePoste, marque: &str, prix_ht: u32, annee_achat: i32) -> Poste {
        Poste {
            numero: numero.to_string(),
            type_poste,
            marque: marque.to_string(),
            prix_ht,
            annee_achat,
            statut: Statut::EnStock,
        }
    }

    pub fn prix_ttc(&self) -> u64 {
        u64::from(self.prix_ht) * (100 + TVA) / 100
    }

    pub fn age(&self, annee_courante: i32) -> i32 {
        annee_courante - self.annee_achat
    }

    pub fn est_a_renouveler(&self, annee_courante: i32) -> bool {
        self.statut != Statut::Reforme && self.age(annee_courante) >= AGE_RENOUVELLEMENT
    }

    pub fn affecter(&mut self, utilisateur: &str) -> Result<(), ErreurParc> {
        if self.statut == Statut::Reforme {
            return Err(ErreurParc::PosteReforme(self.numero.clone()));
        }
        self.statut = Statut::Affecte(utilisateur.to_string());
        Ok(())
    }
}

impl fmt::Display for Poste {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "{:<8} {:<9} {:<7} {:>12} HT  {}  {}",
            self.numero,
            self.type_poste,
            self.marque,
            formater_euros(u64::from(self.prix_ht)),
            self.annee_achat,
            self.statut
        )
    }
}

/// 89900 centimes → « 899,00 € ».
pub fn formater_euros(centimes: u64) -> String {
    format!("{},{:02} €", centimes / 100, centimes % 100)
}

/// « 899 », « 899,9 » ou « 899.90 » → 89990 centimes.
pub fn lire_euros(texte: &str) -> Result<u32, ErreurParc> {
    let invalide = || ErreurParc::NombreInvalide(texte.to_string());
    let normalise = texte.trim().replace(',', ".");
    let (euros, decimales) = match normalise.split_once('.') {
        Some((e, d)) => (e, d),
        None => (normalise.as_str(), ""),
    };
    if euros.is_empty() || decimales.len() > 2 || !decimales.chars().all(|c| c.is_ascii_digit()) {
        return Err(invalide());
    }
    let euros: u32 = euros.parse().map_err(|_| invalide())?;
    let centimes: u32 = format!("{decimales:0<2}").parse().map_err(|_| invalide())?;
    euros
        .checked_mul(100)
        .and_then(|c| c.checked_add(centimes))
        .ok_or_else(invalide)
}

use std::fs;
use std::io::ErrorKind;
use std::path::Path;

use crate::erreur::ErreurParc;
use crate::poste::Poste;

pub const ENTETE: &str = "numero;type;marque;prix_ht;annee;statut";

/// Transforme une ligne du CSV en poste.
pub fn lire_ligne(ligne: &str) -> Result<Poste, ErreurParc> {
    let champs: Vec<&str> = ligne.split(';').map(str::trim).collect();
    if champs.len() != 6 {
        return Err(ErreurParc::NombreDeChamps(champs.len()));
    }
    Ok(Poste {
        numero: champs[0].to_string(),
        type_poste: champs[1].parse()?,
        marque: champs[2].to_string(),
        prix_ht: champs[3]
            .parse()
            .map_err(|_| ErreurParc::NombreInvalide(champs[3].to_string()))?,
        annee_achat: champs[4]
            .parse()
            .map_err(|_| ErreurParc::NombreInvalide(champs[4].to_string()))?,
        statut: champs[5].parse()?,
    })
}

/// Transforme un poste en ligne du CSV.
pub fn ecrire_ligne(poste: &Poste) -> String {
    format!(
        "{};{};{};{};{};{}",
        poste.numero,
        poste.type_poste,
        poste.marque,
        poste.prix_ht,
        poste.annee_achat,
        poste.statut.vers_csv()
    )
}

/// Lit tout le contenu du fichier : l'en-tête, puis un poste par ligne.
pub fn lire_parc(contenu: &str) -> Result<Vec<Poste>, ErreurParc> {
    let mut postes = Vec::new();
    for (index, ligne) in contenu.lines().enumerate().skip(1) {
        if ligne.trim().is_empty() {
            continue;
        }
        let poste = lire_ligne(ligne).map_err(|e| ErreurParc::Ligne {
            numero: index + 1,
            message: e.to_string(),
        })?;
        postes.push(poste);
    }
    Ok(postes)
}

/// Charge le parc ; un fichier absent donne un parc vide.
pub fn charger(chemin: &Path) -> Result<Vec<Poste>, ErreurParc> {
    match fs::read_to_string(chemin) {
        Ok(contenu) => lire_parc(&contenu),
        Err(e) if e.kind() == ErrorKind::NotFound => Ok(Vec::new()),
        Err(e) => Err(ErreurParc::Fichier(e)),
    }
}

pub fn enregistrer(chemin: &Path, postes: &[Poste]) -> Result<(), ErreurParc> {
    let mut contenu = String::from(ENTETE);
    contenu.push('\n');
    for poste in postes {
        contenu.push_str(&ecrire_ligne(poste));
        contenu.push('\n');
    }
    fs::write(chemin, contenu)?;
    Ok(())
}

use std::collections::BTreeMap;

use crate::poste::{Poste, Statut, TypePoste};

/// Valeur d'achat HT des postes encore utilisables, en centimes.
pub fn valeur_totale_ht(postes: &[Poste]) -> u64 {
    postes
        .iter()
        .filter(|p| p.statut != Statut::Reforme)
        .map(|p| u64::from(p.prix_ht))
        .sum()
}

/// Nombre de postes de chaque type, triés par type.
pub fn nombre_par_type(postes: &[Poste]) -> BTreeMap<TypePoste, usize> {
    let mut compteurs = BTreeMap::new();
    for poste in postes {
        *compteurs.entry(poste.type_poste).or_insert(0) += 1;
    }
    compteurs
}

/// Les postes à renouveler cette année.
pub fn a_renouveler(postes: &[Poste], annee: i32) -> Vec<&Poste> {
    postes.iter().filter(|p| p.est_a_renouveler(annee)).collect()
}

/// Le poste qui porte ce numéro, s'il existe.
pub fn chercher<'a>(postes: &'a [Poste], numero: &str) -> Option<&'a Poste> {
    postes.iter().find(|p| p.numero == numero)
}

use std::path::PathBuf;
use std::process::ExitCode;

use chrono::Datelike;
use clap::{Parser, Subcommand};

use parc::erreur::ErreurParc;
use parc::poste::{self, Poste, TypePoste};
use parc::{stats, stockage};

/// Gestion du parc informatique de Sorbier Logistique.
#[derive(Parser)]
#[command(version)]
struct Cli {
    /// Fichier CSV du parc
    #[arg(short, long, default_value = "parc.csv")]
    fichier: PathBuf,

    #[command(subcommand)]
    commande: Commande,
}

#[derive(Subcommand)]
enum Commande {
    /// Liste les postes, ou seulement ceux d'un type
    Lister {
        /// fixe, portable ou serveur
        #[arg(short, long = "type")]
        type_poste: Option<TypePoste>,
    },
    /// Affiche la valeur du parc et les postes à renouveler
    Stats,
    /// Ajoute un poste neuf, en stock
    Ajouter {
        numero: String,
        type_poste: TypePoste,
        marque: String,
        /// Prix d'achat HT en euros, par exemple 899,90
        prix_ht: String,
        annee: i32,
    },
    /// Affecte un poste à un utilisateur
    Affecter { numero: String, utilisateur: String },
}

fn main() -> ExitCode {
    let cli = Cli::parse();
    match executer(cli) {
        Ok(()) => ExitCode::SUCCESS,
        Err(erreur) => {
            eprintln!("erreur : {erreur}");
            ExitCode::FAILURE
        }
    }
}

fn executer(cli: Cli) -> Result<(), ErreurParc> {
    let mut postes = stockage::charger(&cli.fichier)?;

    match cli.commande {
        Commande::Lister { type_poste } => {
            for p in postes.iter().filter(|p| type_poste.is_none_or(|t| p.type_poste == t)) {
                println!("{p}");
            }
        }
        Commande::Stats => {
            let annee = chrono::Local::now().year();
            println!("Postes : {}", postes.len());
            for (type_poste, nombre) in stats::nombre_par_type(&postes) {
                println!("  {type_poste:<9} {nombre}");
            }
            let total = stats::valeur_totale_ht(&postes);
            println!("Valeur d'achat HT (hors réformés) : {}", poste::formater_euros(total));
            println!("À renouveler en {annee} :");
            for p in stats::a_renouveler(&postes, annee) {
                println!("  {} ({} ans)", p.numero, p.age(annee));
            }
        }
        Commande::Ajouter { numero, type_poste, marque, prix_ht, annee } => {
            if stats::chercher(&postes, &numero).is_some() {
                return Err(ErreurParc::NumeroDejaPris(numero));
            }
            let prix_ht = poste::lire_euros(&prix_ht)?;
            postes.push(Poste::new(&numero, type_poste, &marque, prix_ht, annee));
            stockage::enregistrer(&cli.fichier, &postes)?;
            println!("Poste {numero} ajouté en stock.");
        }
        Commande::Affecter { numero, utilisateur } => {
            let poste = postes
                .iter_mut()
                .find(|p| p.numero == numero)
                .ok_or_else(|| ErreurParc::PosteInconnu(numero.clone()))?;
            poste.affecter(&utilisateur)?;
            stockage::enregistrer(&cli.fichier, &postes)?;
            println!("Poste {numero} affecté à {utilisateur}.");
        }
    }
    Ok(())
}

cargo run -- lister --type portable

PC-0001  portable  Dell        899,00 € HT  2023  affecté à Julie Lefèvre
PC-0003  portable  Lenovo     1049,00 € HT  2024  affecté à Sofiane Benali
PC-0006  portable  Lenovo      999,00 € HT  2021  en réparation

Postes : 7
  fixe      3
  portable  3
  serveur   1
Valeur d'achat HT (hors réformés) : 7815,00 €
À renouveler en 2026 :
  PC-0002 (6 ans)
  PC-0005 (5 ans)
  PC-0006 (5 ans)

$ parc ajouter PC-0008 portable Lenovo 799,90 2026
Poste PC-0008 ajouté en stock.
$ parc ajouter PC-0008 fixe HP 500 2026
erreur : le numéro PC-0008 est déjà pris
$ parc affecter PC-0004 "Camille Roux"
erreur : le poste PC-0004 est réformé
$ parc lister --type tablette
error: invalid value 'tablette' for '--type <TYPE_POSTE>': type de poste inconnu : « tablette »

For more information, try '--help'.

$ parc --help
Gestion du parc informatique de Sorbier Logistique

Usage: parc [OPTIONS] <COMMAND>

Commands:
  lister    Liste les postes, ou seulement ceux d'un type
  stats     Affiche la valeur du parc et les postes à renouveler
  ajouter   Ajoute un poste neuf, en stock
  affecter  Affecte un poste à un utilisateur
  help      Print this message or the help of the given subcommand(s)

Options:
  -f, --fichier <FICHIER>  Fichier CSV du parc [default: parc.csv]
  -h, --help               Print help
  -V, --version            Print version

#[cfg(test)]
mod tests {
    use super::*;

    fn poste_exemple() -> Poste {
        Poste::new("PC-0001", TypePoste::Portable, "Dell", 89900, 2023)
    }

    #[test]
    fn un_poste_neuf_est_en_stock() {
        assert_eq!(poste_exemple().statut, Statut::EnStock);
    }

    #[test]
    fn prix_ttc_ajoute_vingt_pour_cent() {
        assert_eq!(poste_exemple().prix_ttc(), 107880);
    }

    #[test]
    fn renouvellement_a_partir_de_cinq_ans() {
        let poste = poste_exemple();
        assert!(!poste.est_a_renouveler(2027));
        assert!(poste.est_a_renouveler(2028));
    }

    #[test]
    fn un_poste_reforme_ne_peut_pas_etre_affecte() {
        let mut poste = poste_exemple();
        poste.statut = Statut::Reforme;
        assert!(poste.affecter("Julie Lefèvre").is_err());
        assert_eq!(poste.statut, Statut::Reforme);
    }

    #[test]
    fn lire_euros_accepte_virgule_et_point() {
        assert_eq!(lire_euros("899").unwrap(), 89900);
        assert_eq!(lire_euros("899,9").unwrap(), 89990);
        assert_eq!(lire_euros("899.90").unwrap(), 89990);
        assert_eq!(lire_euros(" 0,05 ").unwrap(), 5);
    }

    #[test]
    fn lire_euros_refuse_les_saisies_invalides() {
        for saisie in ["", "abc", "12,345", "-5", "12,a", ",50", "50000000"] {
            assert!(lire_euros(saisie).is_err(), "« {saisie} » aurait dû être refusé");
        }
    }

    #[test]
    fn formater_euros_garde_deux_decimales() {
        assert_eq!(formater_euros(89900), "899,00 €");
        assert_eq!(formater_euros(5), "0,05 €");
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::poste::{Statut, TypePoste};

    #[test]
    fn lit_une_ligne_correcte() {
        let poste = lire_ligne("PC-0001;portable;Dell;89900;2023;affecte:Julie Lefèvre").unwrap();
        assert_eq!(poste.type_poste, TypePoste::Portable);
        assert_eq!(poste.statut, Statut::Affecte("Julie Lefèvre".to_string()));
    }

    #[test]
    fn refuse_une_ligne_incomplete() {
        let erreur = lire_ligne("PC-0001;portable;Dell").unwrap_err();
        assert!(matches!(erreur, ErreurParc::NombreDeChamps(3)));
    }

    #[test]
    fn ecrire_puis_relire_redonne_le_meme_poste() {
        let poste = lire_ligne("PC-0006;portable;Lenovo;99900;2021;reparation").unwrap();
        assert_eq!(lire_ligne(&ecrire_ligne(&poste)).unwrap(), poste);
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn parc_exemple() -> Vec<Poste> {
        let mut vieux = Poste::new("PC-0004", TypePoste::Fixe, "HP", 61900, 2019);
        vieux.statut = Statut::Reforme;
        vec![
            Poste::new("PC-0001", TypePoste::Portable, "Dell", 89900, 2023),
            Poste::new("PC-0002", TypePoste::Fixe, "HP", 64900, 2020),
            vieux,
        ]
    }

    #[test]
    fn la_valeur_ignore_les_postes_reformes() {
        assert_eq!(valeur_totale_ht(&parc_exemple()), 89900 + 64900);
    }

    #[test]
    fn compte_les_postes_par_type() {
        let compteurs = nombre_par_type(&parc_exemple());
        assert_eq!(compteurs[&TypePoste::Fixe], 2);
        assert_eq!(compteurs[&TypePoste::Portable], 1);
        assert_eq!(compteurs.get(&TypePoste::Serveur), None);
    }

    #[test]
    fn un_poste_reforme_n_est_pas_a_renouveler() {
        let parc = parc_exemple();
        let numeros: Vec<&str> = a_renouveler(&parc, 2026).iter().map(|p| p.numero.as_str()).collect();
        assert_eq!(numeros, ["PC-0002"]);
    }

    #[test]
    fn chercher_un_numero_absent_donne_none() {
        assert!(chercher(&parc_exemple(), "PC-9999").is_none());
    }
}

use parc::poste::{Poste, Statut, TypePoste};
use parc::stockage;

#[test]
fn enregistrer_puis_charger_redonne_le_meme_parc() {
    let chemin = std::env::temp_dir().join("parc-test-integration.csv");
    let mut poste = Poste::new("PC-0010", TypePoste::Portable, "Lenovo", 79900, 2026);
    poste.statut = Statut::Affecte("Chloé Lambert".to_string());
    let parc = vec![poste, Poste::new("PC-0011", TypePoste::Fixe, "HP", 64900, 2026)];

    stockage::enregistrer(&chemin, &parc).unwrap();
    let relu = stockage::charger(&chemin).unwrap();
    std::fs::remove_file(&chemin).unwrap();

    assert_eq!(relu, parc);
}

#[test]
fn une_ligne_fausse_donne_son_numero() {
    let contenu = "numero;type;marque;prix_ht;annee;statut\n\
                   PC-0001;portable;Dell;89900;2023;stock\n\
                   PC-0002;tablette;Samsung;45000;2024;stock\n";
    let erreur = stockage::lire_parc(contenu).unwrap_err();
    assert_eq!(erreur.to_string(), "ligne 3 : type de poste inconnu : « tablette »");
}

cargo test

     Running unittests src/lib.rs (target/debug/deps/parc-6e080b936515dd12)

running 14 tests
test poste::tests::formater_euros_garde_deux_decimales ... ok
test poste::tests::lire_euros_accepte_virgule_et_point ... ok
test poste::tests::lire_euros_refuse_les_saisies_invalides ... ok
test poste::tests::prix_ttc_ajoute_vingt_pour_cent ... ok
test poste::tests::renouvellement_a_partir_de_cinq_ans ... ok
test poste::tests::un_poste_neuf_est_en_stock ... ok
test poste::tests::un_poste_reforme_ne_peut_pas_etre_affecte ... ok
test stats::tests::chercher_un_numero_absent_donne_none ... ok
test stats::tests::compte_les_postes_par_type ... ok
test stats::tests::la_valeur_ignore_les_postes_reformes ... ok
test stats::tests::un_poste_reforme_n_est_pas_a_renouveler ... ok
test stockage::tests::ecrire_puis_relire_redonne_le_meme_poste ... ok
test stockage::tests::lit_une_ligne_correcte ... ok
test stockage::tests::refuse_une_ligne_incomplete ... ok

test result: ok. 14 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

     Running tests/fichier.rs (target/debug/deps/fichier-6a4ec51b99b87bb1)

running 2 tests
test une_ligne_fausse_donne_son_numero ... ok
test enregistrer_puis_charger_redonne_le_meme_parc ... ok

test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

cargo build --release