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;