-- CXA5012.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.
--*
--
-- OBJECTIVE:
--      Check that, for both Float_Random and Discrete_Random packages,
--      the following are true:
--      1) the procedures Save and Reset can be used to save the
--         specific state of a random number generator, and then restore
--         the specific state to the generator following some intermediate
--         generator activity.
--      2) the Function Image can be used to obtain a string
--         representation of the state of a generator; and that the
--         Function Value will transform a string representation of the
--         state of a random number generator into the actual state object.
--      3) a call to Function Value, with a string value that is
--         not the image of any generator state, is a bounded error. This
--         error either raises Constraint_Error or Program_Error, or is
--         accepted. (See Technical Corrigendum 1).
--
-- TEST DESCRIPTION:
--      This test evaluates components of the Ada.Numerics.Float_Random and
--      Ada.Numerics.Discrete_Random packages.
--      The first objective block of this test uses Procedure Save to
--      save the particular state of a random number generator.  The random
--      number generator then generates a series of random numbers.  The
--      saved state variable is then used to reset (using Procedure Reset)
--      the generator back to the state it was in at the point of the call
--      to Save.  Random values are then generated from this restored
--      generator, and compared with expected values.
--      The second objective block of this test uses Function Image to
--      provide a string representation of a state code.  This string is
--      then transformed back to a state code value, and used to reset a
--      random number generator to the saved state.  Random values are
--      likewise generated from this restored generator, and compared with
--      expected values.
--
--
-- CHANGE HISTORY:
--      25 Apr 95   SAIC    Initial prerelease version.
--      17 Jul 95   SAIC    Incorporated reviewer comments.
--      17 Dec 97   EDS     Change subtype upper limit from 100_000 to 10_000.
--      16 Sep 99   RLB     Updated objective 3 for Technical Corrigendum 1
--                          changes.

--!

with Ada.Numerics.Float_Random;
with Ada.Numerics.Discrete_Random;
with Ada.Strings.Bounded;
with ImpDef;
with Report;

procedure CXA5012 is

