| -- CXA5011.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) two objects of type Generator are initialized to the same state. |
| -- 2) when the Function Reset is used to reset two generators |
| -- to different time-dependent states, the resulting random values |
| -- from each generator are different. |
| -- 3) when the Function Reset uses the same integer initiator |
| -- to reset two generators to the same state, the resulting random |
| -- values from each generator are identical. |
| -- 4) when the Function Reset uses different integer initiator |
| -- values to reset two generators, the resulting random numbers are |
| -- different. |
| -- |
| -- TEST DESCRIPTION: |
| -- This test evaluates components of the Ada.Numerics.Float_Random and |
| -- Ada.Numerics.Discrete_Random packages. |
| -- This test checks to see that objects of type Generator are initialized |
| -- to the same state. In addition, the functionality of Function Reset is |
| -- validated. |
| -- For each of the objectives above, evaluation of the various generators |
| -- is performed using each of the following techniques. When the states of |
| -- two generators are to be compared, each state is saved, then |
| -- transformed to a bounded-string variable. The bounded-strings can |
| -- then be compared for equality. In this case, matching bounded-strings |
| -- are evidence that the states of two generators are the same. |
| -- In addition, two generators are compared by evaluating a series of |
| -- random numbers they produce. A matching series of random numbers |
| -- implies that the generators were in the same state prior to producing |
| -- the numbers. |
| -- |
| -- |
| -- CHANGE HISTORY: |
| -- 20 Apr 95 SAIC Initial prerelease version. |
| -- 07 Jul 95 SAIC Incorporated reviewer comments/suggestions. |
| -- 22 Apr 96 SAIC Incorporated reviewer comments for ACVC 2.1. |
| -- 17 Aug 96 SAIC Deleted Subtest #2. |
| -- 09 Feb 01 RLB Repaired to work on implementations with a 16-bit |
| -- Integer. |
| |
| --! |
| |
| with Ada.Exceptions; |
| with Ada.Numerics.Float_Random; |
| with Ada.Numerics.Discrete_Random; |
| with Ada.Strings.Bounded; |
| with ImpDef; |
| with Report; |
| |
| procedure CXA5011 is |
| begin |
| |
| Report.Test ("CXA5011", "Check the effect of Function Reset on the " & |
| "state of random number generators"); |
| |
| Test_Block: |
| declare |
| |
| use Ada.Exceptions; |
| use Ada.Numerics; |
| use Ada.Strings.Bounded; |
| |
| -- Declare an modular subtype, and use it to instantiate the discrete |
| -- random number generator generic package. |
| |
| type Discrete_Range is mod 2**(Integer'Size-1); |
| package Discrete_Package is new Discrete_Random(Discrete_Range); |
| |
| -- Declaration of random number generator objects. |
| |
| Discrete_Generator_1, |
| Discrete_Generator_2 : Discrete_Package.Generator; |
| Float_Generator_1, |
| Float_Generator_2 : Float_Random.Generator; |
| |
| -- Declaration of bounded string packages instantiated with the |
| -- value of Max_Image_Width constant from each random number generator |
| -- package, and bounded string variables used to hold the image of |
| -- random number generator states. |
| |
| package Discrete_String_Pack is |
| new Generic_Bounded_Length(Discrete_Package.Max_Image_Width); |
| |
| package Float_String_Pack is |
| new Generic_Bounded_Length(Float_Random.Max_Image_Width); |
| |
| use Discrete_String_Pack, Float_String_Pack; |
| |
| TC_Seed : Integer; |
| TC_Max_Loop_Count : constant Natural := 1000; |
| Allowed_Matches : constant Natural := 2; |
| -- |
| -- In a sequence of TC_Max_Loop_Count random numbers that should |
| -- not match, some may match by chance. Up to Allowed_Matches |
| -- numbers may match before the test is considered to fail. |
| -- |
| |
| |
| procedure Check_Float_State (Gen_1, Gen_2 : Float_Random.Generator; |
| Sub_Test : Integer; |
| States_Should_Match : Boolean) is |
| |
| use type Float_Random.State; |
| |
| State_1, |
| State_2 : Float_Random.State; |
| |
| State_String_1, |
| State_String_2 : Float_String_Pack.Bounded_String := |
| Float_String_Pack.Null_Bounded_String; |
| begin |
| |
| Float_Random.Save(Gen => Gen_1, To_State => State_1); |
| Float_Random.Save(Gen_2, State_2); |
| |
| State_String_1 := |
| Float_String_Pack.To_Bounded_String(Source => |
| Float_Random.Image(Of_State => State_1)); |
| |
| State_String_2 := |
| Float_String_Pack.To_Bounded_String(Float_Random.Image(State_2)); |
| |
| case States_Should_Match is |
| when True => |
| if State_1 /= State_2 then |
| Report.Failed("Subtest #" & Integer'Image(Sub_Test) & |
| " State values from Float generators " & |
| "are not the same"); |
| end if; |
| if State_String_1 /= State_String_2 then |
| Report.Failed("Subtest #" & Integer'Image(Sub_Test) & |
| " State strings from Float generators " & |
| "are not the same"); |
| end if; |
| when False => |
| if State_1 = State_2 then |
| Report.Failed("Subtest #" & Integer'Image(Sub_Test) & |
| " State values from Float generators " & |
| "are the same"); |
| end if; |
| if State_String_1 = State_String_2 then |
| Report.Failed("Subtest #" & Integer'Image(Sub_Test) & |
| " State strings from Float generators " & |
| "are the same"); |
| end if; |
| end case; |
| end Check_Float_State; |
| |
| |
| |
| procedure Check_Discrete_State (Gen_1, |
| Gen_2 : Discrete_Package.Generator; |
| Sub_Test : Integer; |
| States_Should_Match : Boolean) is |
| |
| use type Discrete_Package.State; |
| |
| State_1, State_2 : Discrete_Package.State; |
| |
| State_String_1, |
| State_String_2 : Discrete_String_Pack.Bounded_String := |
| Discrete_String_Pack.Null_Bounded_String; |
| begin |
| |
| Discrete_Package.Save(Gen => Gen_1, |
| To_State => State_1); |
| Discrete_Package.Save(Gen_2, To_State => State_2); |
| |
| State_String_1 := |
| Discrete_String_Pack.To_Bounded_String(Source => |
| Discrete_Package.Image(Of_State => State_1)); |
| |
| State_String_2 := |
| Discrete_String_Pack.To_Bounded_String(Source => |
| Discrete_Package.Image(Of_State => State_2)); |
| |
| case States_Should_Match is |
| when True => |
| if State_1 /= State_2 then |
| Report.Failed("Subtest #" & Integer'Image(Sub_Test) & |
| " State values from Discrete " & |
| "generators are not the same"); |
| end if; |
| if State_String_1 /= State_String_2 then |
| Report.Failed("Subtest #" & Integer'Image(Sub_Test) & |
| " State strings from Discrete " & |
| "generators are not the same"); |
| end if; |
| when False => |
| if State_1 = State_2 then |
| Report.Failed("Subtest #" & Integer'Image(Sub_Test) & |
| " State values from Discrete " & |
| "generators are the same"); |
| end if; |
| if State_String_1 = State_String_2 then |
| Report.Failed("Subtest #" & Integer'Image(Sub_Test) & |
| " State strings from Discrete " & |
| "generators are the same"); |
| end if; |
| end case; |
| end Check_Discrete_State; |
| |
| |
| |
| procedure Check_Float_Values (Gen_1, Gen_2 : Float_Random.Generator; |
| Sub_Test : Integer; |
| Values_Should_Match : Boolean) is |
| Matches : Natural := 0; |
| Check_Failed : Boolean := False; |
| begin |
| case Values_Should_Match is |
| when True => |
| for i in 1..TC_Max_Loop_Count loop |
| if Float_Random.Random(Gen_1) /= Float_Random.Random(Gen_2) |
| then |
| Check_Failed := True; |
| exit; |
| end if; |
| end loop; |
| if Check_Failed then |
| Report.Failed("Sub_Test # " & Integer'Image(Sub_Test) & |
| " Random numbers from Float generators " & |
| "Failed check"); |
| end if; |
| when False => |
| for i in 1..TC_Max_Loop_Count loop |
| if Float_Random.Random(Gen_1) = Float_Random.Random(Gen_2) |
| then |
| Matches := Matches + 1; |
| end if; |
| end loop; |
| end case; |
| |
| if (Values_Should_Match and Check_Failed) or |
| (not Values_Should_Match and Matches > Allowed_Matches) |
| then |
| Report.Failed("Sub_Test # " & Integer'Image(Sub_Test) & |
| " Random numbers from Float generators " & |
| "Failed check"); |
| end if; |
| |
| end Check_Float_Values; |
| |
| |
| |
| procedure Check_Discrete_Values (Gen_1, |
| Gen_2 : Discrete_Package.Generator; |
| Sub_Test : Integer; |
| Values_Should_Match : Boolean) is |
| Matches : Natural := 0; |
| Check_Failed : Boolean := False; |
| begin |
| case Values_Should_Match is |
| when True => |
| for i in 1..TC_Max_Loop_Count loop |
| if Discrete_Package.Random(Gen_1) /= |
| Discrete_Package.Random(Gen_2) |
| then |
| Check_Failed := True; |
| exit; |
| end if; |
| end loop; |
| when False => |
| for i in 1..TC_Max_Loop_Count loop |
| if Discrete_Package.Random(Gen_1) = |
| Discrete_Package.Random(Gen_2) |
| then |
| Matches := Matches + 1; |
| end if; |
| end loop; |
| end case; |
| |
| if (Values_Should_Match and Check_Failed) or |
| (not Values_Should_Match and Matches > Allowed_Matches) |
| then |
| Report.Failed("Sub_Test # " & Integer'Image(Sub_Test) & |
| " Random numbers from Discrete generators " & |
| "Failed check"); |
| end if; |
| |
| end Check_Discrete_Values; |
| |
| |
| |
| begin |
| |
| Sub_Test_1: |
| -- Check that two objects of type Generator are initialized to the |
| -- same state. |
| begin |
| |
| -- Since the discrete and float random generators are in the initial |
| -- state, using Procedure Save to save the states of the generator |
| -- objects, and transforming these states into strings using |
| -- Function Image, should yield identical strings. |
| |
| Check_Discrete_State (Discrete_Generator_1, |
| Discrete_Generator_2, |
| Sub_Test => 1, |
| States_Should_Match => True); |
| |
| Check_Float_State (Float_Generator_1, |
| Float_Generator_2, |
| Sub_Test => 1, |
| States_Should_Match => True); |
| |
| -- Since the two random generator objects are in their initial |
| -- state, the values produced from each (upon calls to Random) |
| -- should be identical. |
| |
| Check_Discrete_Values (Discrete_Generator_1, |
| Discrete_Generator_2, |
| Sub_Test => 1, |
| Values_Should_Match => True); |
| |
| Check_Float_Values (Float_Generator_1, |
| Float_Generator_2, |
| Sub_Test => 1, |
| Values_Should_Match => True); |
| |
| end Sub_Test_1; |
| |
| |
| |
| Sub_Test_3: |
| -- Check that when the Function Reset uses the same integer |
| -- initiator to reset two generators to the same state, the |
| -- resulting random values and the state from each generator |
| -- are identical. |
| declare |
| use Discrete_Package, Float_Random; |
| begin |
| |
| -- Reset the generators to the same states, using the version of |
| -- Function Reset with both generator parameter and initiator |
| -- specified. |
| |
| TC_Seed := Integer(Random(Discrete_Generator_1)); |
| Reset(Gen => Discrete_Generator_1, Initiator => TC_Seed); |
| Reset(Discrete_Generator_2, Initiator => TC_Seed); |
| Reset(Float_Generator_1, TC_Seed); |
| Reset(Float_Generator_2, TC_Seed); |
| |
| -- Since the random generators have been reset to identical states, |
| -- bounded string images of these states should yield identical |
| -- strings. |
| |
| Check_Discrete_State (Discrete_Generator_1, |
| Discrete_Generator_2, |
| Sub_Test => 3, |
| States_Should_Match => True); |
| |
| Check_Float_State (Float_Generator_1, |
| Float_Generator_2, |
| Sub_Test => 3, |
| States_Should_Match => True); |
| |
| -- Since the random generators have been reset to identical states, |
| -- the values produced from each (upon calls to Random) should |
| -- be identical. |
| |
| Check_Discrete_Values (Discrete_Generator_1, |
| Discrete_Generator_2, |
| Sub_Test => 3, |
| Values_Should_Match => True); |
| |
| Check_Float_Values (Float_Generator_1, |
| Float_Generator_2, |
| Sub_Test => 3, |
| Values_Should_Match => True); |
| |
| end Sub_Test_3; |
| |
| |
| |
| Sub_Test_4: |
| -- Check that when the Function Reset uses different integer |
| -- initiator values to reset two generators, the resulting random |
| -- numbers and states are different. |
| begin |
| |
| -- Reset the generators to different states. |
| |
| TC_Seed := |
| Integer(Discrete_Package.Random(Discrete_Generator_1)); |
| |
| Discrete_Package.Reset(Gen => Discrete_Generator_1, |
| Initiator => TC_Seed); |
| |
| -- Set the seed value to a different value for the second call |
| -- to Reset. |
| -- Note: A second call to Random could be made, as above, but that |
| -- would not ensure that the resulting seed value was |
| -- different from the first. |
| |
| if TC_Seed /= Integer'Last then |
| TC_Seed := TC_Seed + 1; |
| else |
| TC_Seed := TC_Seed - 1; |
| end if; |
| |
| Discrete_Package.Reset(Gen => Discrete_Generator_2, |
| Initiator => TC_Seed); |
| |
| Float_Random.Reset(Float_Generator_1, 16#FF#); -- 255 |
| Float_Random.Reset(Float_Generator_2, 2#1110_0000#); -- 224 |
| |
| -- Since the two float random generators are in different |
| -- states, the bounded string images depicting their states should |
| -- differ. |
| |
| Check_Discrete_State (Discrete_Generator_1, |
| Discrete_Generator_2, |
| Sub_Test => 4, |
| States_Should_Match => False); |
| |
| Check_Float_State (Float_Generator_1, |
| Float_Generator_2, |
| Sub_Test => 4, |
| States_Should_Match => False); |
| |
| -- Since the two discrete random generator objects were reset |
| -- to different states, the values produced from each (upon calls |
| -- to Random) should differ. |
| |
| Check_Discrete_Values (Discrete_Generator_1, |
| Discrete_Generator_2, |
| Sub_Test => 4, |
| Values_Should_Match => False); |
| |
| Check_Float_Values (Float_Generator_1, |
| Float_Generator_2, |
| Sub_Test => 4, |
| Values_Should_Match => False); |
| |
| end Sub_Test_4; |
| |
| exception |
| when The_Error : others => |
| Report.Failed ("The following exception was raised in the " & |
| "Test_Block: " & Exception_Name(The_Error)); |
| end Test_Block; |
| |
| Report.Result; |
| |
| end CXA5011; |
