Init_Collection (R.all);

   procedure Init_Collection (Collection : in out Result_Collection)

   is

   begin

      Init_List (Collection.Children);

      Collection.Passes := Result_Info_List.Empty_List;

      Collection.Failures := Result_Info_List.Empty_List;

      Collection.Errors := Result_Info_List.Empty_List;

      Collection.Parent := null;

      Collection.Test_Name := Empty_VString;

   end Init_Collection;

   package body Result_List is

      procedure Init_List (Target : in out List) is

      begin

         Target.First := null;

         Target.Last := null;

         Target.Size := 0;

      end Init_List;

      procedure Remove (Ptr : Node_Access) is

         procedure Free is

           new Ada.Unchecked_Deallocation (Object => Node,

                                           Name   => Node_Access);

         My_Ptr : Node_Access := Ptr;

      begin

         Ptr.Next := null;

         Free (My_Ptr);

      end Remove;

      procedure Append (Target    : in out List;

                        Node_Data :        Result_Collection_Wrapper) is

         New_Node : Node_Access  := null;

      begin

         if Target.Size = Count_Type'Last then

            raise List_Full;

         end if;

         New_Node := new Node'(Data => Node_Data, Next => null);

         if Target.Last = null then

            Target.First := New_Node;

         else

            Target.Last.Next := New_Node;

         end if;

         Target.Last := New_Node;

         Target.Size := Target.Size + 1;

      end Append;

      procedure Clear (Target : in out List) is

         Current_Node : Node_Access := Target.First;

         Next_Node : Node_Access := null;

      begin

         while Current_Node /= null loop

            Next_Node := Current_Node.Next;

            Remove (Current_Node);

            Current_Node := Next_Node;

         end loop;

         Target.First := null;

         Target.Last := null;

         Target.Size := 0;

      end Clear;

      function First (Target : List) return Cursor is

      begin

         return Cursor (Target.First);

      end First;

      function Next (Position : Cursor) return Cursor is

      begin

         if Position = null then

            raise Invalid_Cursor;

         end if;

         return Cursor (Position.Next);

      end Next;

      function Data (Position : Cursor) return Result_Collection_Wrapper is

      begin

         if Position = null then

            raise Invalid_Cursor;

         end if;

         return Position.Data;

      end Data;

      function Is_Valid (Position : Cursor) return Boolean is

      begin

         return Position /= null;

      end Is_Valid;

      function Length (Target : List) return Count_Type is

      begin

         return Target.Size;

      end Length;

   end Result_List;

   procedure Init_Collection (Collection : in out Result_Collection);

   -- Initialize the collection, must be called before other actions.

      type List is limited private;

      type Cursor is private;

      subtype Count_Type is Natural;

      Invalid_Cursor : exception;

      List_Full : exception;

      -- Thrown when the size of the list exceeds Count_Type'Last.

      procedure Init_List (Target : in out List);

      -- Initialize the list. Must be called before other actions.

      procedure Append (Target    : in out List;

                        Node_Data :        Result_Collection_Wrapper);

      -- Append an element at the end of the list.

      --

      -- Raises List_Full if the list has already Count_Type'Last items.

      procedure Clear (Target : in out List);

      -- Remove all elements from the list.

      function First (Target : List) return Cursor;

      -- Return a cursor to the first element of the list.

      function Next (Position : Cursor) return Cursor;

      -- Move the cursor to point to the next element on the list.

      function Data (Position : Cursor) return Result_Collection_Wrapper;

      -- Return element pointed by the cursor.

      function Is_Valid (Position : Cursor) return Boolean;

      -- Tell the validity of the cursor. The cursor

      -- will become invalid when you iterate it over

      -- the last item.

      function Length (Target : List) return Count_Type;

      -- Return the length of the list.

   private

      type Node;

      type Node_Access is access Node;

      type Cursor is new Node_Access;

      procedure Remove (Ptr : Node_Access);

      -- A procedure to release memory pointed by Ptr.

      type Node is record

         Next : Node_Access := null;

         Data : Result_Collection_Wrapper;

      end record;

      type List is limited record

         First : Node_Access := null;

         Last  : Node_Access := null;

         Size  : Count_Type  := 0;

      end record;

   end Result_List;

      Init_Collection (Coll);

      Init_Collection (Coll_Dyn.all);

      Release (Coll);

      Init_Collection (Coll);

      Init_Collection (Coll_Dyn.all);

      Release (Coll);

      Init_Collection (Coll);

      Release (Coll);

      Init_Collection (Coll);

      Release (Coll);

      Init_Collection (Coll);

      Release (Coll);

      Init_Collection (Coll);

      Release (Coll);