begin

   Report.Test ("CXA5012", "Check the effect of Procedures Save and " &
                           "Reset, and Functions Image and Value "    &
                           "from the Ada.Numerics.Discrete_Random "   &
                           "and Float_Random packages");

   Test_Block:
   declare

      use Ada.Numerics, Ada.Strings.Bounded;

      -- Declare an integer subtype and an enumeration subtype, and use them
      -- to instantiate the discrete random number generator generic package.

      subtype Discrete_Range is Integer range 1..10_000;
      type    Suit_Of_Cards  is (Ace, One, Two, Three, Four, Five, Six,
                                 Seven, Eight, Nine, Ten, Jack, Queen, King);
      package Discrete_Pack is new Discrete_Random(Discrete_Range);
      package Card_Pack     is new Discrete_Random(Suit_Of_Cards);

      -- Declaration of random number generator objects.

      DGen_1, DGen_2 : Discrete_Pack.Generator;
      EGen_1, EGen_2 : Card_Pack.Generator;
      FGen_1, FGen_2 : Float_Random.Generator;

      -- Variables declared to hold random numbers over the inclusive range
      -- of their corresponding type.

      DVal_1, DVal_2 : Discrete_Range;
      EVal_1, EVal_2 : Suit_Of_Cards;
      FVal_1, FVal_2 : Float_Random.Uniformly_Distributed;

      -- Declaration of State variables used to hold the state of the
      -- random number generators.

      DState_1, DState_2 : Discrete_Pack.State;
      EState_1, EState_2 : Card_Pack.State;
      FState_1, FState_2 : Float_Random.State;

      -- Declaration of bounded string packages instantiated with the
      -- value of Max_Image_Width constant, and bounded string variables
      -- used to hold the image of random number generator states.

      package DString_Pack is
        new Generic_Bounded_Length(Discrete_Pack.Max_Image_Width);
      package EString_Pack is
        new Generic_Bounded_Length(Card_Pack.Max_Image_Width);
      package FString_Pack is
        new Generic_Bounded_Length(Float_Random.Max_Image_Width);

      use DString_Pack, EString_Pack, FString_Pack;

      DString_1, DString_2 : DString_Pack.Bounded_String :=
                               DString_Pack.Null_Bounded_String;
      EString_1, EString_2 : EString_Pack.Bounded_String :=
                               EString_Pack.Null_Bounded_String;
      FString_1, FString_2 : FString_Pack.Bounded_String :=
                               FString_Pack.Null_Bounded_String;

      -- Test variables.

      TC_Count                  : Natural;
      TC_Discrete_Check_Failed,
      TC_Enum_Check_Failed,
      TC_Float_Check_Failed     : Boolean := False;
      TC_Seed                   : Integer;

   begin

      Objective_1:
         -- Check that the procedures Save and Reset can be used to save the
         -- specific state of a random number generator, and then restore the
         -- specific state to the generator following some intermediate
         -- generator activity.
      declare

         First_Row     : constant :=   1;
         Second_Row    : constant :=   2;
         TC_Max_Values : constant := 100;

         TC_Discrete_Array : array (First_Row..Second_Row, 1..TC_Max_Values)
                               of Discrete_Range;
         TC_Enum_Array     : array (First_Row..Second_Row, 1..TC_Max_Values)
                               of Suit_Of_Cards;
         TC_Float_Array    : array (First_Row..Second_Row, 1..TC_Max_Values)
                               of Float_Random.Uniformly_Distributed;
      begin

         -- The state of the random number generators are saved to state
         -- variables using the procedure Save.

         Discrete_Pack.Save(Gen => DGen_1, To_State => DState_1);
         Card_Pack.Save    (Gen => EGen_1, To_State => EState_1);
         Float_Random.Save (Gen => FGen_1, To_State => FState_1);

         -- Random number generators are used to fill the first half of the
         -- first row of the arrays with randomly generated values.

         for i in 1..TC_Max_Values/2 loop
            TC_Discrete_Array(First_Row, i) := Discrete_Pack.Random(DGen_1);
            TC_Enum_Array(First_Row, i)     := Card_Pack.Random(EGen_1);
            TC_Float_Array(First_Row, i)    := Float_Random.Random(FGen_1);
         end loop;

         -- The random number generators are reset to the states saved in the
         -- state variables, using the procedure Reset.

         Discrete_Pack.Reset(Gen => DGen_1, From_State => DState_1);
         Card_Pack.Reset    (Gen => EGen_1, From_State => EState_1);
         Float_Random.Reset (Gen => FGen_1, From_State => FState_1);

         -- The same random number generators are used to fill the first half
         -- of the second row of the arrays with randomly generated values.

         for i in 1..TC_Max_Values/2 loop
            TC_Discrete_Array(Second_Row, i) := Discrete_Pack.Random(DGen_1);
            TC_Enum_Array(Second_Row, i)     := Card_Pack.Random(EGen_1);
            TC_Float_Array(Second_Row, i)    := Float_Random.Random(FGen_1);
         end loop;

         -- Run the random number generators many times (not using results).

         for i in Discrete_Range'Range loop
             DVal_1 := Discrete_Pack.Random(DGen_1);
             EVal_1 := Card_Pack.Random(EGen_1);
             FVal_1 := Float_Random.Random(FGen_1);
         end loop;

         -- The states of the random number generators are saved to state
         -- variables using the procedure Save.

         Discrete_Pack.Save(Gen => DGen_1, To_State => DState_1);
         Card_Pack.Save(Gen => EGen_1, To_State => EState_1);
         Float_Random.Save (Gen => FGen_1, To_State => FState_1);

         -- The last half of the first row of the arrays are filled with
         -- values generated from the same random number generators.

         for i in (TC_Max_Values/2 + 1)..TC_Max_Values loop
            TC_Discrete_Array(First_Row, i) := Discrete_Pack.Random(DGen_1);
            TC_Enum_Array(First_Row, i)     := Card_Pack.Random(EGen_1);
            TC_Float_Array(First_Row, i)    := Float_Random.Random(FGen_1);
         end loop;

         -- The random number generators are reset to the states saved in the
         -- state variables, using the procedure Reset.

         Discrete_Pack.Reset(Gen => DGen_1, From_State => DState_1);
         Card_Pack.Reset(Gen => EGen_1, From_State => EState_1);
         Float_Random.Reset (Gen => FGen_1, From_State => FState_1);

         -- The last half of the second row of the arrays are filled with
         -- values generated from the same random number generator.
         -- These values should exactly mirror the values in the last half
         -- of the first row of the arrays that had been previously generated.

         for i in (TC_Max_Values/2 + 1)..TC_Max_Values loop
            TC_Discrete_Array(Second_Row, i) := Discrete_Pack.Random(DGen_1);
            TC_Enum_Array(Second_Row, i)     := Card_Pack.Random(EGen_1);
            TC_Float_Array(Second_Row, i)    := Float_Random.Random(FGen_1);
         end loop;

         -- Check that the values in the two rows of the arrays are identical.

         for i in 1..TC_Max_Values loop
            if TC_Discrete_Array(First_Row,i) /=
               TC_Discrete_Array(Second_Row,i)
            then
               TC_Discrete_Check_Failed := True;
               exit;
            end if;
         end loop;

         for i in 1..TC_Max_Values loop
            if TC_Enum_Array(First_Row,i) /= TC_Enum_Array(Second_Row,i) then
               TC_Enum_Check_Failed := True;
               exit;
            end if;
         end loop;

         for i in 1..TC_Max_Values loop
            if TC_Float_Array(First_Row,i) /= TC_Float_Array(Second_Row,i)
            then
               TC_Float_Check_Failed := True;
               exit;
            end if;
         end loop;

         if TC_Discrete_Check_Failed then
            Report.Failed("Discrete random values generated following use " &
                          "of procedures Save and Reset were not the same");
            TC_Discrete_Check_Failed := False;
         end if;

         if TC_Enum_Check_Failed then
            Report.Failed("Enumeration random values generated following " &
                          "use of procedures Save and Reset were not the " &
                          "same");
            TC_Enum_Check_Failed := False;
         end if;

         if TC_Float_Check_Failed then
            Report.Failed("Float random values generated following use " &
                          "of procedures Save and Reset were not the same");
            TC_Float_Check_Failed := False;
         end if;

      end Objective_1;


      Objective_2:
         -- Check that the Function Image can be used to obtain a string
         -- representation of the state of a generator.
         -- Check that the Function Value will transform a string
         -- representation of the state of a random number generator
         -- into the actual state object.
      begin

         -- Use two discrete and float random number generators to generate
         -- a series of values (so that the generators are no longer in their
         -- initial states, and they have generated the same number of
         -- random values).

         TC_Seed := Integer(Discrete_Pack.Random(DGen_1));
         Discrete_Pack.Reset(DGen_1, TC_Seed);
         Discrete_Pack.Reset(DGen_2, TC_Seed);
         Card_Pack.Reset    (EGen_1, TC_Seed);
         Card_Pack.Reset    (EGen_2, TC_Seed);
         Float_Random.Reset (FGen_1,  TC_Seed);
         Float_Random.Reset (FGen_2,  TC_Seed);

         for i in 1..1000 loop
            DVal_1 := Discrete_Pack.Random(DGen_1);
            DVal_2 := Discrete_Pack.Random(DGen_2);
            EVal_1 := Card_Pack.Random(EGen_1);
            EVal_2 := Card_Pack.Random(EGen_2);
            FVal_1 := Float_Random.Random(FGen_1);
            FVal_2 := Float_Random.Random(FGen_2);
         end loop;

         -- Use the Procedure Save to save the states of the generators
         -- to state variables.

         Discrete_Pack.Save(Gen => DGen_1, To_State => DState_1);
         Discrete_Pack.Save(DGen_2, To_State => DState_2);
         Card_Pack.Save    (Gen => EGen_1, To_State => EState_1);
         Card_Pack.Save    (EGen_2, To_State => EState_2);
         Float_Random.Save (FGen_1, To_State => FState_1);
         Float_Random.Save (FGen_2, FState_2);

         -- Use the Function Image to produce a representation of the state
         -- codes as (bounded) string objects.

         DString_1 := DString_Pack.To_Bounded_String(
                        Discrete_Pack.Image(Of_State => DState_1));
         DString_2 := DString_Pack.To_Bounded_String(
                        Discrete_Pack.Image(DState_2));
         EString_1 := EString_Pack.To_Bounded_String(
                        Card_Pack.Image(Of_State => EState_1));
         EString_2 := EString_Pack.To_Bounded_String(
                        Card_Pack.Image(EState_2));
         FString_1 := FString_Pack.To_Bounded_String(
                        Float_Random.Image(Of_State => FState_1));
         FString_2 := FString_Pack.To_Bounded_String(
                        Float_Random.Image(FState_2));

         -- Compare the bounded string objects for equality.

         if DString_1 /= DString_2 then
            Report.Failed("String values returned from Function Image " &
                          "depict different states of Discrete generators");
         end if;
         if EString_1 /= EString_2 then
            Report.Failed("String values returned from Function Image " &
                          "depict different states of Enumeration "     &
                          "generators");
         end if;
         if FString_1 /= FString_2 then
            Report.Failed("String values returned from Function Image " &
                          "depict different states of Float generators");
         end if;

         -- The string representation of a state code is transformed back
         -- to a state code variable using the Function Value.

         DState_1 := Discrete_Pack.Value(Coded_State =>
                                          DString_Pack.To_String(DString_1));
         EState_1 := Card_Pack.Value(EString_Pack.To_String(EString_1));
         FState_1 := Float_Random.Value(FString_Pack.To_String(FString_1));

         -- One of the (pair of each type of ) generators is used to generate
         -- a series of random values, getting them "out of synch" with the
         -- specific generation sequence of the other generators.

         for i in 1..100 loop
            DVal_1 := Discrete_Pack.Random(DGen_1);
            EVal_1 := Card_Pack.Random(EGen_1);
            FVal_1 := Float_Random.Random (FGen_1);
         end loop;

         -- The "out of synch" generators are reset to the previous state they
         -- had when their states were saved, and they should now have the same
         -- states as the generators that did not generate the values above.

         Discrete_Pack.Reset(Gen => DGen_1, From_State => DState_1);
         Card_Pack.Reset    (Gen => EGen_1, From_State => EState_1);
         Float_Random.Reset (Gen => FGen_1, From_State => FState_1);

         -- All generators should now be in the same state, so the
         -- random values they produce should be the same.

         for i in 1..1000 loop
            if Discrete_Pack.Random(DGen_1) /= Discrete_Pack.Random(DGen_2)
            then
               TC_Discrete_Check_Failed := True;
               exit;
            end if;
         end loop;

         for i in 1..1000 loop
            if Card_Pack.Random(EGen_1) /= Card_Pack.Random(EGen_2) then
               TC_Enum_Check_Failed := True;
               exit;
            end if;
         end loop;

         for i in 1..1000 loop
            if Float_Random.Random(FGen_1) /= Float_Random.Random(FGen_2)
            then
               TC_Float_Check_Failed := True;
               exit;
            end if;
         end loop;

         if TC_Discrete_Check_Failed then
            Report.Failed("Random values generated following use of "     &
                          "procedures Image and Value were not the same " &
                          "for Discrete generator");
         end if;
         if TC_Enum_Check_Failed then
            Report.Failed("Random values generated following use of "     &
                          "procedures Image and Value were not the same " &
                          "for Enumeration generator");
         end if;
         if TC_Float_Check_Failed then
            Report.Failed("Random values generated following use of "     &
                          "procedures Image and Value were not the same " &
                          "for Float generator");
         end if;

      end Objective_2;


      Objective_3:
         -- Check that a call to Function Value, with a string value that is
         -- not the image of any generator state, is a bounded error. This
         -- error either raises Constraint_Error or Program_Error, or is
         -- accepted. (See Technical Corrigendum 1).
      declare
         Not_A_State : constant String := ImpDef.Non_State_String;
      begin

         begin
            DState_1 := Discrete_Pack.Value(Not_A_State);
            if Not_A_State /= "**NONE**" then
               Report.Failed("Exception not raised by Function " &
                             "Ada.Numerics.Discrete_Random.Value when " &
                             "provided a string input that does not "   &
                             "represent the state of a random number "  &
                             "generator");
            else
               Report.Comment("All strings represent states for Function " &
                             "Ada.Numerics.Discrete_Random.Value");
            end if;
            Discrete_Pack.Reset(DGen_1, DState_1);
         exception
            when Constraint_Error => null;  -- OK, expected exception.
               Report.Comment("Constraint_Error raised by Function " &
                             "Ada.Numerics.Discrete_Random.Value when " &
                             "provided a string input that does not "   &
                             "represent the state of a random number "  &
                             "generator");
            when Program_Error => -- OK, expected exception.
               Report.Comment("Program_Error raised by Function " &
                             "Ada.Numerics.Discrete_Random.Value when " &
                             "provided a string input that does not "   &
                             "represent the state of a random number "  &
                             "generator");
            when others =>
               Report.Failed("Unexpected exception raised by Function " &
                             "Ada.Numerics.Discrete_Random.Value when " &
                             "provided a string input that does not "   &
                             "represent the state of a random number "  &
                             "generator");
         end;

         begin
            EState_1 := Card_Pack.Value(Not_A_State);
            if Not_A_State /= "**NONE**" then
               Report.Failed("Exception not raised by Function " &
                             "Ada.Numerics.Discrete_Random.Value when " &
                             "provided a string input that does not "   &
                             "represent the state of an enumeration "   &
                             "random number generator");
            else
               Report.Comment("All strings represent states for Function " &
                             "Ada.Numerics.Discrete_Random.Value");
            end if;
            Card_Pack.Reset(EGen_1, EState_1);
         exception
            when Constraint_Error => null;  -- OK, expected exception.
            when Program_Error => null; -- OK, expected exception.
            when others =>
               Report.Failed("Unexpected exception raised by Function " &
                             "Ada.Numerics.Discrete_Random.Value when " &
                             "provided a string input that does not "   &
                             "represent the state of an enumeration "   &
                             "random number generator");
         end;

         begin
            FState_1 := Float_Random.Value(Not_A_State);
            if Not_A_State /= "**NONE**" then
               Report.Failed("Exception not raised by an "      &
                             "instantiated version of "                &
                             "Ada.Numerics.Float_Random.Value when "   &
                             "provided a string input that does not "  &
                             "represent the state of a random number " &
                             "generator");
            else
               Report.Comment("All strings represent states for Function " &
                             "Ada.Numerics.Float_Random.Value");
            end if;
            Float_Random.Reset(FGen_1, FState_1);
         exception
            when Constraint_Error => null;  -- OK, expected exception.
            when Program_Error => null; -- OK, expected exception.
            when others =>
               Report.Failed("Unexpected exception raised by an "      &
                             "instantiated version of "                &
                             "Ada.Numerics.Float_Random.Value when "   &
                             "provided a string input that does not "  &
                             "represent the state of a random number " &
                             "generator");
         end;

      end Objective_3;


   exception
      when others => Report.Failed ("Exception raised in Test_Block");
   end Test_Block;

   Report.Result;

end CXA5012;