ENSEEIHT/TP-programmation-imperative
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity
TP-programmation-imperative/td08/listes.adb

947 lines
24 KiB
Ada
Raw Normal View History

init
2023-06-10 19:03:54 +00:00
with Ada.Text_IO; use Ada.Text_IO;
with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
with Ada.Unchecked_Deallocation;
package body Listes is
--! Les sous-programmes pour lesquels on demande une version itérative et
--! récursive apparaissent trois fois :
--! - avec le suffixe _Recursive : pour la version récursive
--! - avec le suffixe _Iterative : pour la version itérative
--! - sans suffixe : c'est le corps du sous-programme de l'interface qui
--! appelle la version récursive. Inutile de le changer (sauf pour
--! Afficher où on pourra le changer pour essayer l'autre version).
--!
--! Un trait horizontal sépare les différents groupes de sous-programmes.
----------------------------------------------------------------------------
procedure Free is
new Ada.Unchecked_Deallocation (T_Cellule, T_Liste);
---------------------------------------------------------------------------- question 1
procedure Initialiser (Liste: out T_Liste) is
begin
Liste := null;
end Initialiser;
----------------------------------------------------------------------------
procedure Detruire_Recursive (Liste: in out T_Liste) is
begin
if Liste /= null then
Detruire_Recursive(Liste.All.Suivante);
Free(Liste);
Liste := null;
end if;
end Detruire_Recursive;
procedure Detruire_Iterative (Liste: in out T_Liste) is
A_Detruire: T_Liste := Liste;
Curseur: T_Liste := A_Detruire.All.Suivante;
begin
while (Curseur /= null) loop
Free(A_Detruire);
A_Detruire := Curseur;
Curseur := Curseur.All.Suivante;
end loop;
Free(A_Detruire);
Liste := null;
end Detruire_Iterative;
procedure Detruire (Liste: in out T_Liste) is
begin
Detruire_Recursive (Liste);
end Detruire;
---------------------------------------------------------------------------- question 2
procedure Ajouter_Debut (Liste: in out T_Liste; Element: in T_Element) is
begin
if Liste = null then
Liste := new T_Cellule'(Element, Null);
else
Liste := new T_Cellule'(Element, Liste);
end if;
end Ajouter_Debut;
---------------------------------------------------------------------------- question 3
function Premier (Liste: in T_Liste) return T_Element is
begin
if Taille(Liste) = 0 then
raise Element_Absent_Error;
else
return Liste.All.Element;
end if;
end Premier;
---------------------------------------------------------------------------- question 4
function Taille_Recursive (Liste: in T_Liste) return Integer is
begin
if Liste = null then
return 0;
else
return 1 + Taille_Recursive(Liste.All.Suivante);
end if;
end Taille_Recursive;
function Taille_Iterative (Liste: in T_Liste) return Integer is
Cursor : T_liste := Liste;
l : Integer := 0;
begin
while (Cursor /= null) loop
Cursor := Cursor.All.Suivante;
l := l + 1;
end loop;
return l;
end Taille_Iterative;
function Taille (Liste: in T_Liste) return Integer is
begin
return Taille_Recursive (Liste);
end Taille;
---------------------------------------------------------------------------- question 5
generic
with procedure Afficher_Element (Element: in T_Element);
procedure Afficher_Recursive (Liste: in T_Liste);
procedure Afficher_Recursive (Liste: in T_Liste) is
begin
if Liste = null then
put("--E");
else
put("-->[");
Afficher_Element(Liste.All.Element);
put("]");
Afficher_Recursive(Liste.All.Suivante);
end if;
end Afficher_Recursive;
generic
with procedure Afficher_Element (Element: in T_Element);
procedure Afficher_Iterative (Liste: in T_Liste);
procedure Afficher_Iterative (Liste: in T_Liste) is
Cursor : T_liste := Liste;
begin
while (Cursor /= null) loop
put("-->[");
Afficher_Element(Cursor.All.Element);
put("]");
Cursor := Cursor.All.Suivante;
end loop;
put("--E");
end Afficher_Iterative;
procedure Afficher (Liste: in T_Liste) is
procedure Afficher_Recursive_Instanciee is
new Afficher_Recursive (Afficher_Element);
begin
Afficher_Recursive_Instanciee (Liste);
end Afficher;
---------------------------------------------------------------------------- question 6
function Est_Present_Recursive (Liste: in T_Liste; Element: in T_Element) return Boolean is
begin
if Liste = null then
return False;
elsif Liste.All.Element = Element then
return True;
else
return Est_Present_Recursive(Liste.All.Suivante, Element);
end if;
end Est_Present_Recursive;
function Est_Present_Iterative (Liste: in T_Liste; Element: in T_Element) return Boolean is
Cursor : T_liste := Liste;
begin
while (Cursor /= null) loop
if Cursor.All.Element = Element then
return True;
end if;
Cursor := Cursor.All.Suivante;
end loop;
return False;
end Est_Present_Iterative;
function Est_Present (Liste: in T_Liste; Element: in T_Element) return Boolean is
begin
return Est_Present_Recursive (Liste, Element);
end Est_Present;
---------------------------------------------------------------------------- question 7
procedure Supprimer_Recursive (Liste: in out T_Liste; Element: in T_Element) is
Cursor : T_Liste;
begin
if not Est_Present(Liste, Element) then
raise Element_Absent_Error;
elsif Liste.All.Suivante.All.Element = Element then
Cursor := Liste.All.Suivante.All.Suivante;
Free(Liste.All.Suivante);
Liste.All.Suivante:= Cursor;
else
Supprimer_Recursive(Liste.All.Suivante, Element);
end if;
end Supprimer_Recursive;
procedure Supprimer_Iterative (Liste: in out T_Liste; Element: in T_Element) is
Cursor: T_Liste := Liste;
Cursor_next: T_Liste;
begin
if not Est_Present(Liste, Element) then
raise Element_Absent_Error;
else
while (Cursor.All.Suivante /= null) loop
exit when Cursor.All.Suivante.All.Element = Element;
Cursor := Cursor.All.Suivante;
end loop;
Cursor_next := Cursor.All.Suivante.All.Suivante;
Free(Cursor.All.Suivante);
Cursor.All.Suivante := Cursor_next;
end if;
end Supprimer_Iterative;
procedure Supprimer (Liste: in out T_Liste; Element: in T_Element) is
begin
Supprimer_Recursive (Liste, Element);
end Supprimer;
---------------------------------------------------------------------------- question 8
function Cellule_Contenant_Recursive (Element: T_Element; Liste: in T_Liste) return T_Liste is
begin
if Liste = null then
return null;
elsif Liste.All.Element = Element then
return Liste;
else
return Cellule_Contenant_Recursive(Element, Liste.All.Suivante);
end if;
end Cellule_Contenant_Recursive;
function Cellule_Contenant_Iterative (Element: T_Element; Liste: in T_Liste) return T_Liste is
Cursor : T_liste := Liste;
begin
while (Cursor /= null) loop
if Cursor.All.Element = Element then
return Cursor;
end if;
Cursor := Cursor.All.Suivante;
end loop;
return null;
end Cellule_Contenant_Iterative;
function Cellule_Contenant (Element: T_Element; Liste: in T_Liste) return T_Liste is
begin
return Cellule_Contenant_Recursive (Element, Liste);
end Cellule_Contenant;
---------------------------------------------------------------------------- question 9
procedure Inserer_Apres (Liste: in out T_Liste ; Nouveau, Element: in T_Element) is
Cursor: T_Liste;
begin
if not Est_Present(Liste, Element) then
raise Element_Absent_Error;
else
Cursor := Cellule_Contenant(Element, Liste);
Cursor.All.Suivante := new T_Cellule'(Nouveau, Cursor.All.Suivante);
end if;
end Inserer_Apres;
---------------------------------------------------------------------------- question 10
function Ieme_Recursive (Liste: in T_Liste; Indice: in Integer) return T_Element is
begin
if Indice < 0 then
raise Indice_Error;
elsif Indice = 0 then
return Liste.All.Element;
else
return Ieme_Recursive(Liste.All.Suivante, Indice - 1);
end if;
end Ieme_Recursive;
function Ieme_Iterative (Liste: in T_Liste; Indice: in Integer) return T_Element is
Cursor : T_liste := Liste;
l : Integer := 0;
begin
if Indice < 0 then
raise Indice_Error;
else
While (Cursor /= null) Loop
exit when l = Indice;
Cursor := Cursor.All.Suivante;
l := l + 1;
End Loop;
return Cursor.All.Element;
end if;
end Ieme_Iterative;
function Ieme (Liste: in T_Liste; Indice: in Integer) return T_Element is
begin
return Ieme_Recursive (Liste, Indice);
end Ieme;
---------------------------------------------------------------------------- question 11
procedure Supprimer_Ieme_Recursive (Liste: in out T_Liste; Indice: in Integer) is
Cursor : T_Liste := Liste;
begin
if Indice < 0 then
raise Indice_Error;
elsif Indice = 0 then
Liste := Liste.All.Suivante;
Free(Cursor);
elsif Indice = 1 then
Cursor := Liste.All.Suivante.All.Suivante;
Free(Liste.All.Suivante);
Liste.All.Suivante:= Cursor;
else
Supprimer_Ieme_Recursive(Liste.All.Suivante, Indice - 1);
end if;
end Supprimer_Ieme_Recursive;
procedure Supprimer_Ieme_Iterative (Liste: in out T_Liste; Indice: in Integer) is
Cursor: T_Liste := Liste;
Cursor_next: T_Liste;
l : Integer := 0;
begin
if Indice < 0 then
raise Indice_Error;
else
While (Cursor.All.Suivante.All.Suivante /= null) Loop
exit when l = Indice - 1;
Cursor := Cursor.All.Suivante;
l := l + 1;
End Loop;
end if;
if l /= Indice - 1 then
raise Indice_Error;
else
Cursor_next := Cursor.All.Suivante.All.Suivante;
Free(Cursor.All.Suivante);
Cursor.All.Suivante := Cursor_next;
end if;
end Supprimer_Ieme_Iterative;
procedure Supprimer_Ieme (Liste: in out T_Liste; Indice: in Integer) is
begin
Supprimer_Ieme_Recursive (Liste, Indice);
end Supprimer_Ieme;
---| les tests |------------------------------------------------------------
procedure Tester is
-- XXX
procedure Put is new Afficher (Afficher_Element);
-- Initialiser une liste [ Un, Trois, Un, Deux].
-- Elle devra être détruite.
procedure Initialiser_Liste1312 (Liste: out T_Liste) is
begin
Initialiser (Liste);
Ajouter_Debut (Liste, Deux);
Ajouter_Debut (Liste, Un);
Ajouter_Debut (Liste, Trois);
Ajouter_Debut (Liste, Un);
end;
procedure Tester_Initialiser is
Vide: T_Liste;
begin
Initialiser (Vide);
pragma Assert (Vide = null);
end Tester_Initialiser;
procedure Tester_Ajouter_Debut is
Liste: T_Liste;
begin
Initialiser (Liste);
-- ajouter un premier élémnet
Ajouter_Debut (Liste, Un);
pragma Assert (Liste /= null);
pragma Assert (Liste.all.Suivante = null);
pragma Assert (Liste.all.Element = Un);
-- ajouter un deuxième élémnet
Ajouter_Debut (Liste, Deux);
pragma Assert (Liste /= null);
pragma Assert (Liste.all.Element = Deux);
pragma Assert (Liste.all.Suivante /= null);
pragma Assert (Liste.all.Suivante.all.Element = Un);
pragma Assert (Liste.all.Suivante.all.Suivante = null);
Detruire (Liste);
end Tester_Ajouter_Debut;
procedure Tester_Premier is
Liste: T_Liste;
begin
Initialiser (Liste);
-- ajouter un premier élémnet
Ajouter_Debut (Liste, Un);
pragma Assert (Premier (Liste) = Un);
-- ajouter un deuxième élémnet
Ajouter_Debut (Liste, Deux);
pragma Assert (Premier (Liste) = Deux);
-- ajouter un troisième élémnet
Ajouter_Debut (Liste, Trois);
pragma Assert (Premier (Liste) = Trois);
Detruire (Liste);
end Tester_Premier;
generic
with function Taille (Liste: in T_Liste) return Integer;
procedure Tester_Taille;
procedure Tester_Taille is
Liste: T_Liste;
begin
Initialiser (Liste);
pragma Assert (Taille (Liste) = 0);
-- ajouter un premier élémnet
Ajouter_Debut (Liste, Un);
pragma Assert (Taille (Liste) = 1);
-- ajouter un deuxième élémnet
Ajouter_Debut (Liste, Deux);
pragma Assert (Taille (Liste) = 2);
-- ajouter un troisième élémnet
Ajouter_Debut (Liste, Trois);
pragma Assert (Taille (Liste) = 3);
-- ajouter un quatirème élémnet
Ajouter_Debut (Liste, Un);
pragma Assert (Taille (Liste) = 4);
Detruire (Liste);
end Tester_Taille;
procedure Tester_Taille_Recursive is
new Tester_Taille (Taille_Recursive);
procedure Tester_Taille_Iterative is
new Tester_Taille (Taille_Iterative);
generic
with function Est_Present (Liste: in T_Liste; Element: in T_Element) return Boolean;
procedure Tester_Est_Present;
procedure Tester_Est_Present is
Liste: T_Liste;
begin
Initialiser (Liste);
pragma Assert (not Est_Present (Liste, Un));
-- ajouter un premier élémnet
Ajouter_Debut (Liste, Un);
pragma Assert (Est_Present (Liste, Un));
pragma Assert (not Est_Present (Liste, Deux));
-- ajouter un deuxième élémnet
Ajouter_Debut (Liste, Deux);
pragma Assert (Est_Present (Liste, Un));
pragma Assert (Est_Present (Liste, Deux));
pragma Assert (not Est_Present (Liste, Trois));
-- ajouter un troisième élémnet
Ajouter_Debut (Liste, Un);
pragma Assert (Est_Present (Liste, Un));
pragma Assert (Est_Present (Liste, Deux));
pragma Assert (not Est_Present (Liste, Trois));
Detruire (Liste);
end Tester_Est_Present;
procedure Tester_Est_Present_Recursive is
new Tester_Est_Present (Est_Present_Recursive);
procedure Tester_Est_Present_Iterative is
new Tester_Est_Present (Est_Present_Iterative);
generic
with function Cellule_Contenant (Element: in T_Element; Liste: in T_Liste) return T_Liste;
procedure Tester_Cellule_Contenant;
procedure Tester_Cellule_Contenant is
procedure Tester_Existants is
Liste: T_Liste;
begin
Initialiser_Liste1312 (Liste);
pragma Assert (Cellule_Contenant (Un, Liste) = Liste);
pragma Assert (Cellule_Contenant (Trois, Liste) = Liste.all.Suivante);
pragma Assert (Cellule_Contenant (Deux, Liste) = Liste.all.Suivante.all.Suivante.all.Suivante);
Detruire (Liste);
end Tester_Existants;
procedure Tester_Absent (Liste: in T_Liste; Element: in T_Element) is
Ptr: T_Liste;
begin
Ptr := Cellule_Contenant (Element, Liste);
pragma Assert (False);
pragma Assert (Ptr = null); --! pour éviter l'avertissement
exception
when Element_Absent_Error =>
null;
when others =>
pragma Assert (False);
end;
Liste: T_Liste;
begin
Tester_Existants;
-- tester les cas où l'élément n'est pas présent
Initialiser (Liste);
Tester_Absent (Liste, Un);
Ajouter_Debut (Liste, Deux);
Tester_Absent (Liste, Un);
Ajouter_Debut (Liste, Trois);
Tester_Absent (Liste, Un);
Detruire (Liste);
end Tester_Cellule_Contenant;
procedure Tester_Cellule_Contenant_Recursive is
new Tester_Cellule_Contenant (Cellule_Contenant_Recursive);
procedure Tester_Cellule_Contenant_Iterative is
new Tester_Cellule_Contenant (Cellule_Contenant_Iterative);
generic
with procedure Supprimer (Liste: in out T_Liste; Element: in T_Element);
procedure Tester_Supprimer;
procedure Tester_Supprimer is
procedure Supprimer_Trace (Liste: in out T_Liste; Element: in T_Element) is
begin
-- Tracer l'instruction qui va être exécutée
Put ("> Supprimer (..., ");
Afficher_Element (Element);
Put (");");
New_Line;
Supprimer (Liste, Element);
-- Afficher la liste
Put (Liste);
New_Line;
New_Line;
end Supprimer_Trace;
procedure Supprimer_Extremites is
Liste: T_Liste;
begin
Initialiser_Liste1312 (Liste);
New_Line;
Put_Line ("## Supprimer_Extremites");
New_Line;
Put (Liste);
New_Line;
New_Line;
-- supprimer le premier élément
Supprimer_Trace (Liste, Un);
pragma Assert (Premier (Liste) = Trois);
pragma Assert (Taille (Liste) = 3);
-- supprimer le dernier élément
Supprimer_Trace (Liste, Deux);
pragma Assert (Taille (Liste) = 2);
-- supprimer le dernier élément
Supprimer_Trace (Liste, Un);
pragma Assert (Taille (Liste) = 1);
-- supprimer le seul élément
Supprimer_Trace (Liste, Trois);
pragma Assert (Taille (Liste) = 0);
Detruire (Liste);
end Supprimer_Extremites;
procedure Supprimer_Milieu is
Liste: T_Liste;
begin
Initialiser_Liste1312 (Liste);
New_Line;
Put_Line ("## Supprimer_Milieu");
New_Line;
Put (Liste);
New_Line;
New_Line;
-- supprimer le premier élément
Supprimer_Trace (Liste, Un);
pragma Assert (Premier (Liste) = Trois);
pragma Assert (Taille (Liste) = 3);
pragma Assert (Est_Present (Liste, Un));
pragma Assert (Est_Present (Liste, Deux));
-- supprimer un élément au milieu
Supprimer_Trace (Liste, Un);
pragma Assert (Taille (Liste) = 2);
pragma Assert (Premier (Liste) = Trois);
pragma Assert (Est_Present (Liste, Deux));
Detruire (Liste);
end Supprimer_Milieu;
procedure Supprimer_Liste_Vide is
Vide: T_Liste;
begin
Initialiser (Vide);
Supprimer (Vide, Un);
pragma Assert (False);
exception
when Element_Absent_Error =>
null;
Detruire (Vide);
when others =>
--pragma Assert (False);
null;
end Supprimer_Liste_Vide;
procedure Supprimer_Liste1_Un_Element_Present is
Liste: T_Liste;
begin
Initialiser (Liste);
Ajouter_Debut (Liste, Un);
Supprimer (Liste, Un);
pragma Assert (Taille(Liste) = 0);
Detruire (Liste);
end Supprimer_Liste1_Un_Element_Present;
procedure Supprimer_Liste1_Un_Element_Absent is
Liste: T_Liste;
begin
Initialiser (Liste);
Ajouter_Debut (Liste, Un);
Supprimer (Liste, Deux);
pragma Assert (False);
exception
when Element_Absent_Error =>
null;
Detruire (Liste);
when others =>
pragma Assert (False);
end Supprimer_Liste1_Un_Element_Absent;
begin
pragma Assert (Un /= Deux);
pragma Assert (Un /= Trois);
pragma Assert (Deux /= Trois);
Supprimer_Liste_Vide;
Supprimer_Liste1_Un_Element_Present;
Supprimer_Liste1_Un_Element_Absent;
Supprimer_Extremites;
Supprimer_Milieu;
end;
procedure Tester_Supprimer_Recursive is
new Tester_Supprimer(Supprimer_Recursive);
procedure Tester_Supprimer_Iterative is
new Tester_Supprimer(Supprimer_Iterative);
generic
with function Ieme (Liste: in T_Liste; Indice: in Integer) return T_Element;
procedure Tester_Ieme;
procedure Tester_Ieme is
procedure Tester_Nominal is
Liste: T_Liste;
begin
Initialiser_Liste1312 (Liste);
pragma Assert (Ieme (Liste, 0) = Un);
pragma Assert (Ieme (Liste, 1) = Trois);
pragma Assert (Ieme (Liste, 2) = Un);
pragma Assert (Ieme (Liste, 3) = Deux);
Detruire (Liste);
end Tester_Nominal;
procedure Tester_Indice_Invalide (Liste: in T_Liste; Indice: in Integer) is
Element: T_Element;
begin
Element := Ieme (Liste, Indice);
pragma Assert (False);
pragma Assert (Element = Un); -- pour eviter le warning
exception
when Indice_Error =>
null;
when others =>
pragma Assert (False);
end Tester_Indice_Invalide;
Vide: T_Liste;
Liste: T_Liste;
begin
Tester_Nominal;
Initialiser (Vide);
Tester_Indice_Invalide (Vide, 0);
Tester_Indice_Invalide (Vide, -1);
Tester_Indice_Invalide (Vide, 1);
Detruire (Vide);
Initialiser_Liste1312 (Liste);
Tester_Indice_Invalide (Vide, 4);
Tester_Indice_Invalide (Vide, 10);
Tester_Indice_Invalide (Vide, -1);
Tester_Indice_Invalide (Vide, -10);
Detruire (Liste);
end Tester_Ieme;
procedure Tester_Ieme_Recursive is
new Tester_Ieme (Ieme_Recursive);
procedure Tester_Ieme_Iterative is
new Tester_Ieme (Ieme_Iterative);
procedure Tester_Inserer_Apres is
procedure Test_Nominal is
Liste: T_Liste;
begin
Initialiser (Liste);
Ajouter_Debut (Liste, Un);
Inserer_Apres (Liste, Deux, Un);
pragma Assert (Taille (Liste) = 2);
pragma Assert (Premier (Liste) = Un);
pragma Assert (Liste.all.Suivante.all.Element = Deux);
Inserer_Apres (Liste, Un, Deux);
pragma Assert (Taille (Liste) = 3);
pragma Assert (Premier (Liste) = Un);
pragma Assert (Liste.all.Suivante.all.Element = Deux);
pragma Assert (Liste.all.Suivante.all.Suivante.all.Element = Un);
Inserer_Apres (Liste, Trois, Un);
pragma Assert (Taille (Liste) = 4);
pragma Assert (Premier (Liste) = Un);
pragma Assert (Liste.all.Suivante.all.Element = Trois);
pragma Assert (Liste.all.Suivante.all.Suivante.all.Element = Deux);
Detruire (Liste);
end Test_Nominal;
procedure Test_Erreur (Liste: in out T_Liste; Element: in T_Element) is
begin
Inserer_Apres (Liste, Un, Element);
pragma Assert (False);
exception
when Element_Absent_Error =>
null;
when others =>
pragma Assert (False);
end Test_Erreur;
Liste: T_Liste;
begin
Test_Nominal;
-- Tests erreurs
Initialiser (Liste);
for I in 1..10 loop
Test_Erreur (Liste, Deux);
Ajouter_Debut (Liste, Un);
end loop;
Detruire (Liste);
end Tester_Inserer_Apres;
generic
with procedure Supprimer_Ieme (Liste: in out T_Liste; Indice: in Integer);
procedure Tester_Supprimer_Ieme;
procedure Tester_Supprimer_Ieme is
procedure Supprimer_Ieme_Trace (Liste: in out T_Liste; Indice: in Integer) is
begin
-- Tracer l'instruction qui va être exécutée
Put ("> Supprimer_Ieme (..., ");
Put (Indice, 1);
Put (");");
New_Line;
Supprimer_Ieme (Liste, Indice);
-- Afficher la liste
Put (Liste);
New_Line;
New_Line;
end Supprimer_Ieme_Trace;
procedure Supprimer_Ieme_Nominal is
Liste: T_Liste;
begin
Initialiser_Liste1312 (Liste);
New_Line;
Put_Line ("## Supprimer_Ieme_Nominal");
New_Line;
Put (Liste);
New_Line;
New_Line;
-- supprimer au milieu
Supprimer_Ieme_Trace (Liste, 2);
pragma Assert (Taille (Liste) = 3);
pragma Assert (Est_Present (Liste, Un));
pragma Assert (Est_Present (Liste, Deux));
pragma Assert (Est_Present (Liste, Trois));
-- supprimer le dernier élément
Supprimer_Ieme_Trace (Liste, 2);
pragma Assert (Taille (Liste) = 2);
pragma Assert (Est_Present (Liste, Un));
pragma Assert (not Est_Present (Liste, Deux));
pragma Assert (Est_Present (Liste, Trois));
-- supprimer le premier élément
Supprimer_Ieme_Trace (Liste, 0);
pragma Assert (Taille (Liste) = 1);
pragma Assert (Premier (Liste) = Trois);
-- supprimer le seul élément
Supprimer_Ieme_Trace (Liste, 0);
pragma Assert (Taille (Liste) = 0);
Detruire (Liste);
end Supprimer_Ieme_Nominal;
procedure Supprimer_Ieme_Erreur (Liste: in out T_Liste; Indice: in Integer) is
begin
Supprimer_Ieme (Liste, Indice);
pragma Assert (False);
exception
when Indice_Error =>
null;
when others =>
pragma Assert (False);
end Supprimer_Ieme_Erreur;
Liste: T_Liste;
begin
Supprimer_Ieme_Nominal;
Initialiser (Liste);
Supprimer_Ieme_Erreur (Liste, 0);
Supprimer_Ieme_Erreur (Liste, -1);
Supprimer_Ieme_Erreur (Liste, 1);
Detruire (Liste);
Initialiser_Liste1312 (Liste);
Supprimer_Ieme_Erreur (Liste, Taille (Liste));
Supprimer_Ieme_Erreur (Liste, -1);
Detruire (Liste);
end Tester_Supprimer_Ieme;
procedure Tester_Supprimer_Ieme_Recursive is
new Tester_Supprimer_Ieme(Supprimer_Ieme_Recursive);
procedure Tester_Supprimer_Ieme_Iterative is
new Tester_Supprimer_Ieme(Supprimer_Ieme_Iterative);
begin
pragma Assert (Un /= Deux);
pragma Assert (Un /= Trois);
pragma Assert (Deux /= Trois);
Tester_Initialiser;
Tester_Ajouter_Debut;
Tester_Premier;
Tester_Taille_Recursive;
Tester_Taille_Iterative;
Tester_Est_Present_Recursive;
Tester_Est_Present_Iterative;
Tester_Supprimer_Recursive;
Tester_Supprimer_Iterative;
Tester_Cellule_Contenant_Recursive;
Tester_Cellule_Contenant_Iterative;
Tester_Inserer_Apres;
Tester_Ieme_Recursive;
Tester_Ieme_Iterative;
Tester_Supprimer_Ieme_Recursive;
Tester_Supprimer_Ieme_Iterative;
end Tester;
end Listes;
Reference in a new issue Copy permalink