Subversion Repositories openrisc

-- C980003.A

--

--                             Grant of Unlimited Rights

--

--     Under contracts F33600-87-D-0337, F33600-84-D-0280, MDA903-79-C-0687,

--     F08630-91-C-0015, and DCA100-97-D-0025, the U.S. Government obtained

--     unlimited rights in the software and documentation contained herein.

--     Unlimited rights are defined in DFAR 252.227-7013(a)(19).  By making

--     this public release, the Government intends to confer upon all

--     recipients unlimited rights  equal to those held by the Government.

--     These rights include rights to use, duplicate, release or disclose the

--     released technical data and computer software in whole or in part, in

--     any manner and for any purpose whatsoever, and to have or permit others

--     to do so.

--

--                                    DISCLAIMER

--

--     ALL MATERIALS OR INFORMATION HEREIN RELEASED, MADE AVAILABLE OR

--     DISCLOSED ARE AS IS.  THE GOVERNMENT MAKES NO EXPRESS OR IMPLIED

--     WARRANTY AS TO ANY MATTER WHATSOEVER, INCLUDING THE CONDITIONS OF THE

--     SOFTWARE, DOCUMENTATION OR OTHER INFORMATION RELEASED, MADE AVAILABLE

--     OR DISCLOSED, OR THE OWNERSHIP, MERCHANTABILITY, OR FITNESS FOR A

--     PARTICULAR PURPOSE OF SAID MATERIAL.

--*

--

-- TEST OBJECTIVE:

--      Check that aborts are deferred during the execution of an

--      Initialize procedure (as the last step of the default

--      initialization of a controlled object), during the execution

--      of a Finalize procedure (as part of the finalization of a

--      controlled object), and during an assignment operation to an

--      object with a controlled part.

--

-- TEST DESCRIPTION:

--      A controlled type is created with Initialize, Adjust, and

--      Finalize operations.  These operations note in a protected

--      object when the operation starts and completes.  This change

--      in state of the protected object will open the barrier for

--      the entry in the protected object.

--      The test contains declarations of objects of the controlled

--      type.  An asynchronous select is used to attempt to abort

--      the operations on the controlled type.  The asynchronous select

--      makes use of the state change to the protected object to

--      trigger the abort.

--

--

-- CHANGE HISTORY:

--      11 Jan 96   SAIC    Initial Release for 2.1

--       5 May 96   SAIC    Incorporated Reviewer comments.

--      10 Oct 96   SAIC    Addressed issue where assignment statement

--                          can be 2 assignment operations.

--

--!

with Ada.Finalization;

package C980003_0 is

    Verbose : constant Boolean := False;

    -- the following flag is set true whenever the

    -- Initialize operation is called.

    Init_Occurred : Boolean;

    type Is_Controlled is new Ada.Finalization.Controlled with

         record

             Id : Integer;

         end record;

     procedure Initialize (Object : in out Is_Controlled);

     procedure Finalize   (Object : in out Is_Controlled);

     procedure Adjust     (Object : in out Is_Controlled);

     type States is (Unknown,

                     Start_Init,   Finished_Init,

                     Start_Adjust, Finished_Adjust,

                     Start_Final,  Finished_Final);

     protected State_Manager is

        procedure Reset;

        procedure Set (New_State : States);

        function Current return States;

        entry Wait_For_Change;

     private

        Current_State : States := Unknown;

        Changed : Boolean := False;

     end State_Manager;

end C980003_0;

with Report;

with ImpDef;

package body C980003_0 is

     protected body State_Manager is

         procedure Reset is

         begin

             Current_State := Unknown;

             Changed := False;

         end Reset;

         procedure Set (New_State : States) is

         begin

             Changed := True;

             Current_State := New_State;

         end Set;

         function Current return States is

         begin

             return Current_State;

         end Current;

         entry Wait_For_Change when Changed is

         begin

             Changed := False;

         end Wait_For_Change;

     end State_Manager;

     procedure Initialize (Object : in out Is_Controlled) is

     begin

        if Verbose then

            Report.Comment ("starting initialize");

        end if;

        State_Manager.Set (Start_Init);

        if Verbose then

            Report.Comment ("in initialize");

        end if;

        delay ImpDef.Switch_To_New_Task;  -- tempting place for abort

        State_Manager.Set (Finished_Init);

        if Verbose then

            Report.Comment ("finished initialize");

        end if;

        Init_Occurred := True;

     end Initialize;

     procedure Finalize   (Object : in out Is_Controlled) is

     begin

        if Verbose then

            Report.Comment ("starting finalize");

        end if;

        State_Manager.Set (Start_Final);

        if Verbose then

            Report.Comment ("in finalize");

        end if;

        delay ImpDef.Switch_To_New_Task; -- tempting place for abort

        State_Manager.Set (Finished_Final);

        if Verbose then

            Report.Comment ("finished finalize");

        end if;

     end Finalize;

     procedure Adjust     (Object : in out Is_Controlled) is

     begin

        if Verbose then

            Report.Comment ("starting adjust");

        end if;

        State_Manager.Set (Start_Adjust);

        if Verbose then

            Report.Comment ("in adjust");

        end if;

        delay ImpDef.Switch_To_New_Task; -- tempting place for abort

        State_Manager.Set (Finished_Adjust);

        if Verbose then

            Report.Comment ("finished adjust");

        end if;

     end Adjust;

