-- CXF1001.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 values of 2 and 10 are allowable values for Machine_Radix 
--      of a decimal first subtype.
--      Check that the value of Decimal.Max_Decimal_Digits is at least 18; 
--      the value of Decimal.Max_Scale is at least 18; the value of 
--      Decimal.Min_Scale is at most 0.
--
-- TEST DESCRIPTION:
--      This test examines the Machine_Radix attribute definition clause
--      and its effect on Decimal fixed point types, as well as several
--      constants from the package Ada.Decimal.
--      The first subtest checks that the Machine_Radix attribute will 
--      return the value set for Machine_Radix by an attribute definition
--      clause.  The second and third subtests examine differences between
--      the binary and decimal scaling of a type, based on the radix 
--      representation.  The final subtest examines the values
--      assigned to constants Min_Scale, Max_Scale, and Max_Decimal_Digits,
--      found in the package Ada.Decimal.
--
--       
-- CHANGE HISTORY:
--      06 Dec 94   SAIC    ACVC 2.0
--      29 Dec 94   SAIC    Restructured Radix 10 and Radix 2 test blocks.
--
--!

with Report;
with Ada.Decimal;

procedure CXF1001 is
begin

   Report.Test ("CXF1001", "Check that values of 2 and 10 are allowable " &
                           "values for Machine_Radix of a decimal first " &
                           "subtype.  Check that the value of "           &
                           "Decimal.Max_Decimal_Digits is at least 18; "  &
                           "the value of Decimal.Max_Scale is at least "  &
                           "18; the value of Decimal.Min_Scale is at "    &
                           "most 0");

   Attribute_Check_Block:
   declare

      Del          : constant := 1.0/10**2;
      Const_Digits : constant :=  3;
      Two          : constant :=  2;
      Ten          : constant := 10;

      type Radix_2_Type_1  is delta 0.01  digits 7;
      type Radix_2_Type_2  is delta Ada.Decimal.Min_Delta digits 10;        
      type Radix_2_Type_3  is
        delta 0.000_1 digits Ada.Decimal.Max_Decimal_Digits;

      type Radix_10_Type_1 is delta 10.0**(-Ada.Decimal.Max_Scale) digits 8;
      type Radix_10_Type_2 is delta 10.0**(-Ada.Decimal.Min_Scale) digits 6;
      type Radix_10_Type_3 is delta Ada.Decimal.Max_Delta digits 15;        
        

      -- Use an attribute definition clause to set the Machine_Radix for a
      -- decimal first subtype to either 2 or 10.
      for Radix_2_Type_1'Machine_Radix  use 2;                      
      for Radix_2_Type_2'Machine_Radix  use Two;                    
      for Radix_2_Type_3'Machine_Radix  use 10-8;                   

      for Radix_10_Type_1'Machine_Radix use 2*15/Const_Digits;     
      for Radix_10_Type_2'Machine_Radix use Ten;                             
      for Radix_10_Type_3'Machine_Radix use Radix_10_Type_2'Machine_Radix;


   begin

      -- Check that the attribute 'Machine_Radix returns the value assigned
      -- by the attribute definition clause.

      if Radix_2_Type_1'Machine_Radix /= 2  or else
         Radix_2_Type_2'Machine_Radix /= 2  or else
         Radix_2_Type_3'Machine_Radix /= 2  
      then
         Report.Failed("Incorrect radix value returned, 2 expected");
      end if;

      if Radix_10_Type_1'Machine_Radix /= 10  or else
         Radix_10_Type_2'Machine_Radix /= 10  or else
         Radix_10_Type_3'Machine_Radix /= 10  
      then
         Report.Failed("Incorrect radix value returned, 10 expected");
      end if;

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



   Radix_Block:
   -- Premises:
   --   1) Choose several numbers, from types using either decimal scaling or
   --      binary scaling.
   --   1) Repetitively add these numbers to themselves.
   --   3) Validate that the result is the expected result, regardless of the
   --      scaling used in the definition of the type.
   declare

      Number_Of_Values : constant :=    3;
      Loop_Count       : constant := 1000;

      type Radix_2_Type  is delta 0.0001 digits 10;
      type Radix_10_Type is delta 0.0001 digits 10;
                                      
      for Radix_2_Type'Machine_Radix  use  2;
      for Radix_10_Type'Machine_Radix use 10;

      type Result_Record_Type is record
         Rad_2  : Radix_2_Type;
         Rad_10 : Radix_10_Type;
      end record;

      type Result_Array_Type is array (1..Number_Of_Values) 
        of Result_Record_Type;

      Result_Array : Result_Array_Type := ((50.00,  50.00), 
                                           (613.00, 613.00), 
                                           (72.70,  72.70));

      function Repetitive_Radix_2_Add (Value : in Radix_2_Type) 
        return Radix_2_Type is
         Result : Radix_2_Type := 0.0;
      begin
        for i in 1..Loop_Count loop
           Result := Result + Value;
        end loop;
        return Result;
      end Repetitive_Radix_2_Add;

      function Repetitive_Radix_10_Add (Value : in Radix_10_Type) 
        return Radix_10_Type is
         Result : Radix_10_Type := 0.0;
      begin
        for i in 1..Loop_Count loop
           Result := Result + Value;
        end loop;
        return Result;
      end Repetitive_Radix_10_Add;

   begin

      -- Radix 2 Cases, three different values.
      -- Compare the result of the repetitive addition with the expected
      -- Radix 2 result, as well as with the Radix 10 value after type 
      -- conversion.

      if Repetitive_Radix_2_Add(0.05) /= Result_Array(1).Rad_2  or
         Repetitive_Radix_2_Add(0.05) /= Radix_2_Type(Result_Array(1).Rad_10)
      then
         Report.Failed("Incorrect Radix 2 Result, Case 1");
      end if;

      if Repetitive_Radix_2_Add(0.613) /= 
         Result_Array(2).Rad_2            or
         Repetitive_Radix_2_Add(0.613) /= 
         Radix_2_Type(Result_Array(2).Rad_10)
      then
         Report.Failed("Incorrect Radix 2 Result, Case 2");
      end if;

      if Repetitive_Radix_2_Add(0.0727)  /= 
         Result_Array(3).Rad_2              or
         Repetitive_Radix_2_Add(0.0727)  /= 
         Radix_2_Type(Result_Array(3).Rad_10)
      then
         Report.Failed("Incorrect Radix 2 Result, Case 3");
      end if;

      -- Radix 10 Cases, three different values.
      -- Compare the result of the repetitive addition with the expected
      -- Radix 10 result, as well as with the Radix 2 value after type 
      -- conversion.

      if Repetitive_Radix_10_Add(0.05) /= Result_Array(1).Rad_10  or
         Repetitive_Radix_10_Add(0.05) /= Radix_10_Type(Result_Array(1).Rad_2)
      then
         Report.Failed("Incorrect Radix 10 Result, Case 1");
      end if;

      if Repetitive_Radix_10_Add(0.613) /= 
         Result_Array(2).Rad_10            or
         Repetitive_Radix_10_Add(0.613) /= 
         Radix_10_Type(Result_Array(2).Rad_2)
      then
         Report.Failed("Incorrect Radix 10 Result, Case 2");
      end if;

      if Repetitive_Radix_10_Add(0.0727) /= 
         Result_Array(3).Rad_10             or
         Repetitive_Radix_10_Add(0.0727) /= 
         Radix_10_Type(Result_Array(3).Rad_2)
      then
         Report.Failed("Incorrect Radix 10 Result, Case 3");
      end if;

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



   Size_Block:
   -- Check the implementation max/min values of constants declared in
   -- package Ada.Decimal.
   declare
      Minimum_Required_Size : constant := 18;
      Maximum_Allowed_Size  : constant :=  0;
   begin

      -- Check that the Max_Decimal_Digits value is at least 18.
      if not (Ada.Decimal.Max_Decimal_Digits >= Minimum_Required_Size) then
         Report.Failed("Insufficient size provided for Max_Decimal_Digits");
      end if;

      -- Check that the Max_Scale value is at least 18.
      if not (Ada.Decimal.Max_Scale >= Minimum_Required_Size) then
         Report.Failed("Insufficient size provided for Max_Scale");
      end if;

      -- Check that the Min_Scale value is at most 0.
      if not (Ada.Decimal.Min_Scale <= Maximum_Allowed_Size) then
         Report.Failed("Too large a value provided for Min_Scale");
      end if;

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

   Report.Result;

end CXF1001;