Ajout du devoir noté du jour

devoir qualdev 15-04-2024/metier/demographie.ts

+import { Pays } from './pays.ts';
+
+export class DemographieMondiale {
+  private _pays!: Pays[];
+
+  constructor() {
+    this._pays = [];
+  }
+
+  setPays(liste: Pays[]):void {
+    this._pays = liste;
+  }
+
+  getPays(): Pays[] {
+    return this._pays;
+  }
+
+  getIndexPays(nomOuCode: string): number {
+    for (let i= 0; i < this._pays.length; i++) {
+      if (this._pays[i].getNom() === nomOuCode || this._pays[i].getCode() === nomOuCode) {
+        return i;
+      }
+    }
+    return -1;
+  }
+
+  paysDejaConnu(nomOuCode: string): boolean {
+    return this.getIndexPays(nomOuCode) !== -1;
+  }
+
+  ajoutePays(pays: Pays): void {
+    const position = this.getIndexPays(pays.getNom());
+    if (position !== -1) {
+      throw new Error('Ce pays est déjà présent dans la liste !');
+    } else {
+      this._pays.push(pays);
+    }
+  }
+
+  ajouteHabitants(nomOuCode: string, nbHabitants: number): void {
+    const position = this.getIndexPays(nomOuCode);
+    if (position === -1) {
+      throw new Error('Pays non présent dans la liste !');
+    } else {
+      this._pays[position].ajouteHabitants(nbHabitants);
+    }
+  }
+
+  retrancheHabitants(nomOuCode: string, nbHabitants: number): void {
+    const position = this.getIndexPays(nomOuCode);
+    if (position === -1) {
+      throw new Error('Pays non présent dans la liste !');
+    } else {
+      const vide: boolean = this._pays[position].supprimeHabitants(nbHabitants);
+      if (vide) {
+        this._pays.splice(position, 1);
+      }
+    }
+  }
+
+  getTotal(): number {
+    let total= 0;
+    this._pays.forEach((value: Pays) => {
+      total += value.getNbHabitants();
+    });
+    return total;
+  }
+
+  toString(): string {
+    if (this._pays.length === 0) {
+      return 'Liste vide !';
+    }
+    let content = '';
+    this._pays.forEach((value: Pays) => {
+      content += value.toString() + ' ; ';
+    });
+
+    content = content.substring(0, content.length - 3) + '.';
+    return content;
+  }
+}

devoir qualdev 15-04-2024/metier/pays.ts

+export class Pays {
+  private _nom!: string;
+  private _code!: string;
+  private _nbHabitants!: number;
+
+  constructor(
+    nom: string = 'France',
+    nbHabitants: number = 67,
+    code: string = 'FR'
+  ) {
+    this._nom = nom;
+    this._nbHabitants = nbHabitants;
+    this._code = code;
+  }
+
+  getNom(): string {
+    return this._nom;
+  }
+
+  setNom(nom: string) :void{
+    if (nom.trim().length > 2) {
+      this._nom = nom.trim();
+    } else {
+      throw new Error('Le nom du pays doit avoir au moins 3 lettres.');
+    }
+  }
+
+  setNbHabitants(nbHabitants: number) :void{
+    if (nbHabitants >= 0) {
+      this._nbHabitants = nbHabitants;
+    } else {
+      throw new Error('Le nombre de millions d\'habitants doit être positif !');
+    }
+  }
+
+  getNbHabitants(): number {
+    return this._nbHabitants;
+  }
+
+  setCode(code: string) :void {
+    if (code.length === 2) {
+      this._code = code;
+    } else {
+      throw new Error('Le code pays doit faire 2 caractères !');
+    }
+  }
+
+  getCode(): string {
+    return this._code;
+  }
+
+  ajouteHabitants(nb: number): void {
+    if (nb > 0) {
+      this._nbHabitants += nb;
+    } else {
+      throw new Error('Le nombre à ajouter doit être positif !');
+    }
+  }
+
+  supprimeHabitants(nb: number): boolean {
+    if (nb > 0) {
+      if (nb <= this._nbHabitants) {
+        this._nbHabitants -= nb;
+        return this._nbHabitants === 0;
+      }
+      throw new Error("Pas assez d'habitants dans ce pays!");
+    } else {
+      throw new Error('Le nombre à retrancher doit être positif !');
+    }
+  }
+
+  toString(): string {
+    return (
+      this._nom + ' (' + this._code + '), ' + this._nbHabitants + ' millions d\'habitants'
+    );
+  }
+}

