-- C460007.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, in a numeric type conversion, if the target type is an
--      integer type and the operand type is real, the result is rounded
--      to the nearest integer, and away from zero if the result is exactly
--      halfway between two integers. Check for static and non-static type
--      conversions.
--
-- TEST DESCRIPTION:
--      The following cases are considered:
--
--          X.5    X.5 + delta   -X.5 + delta
--         -X.5    X.5 - delta   -X.5 - delta
--
--      Both zero and non-zero values are used for X. The value of delta is
--      chosen to be a very small increment (on the order of 1.0E-10). For
--      fixed and floating point cases, the value of delta is chosen such that
--      "(-)X.5 +(-) delta" is a multiple of the small, or a machine number,
--      respectively.
--
--      The following type conversions are performed:
--
--      ID   Real operand            Cases          Target integer subtype
--      ------------------------------------------------------------------
--       1   Real named number        X.5           Nonstatic
--       2                            X.5 - delta   Nonstatic
--       3                           -X.5 - delta   Static
--       4   Real literal            -X.5           Static
--       5                            X.5 + delta   Static
--       6                           -X.5 + delta   Nonstatic
--       7   Floating point object   -X.5 - delta   Nonstatic
--       8                            X.5 - delta   Static
--       9   Fixed point object       X.5           Static
--      10                            X.5 + delta   Static
--      11                           -X.5 + delta   Nonstatic
--      The conversion is either assigned to a variable of the target subtype
--      or passed as a parameter to a subprogram (both nonstatic contexts).
--
--      The subprogram Equal is used to circumvent potential optimizations.
--
--
-- CHANGE HISTORY:
--      03 Oct 95   SAIC    Initial prerelease version.
--
--!

with System;
package C460007_0 is

--
-- Target integer subtype (static):
--

   type Static_Integer_Subtype is range -32_000 .. 32_000;

   Static_Target : Static_Integer_Subtype;

   function Equal (L, R: Static_Integer_Subtype) return Boolean;


--
-- Named numbers:
--

   NN_Half      : constant := 0.5000000000;
   NN_Less_Half : constant := 126.4999999999;
   NN_More_Half : constant := -NN_Half - 0.0000000001;


--
-- Floating point:
--

   type My_Float is digits System.Max_Digits;

   Flt_Rnd_Toward_Zero :          My_Float := My_Float'Pred(NN_Half);
   Flt_Rnd_Away_Zero   : constant My_Float := My_Float'Pred(-113.5);


--
-- Fixed point:
--

   type My_Fixed is delta 0.1 range -5.0 .. 5.0;

   Fix_Half            :          My_Fixed := 0.5;
   Fix_Rnd_Away_Zero   :          My_Fixed := Fix_Half + My_Fixed'Small;
   Fix_Rnd_Toward_Zero : constant My_Fixed := -3.5 + My_Fixed'Small;

end C460007_0;


     --==================================================================--


package body C460007_0 is

   function Equal (L, R: Static_Integer_Subtype) return Boolean is
   begin
      return (L = R);
   end Equal;

end C460007_0;


     --==================================================================--


with C460007_0;
use  C460007_0;

with Report;
procedure C460007 is

--
-- Target integer subtype (nonstatic):
--

   Limit : Static_Integer_Subtype :=
           Static_Integer_Subtype(Report.Ident_Int(128));

   subtype Nonstatic_Integer_Subtype is Static_Integer_Subtype
     range -Limit .. Limit;

   Nonstatic_Target : Static_Integer_Subtype;

begin

   Report.Test ("C460007", "Rounding for type conversions of real operand " &
                "to integer target");


   -- --------------------------
   -- Named number/literal cases:
   -- --------------------------

   Nonstatic_Target := Nonstatic_Integer_Subtype(NN_Half);
   
   if not Equal(Nonstatic_Target, 1) then                           -- Case 1.
      Report.Failed ("Wrong result for named number operand" &
                     "(case 1), nonstatic target subtype");
   end if;

   if not Equal(Nonstatic_Integer_Subtype(NN_Less_Half), 126) then  -- Case 2. 
      Report.Failed ("Wrong result for named number operand" &
                     "(case 2), nonstatic target subtype");
   end if;

   Static_Target := Static_Integer_Subtype(NN_More_Half);
   
   if not Equal(Static_Target, -1) then                             -- Case 3.
      Report.Failed ("Wrong result for named number operand" &
                     "(case 3), static target subtype");
   end if;

   if not Equal(Static_Integer_Subtype(-0.50), -1) then             -- Case 4.
      Report.Failed ("Wrong result for literal operand" &
                     "(case 4), static target subtype");
   end if;

   if not Equal(Static_Integer_Subtype(29_546.5001), 29_547) then   -- Case 5.
      Report.Failed ("Wrong result for literal operand" &
                     "(case 5), static target subtype");
   end if;

   if not Equal(Nonstatic_Integer_Subtype(-66.499), -66) then       -- Case 6.
      Report.Failed ("Wrong result for literal operand" &
                     "(case 6), nonstatic target subtype");
   end if;


   -- --------------------
   -- Floating point cases:
   -- --------------------

   Nonstatic_Target := Nonstatic_Integer_Subtype(Flt_Rnd_Away_Zero);

   if not Equal(Nonstatic_Target, -114) then                        -- Case 7.
      Report.Failed ("Wrong result for floating point operand" &
                     "(case 7), nonstatic target subtype");
   end if;
                                                                    -- Case 8.
   if not Equal(Static_Integer_Subtype(Flt_Rnd_Toward_Zero), 0) then
      Report.Failed ("Wrong result for floating point operand" &
                     "(case 8), static target subtype");
   end if;


   -- -----------------
   -- Fixed point cases:
   -- -----------------

   Static_Target := Static_Integer_Subtype(Fix_Half);

   if not Equal(Static_Target, 1) then                              -- Case 9.
      Report.Failed ("Wrong result for fixed point operand" &
                     "(case 9), static target subtype");
   end if;

   if not Equal(Static_Integer_Subtype(Fix_Rnd_Away_Zero), 1) then  -- Case 10.
      Report.Failed ("Wrong result for fixed point operand" &
                     "(case 10), static target subtype");
   end if;

   Nonstatic_Target := Nonstatic_Integer_Subtype(Fix_Rnd_Toward_Zero);

   if not Equal(Nonstatic_Target, -3) then                          -- Case 11.
      Report.Failed ("Wrong result for fixed point operand" &
                     "(case 11), nonstatic target subtype");
   end if;


   Report.Result;

end C460007;