end C980003_0;

with Report;

with ImpDef;

with C980003_0;  use C980003_0;

with Ada.Unchecked_Deallocation;

procedure C980003 is

    procedure Check_State (Should_Be : States;

                           Msg       : String) is

        Cur : States := State_Manager.Current;

    begin

        if Cur /= Should_Be then

            Report.Failed (Msg);

            Report.Comment ("expected: " & States'Image (Should_Be) &

                            "  found: " & States'Image (Cur));

        elsif Verbose then

            Report.Comment ("passed: " & Msg);

        end if;

    end Check_State;

begin

    Report.Test ("C980003", "Check that aborts are deferred during" &

                            " initialization, finalization, and assignment" &

                            " operations on controlled objects");

    Check_State (Unknown, "initial condition");

    -- check that initialization and finalization take place

    Init_Occurred := False;

    select

        State_Manager.Wait_For_Change;

    then abort

        declare

            My_Controlled_Obj : Is_Controlled;

        begin

            delay 0.0;   -- abort completion point

            Report.Failed ("state change did not occur");

        end;

    end select;

    if not Init_Occurred then

        Report.Failed ("Initialize did not complete");

    end if;

    Check_State (Finished_Final, "init/final for declared item");

    -- check adjust

    State_Manager.Reset;

    declare

        Source, Dest : Is_Controlled;

    begin

        Check_State (Finished_Init, "adjust initial state");

        Source.Id := 3;

        Dest.Id := 4;

        State_Manager.Reset;  -- so we will wait for change

        select

            State_Manager.Wait_For_Change;

        then abort

            Dest := Source;

        end select;

        -- there are two implementation methods for the

        -- assignment statement:

        --   1.  no temporary was used in the assignment statement

        --        thus the entire

        --        assignment statement is abort deferred.

        --   2.  a temporary was used in the assignment statement so

        --        there are two assignment operations.  An abort may

        --        occur between the assignment operations

        -- Various optimizations are allowed by 7.6 that can affect

        -- how many times Adjust and Finalize are called.

        -- Depending upon the implementation, the state can be either

        -- Finished_Adjust or Finished_Finalize.   If it is any other

        -- state then the abort took place at the wrong time.

        case State_Manager.Current is

        when Finished_Adjust =>

            if Verbose then

                Report.Comment ("assignment aborted after adjust");

            end if;

        when Finished_Final =>

            if Verbose then

                Report.Comment ("assignment aborted after finalize");

            end if;

        when Start_Adjust =>

            Report.Failed ("assignment aborted in adjust");

        when Start_Final =>

            Report.Failed ("assignment aborted in finalize");

        when Start_Init =>

            Report.Failed ("assignment aborted in initialize");

        when Finished_Init =>

            Report.Failed ("assignment aborted after initialize");

        when Unknown =>

            Report.Failed ("assignment aborted in unknown state");

        end case;

        if Dest.Id /= 3 then

            if Verbose then

                Report.Comment ("assignment not performed");

            end if;

        end if;

    end;

     -- check dynamically allocated objects

    State_Manager.Reset;

    declare

        type Pointer_Type is access Is_Controlled;

        procedure Free is new Ada.Unchecked_Deallocation (

              Is_Controlled, Pointer_Type);

        Ptr : Pointer_Type;

    begin

      -- make sure initialize is done when object is allocated

      Ptr := new Is_Controlled;

      Check_State (Finished_Init, "init when item allocated");

      -- now try aborting the finalize

      State_Manager.Reset;

      select

             State_Manager.Wait_For_Change;

      then abort

             Free (Ptr);

      end select;

      Check_State (Finished_Final, "finalization in dealloc");

    end;

    Report.Result;

end C980003;