devoir qualdev 15-04-2024/test/demographie.test.ts

+import { assertEquals } from "https://deno.land/std@0.220.0/assert/mod.ts";
+import { assertThrows } from "https://deno.land/std@0.220.0/assert/assert_throws.ts";
+import { Pays } from "../metier/pays.ts";
+import { DemographieMondiale } from "../metier/demographie.ts";
+
+Deno.test("cas par defaut", () => {
+    let variable = new DemographieMondiale();
+    assertEquals(variable.getPays() , []);
+    assertEquals(variable.toString() , 'Liste vide !');
+    assertEquals(variable.getTotal(), 0);
+    assertEquals(variable.getIndexPays("EO") , -1);
+});
+
+Deno.test("cas avec 2 pays renseignés", () => {
+    let variable = new DemographieMondiale();
+
+    assertEquals(variable.getTotal(), 0);
+
+    let paysTest1 = new Pays("Pangée", 45, "PN");
+    let paysTest2 = new Pays("Esperantie", 56, "EO");
+    variable.setPays([paysTest1, paysTest2]);
+
+    assertEquals(variable.getPays() , [paysTest1, paysTest2]);
+
+    assertEquals(variable.getIndexPays("Pangée") , 0);
+    assertEquals(variable.getIndexPays("EO") , 1);
+
+    assertEquals(variable.paysDejaConnu("Pangée"), true);
+    assertEquals(variable.paysDejaConnu("Westalie"), false);
+
+    let paysTest3 = new Pays("Westalie", 34, "WT");
+    variable.ajoutePays(paysTest3);
+    assertEquals(variable.getPays() , [paysTest1, paysTest2, paysTest3]);
+
+    assertEquals(variable.getTotal(), 135);
+    
+    assertEquals(variable.toString() , "Pangée (PN), 45 millions d'habitants ; Esperantie (EO), 56 millions d'habitants ; Westalie (WT), 34 millions d'habitants.");
+});
+
+Deno.test("cas ajout d'habitants", () => {
+    let variable = new DemographieMondiale();
+    let paysTest2 = new Pays("Esperantie", 56, "EO");
+    variable.setPays([paysTest2]);
+
+    variable.ajouteHabitants("EO", 4)
+    assertEquals(variable.getPays()[0].getNbHabitants(), 60);
+});
+
+Deno.test("cas retrait d'habitants", () => {
+    let variable = new DemographieMondiale();
+    let paysTest2 = new Pays("Esperantie", 56, "EO");
+    variable.setPays([paysTest2]);
+
+    variable.retrancheHabitants("EO", 6)
+    assertEquals(variable.getPays()[0].getNbHabitants(), 50);
+});
+
+Deno.test("cas erreur ajout pays déjà existant", () => {
+    let variable = new DemographieMondiale();
+    let paysTest2 = new Pays("Esperantie", 56, "EO");
+    variable.setPays([paysTest2]);
+    assertThrows(() => variable.ajoutePays(paysTest2), "Ce pays est déjà présent dans la liste !");
+});
+
+Deno.test("cas erreur retrait ou ajout habitants d'un pays pas dans liste", () => {
+    let variable = new DemographieMondiale();
+    let paysTest2 = new Pays("Esperantie", 56, "EO");
+    variable.setPays([paysTest2]);
+    assertThrows(() => variable.retrancheHabitants("PN", 4), "Pays non présent dans la liste !");
+    assertThrows(() => variable.ajouteHabitants("PN", 4), "Pays non présent dans la liste !");
+});
\ No newline at end of file

devoir qualdev 15-04-2024/test/pays.test.ts

+import { assertEquals } from "https://deno.land/std@0.220.0/assert/mod.ts";
+import { assertThrows } from "https://deno.land/std@0.220.0/assert/assert_throws.ts";
+import { Pays } from "../metier/pays.ts";
+
+Deno.test("cas par defaut", () => {
+    let paysTest = new Pays();
+    assertEquals(paysTest.getNom() , "France");
+    assertEquals(paysTest.getNbHabitants() , 67);
+    assertEquals(paysTest.getCode() , "FR");
+    assertEquals(paysTest.toString(), "France (FR), 67 millions d'habitants");
+});
+
+Deno.test("cas pays fictif dans les paramètres", () => {
+    let paysTest = new Pays("Pangée", 45, "PN");
+    assertEquals(paysTest.getNom() , "Pangée");
+    assertEquals(paysTest.getNbHabitants() , 45);
+    assertEquals(paysTest.getCode() , "PN");
+    assertEquals(paysTest.toString(), "Pangée (PN), 45 millions d'habitants");
+});
+
+
+Deno.test("cas pays fictif initialisé après création", () => {
+    let paysTest = new Pays();
+    paysTest.setNom("Pangée");
+    paysTest.setNbHabitants(45);
+    paysTest.setCode("PN");
+    assertEquals(paysTest.getNom() , "Pangée");
+    assertEquals(paysTest.getNbHabitants() , 45);
+    assertEquals(paysTest.getCode() , "PN");
+    assertEquals(paysTest.toString(), "Pangée (PN), 45 millions d'habitants");
+});
+
+Deno.test("cas ajout d'habitants après création pays fictif", () => {
+    let paysTest = new Pays("Pangée", 45, "PN");
+    paysTest.ajouteHabitants(45);
+    assertEquals(paysTest.getNbHabitants() , 90);
+});
+
+Deno.test("cas supression d'habitants après création pays fictif", () => {
+    let paysTest = new Pays("Pangée", 45, "PN");
+    paysTest.supprimeHabitants(25);
+    assertEquals(paysTest.getNbHabitants() , 20);
+});
+
+Deno.test("cas erreur nom pays de moins de 3 lettres", () => {
+    let paysTest = new Pays();
+    assertThrows(() => paysTest.setNom("ah"), "Le nom du pays doit avoir au moins 3 lettres.");
+});
+
+Deno.test("cas erreur nombres habitants négatif", () => {
+    let paysTest = new Pays();
+    assertThrows(() => paysTest.setNbHabitants(-5), "Le nombre de millions d'habitants doit être positif !");
+});
+
+Deno.test("cas erreur code d'une logueur différente de 2", () => {
+    let paysTest = new Pays();
+    assertThrows(() => paysTest.setCode("A"), "Le code pays doit faire 2 caractères !");
+    assertThrows(() => paysTest.setCode("ABC"), "Le code pays doit faire 2 caractères !");
+});
+
+Deno.test("cas erreur ajout nb habitants négatifs", () => {
+    let paysTest = new Pays("Pangée", 45, "PN");
+    assertThrows(() => paysTest.ajouteHabitants(-1), "Le nombre à ajouter doit être positif !");    
+});
+
+Deno.test("cas erreur suppression nb habitants négatifs", () => {
+    let paysTest = new Pays("Pangée", 45, "PN");
+    assertThrows(() => paysTest.supprimeHabitants(-1), "Le nombre à retrancher doit être positif !");    
+});
+
+Deno.test("cas erreur suppression nb habitants positif mais > aux nb actuel", () => {
+    let paysTest = new Pays("Pangée", 45, "PN");
+    assertThrows(() => paysTest.supprimeHabitants(50), "Pas assez d'habitants dans ce pays!");    
+});
+
+/*
+
+    variable.retrancheHabitants("EO", 50)
+    assertThrows(() => variable.getPays()[0].getNbHabitants(), 0);*/
\ No newline at end of file