obtained gcc-4.6.4.tar.bz2 from upstream website;upstream

verified gcc-4.6.4.tar.bz2.sig;
imported gcc-4.6.4 source tree from verified upstream tarball.

downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.

if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.

1 files changed, 393 insertions, 0 deletions

diff --git a/gcc/testsuite/ada/acats/tests/cxg/cxg1005.a b/gcc/testsuite/ada/acats/tests/cxg/cxg1005.a
new file mode 100644
index 000000000..6faad4e13
--- /dev/null
+++ b/gcc/testsuite/ada/acats/tests/cxg/cxg1005.a
@@ -0,0 +1,393 @@
+-- CXG1005.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 the subprograms defined in the package
+--      Ada.Numerics.Generic_Complex_Elementary_Functions provide correct
+--      results.
+--      
+-- TEST DESCRIPTION:
+--      This test checks that specific subprograms defined in the generic
+--      package Generic_Complex_Elementary_Functions are available, and that
+--      they provide prescribed results given specific input values.
+--      The generic package Ada.Numerics.Generic_Complex_Types is instantiated 
+--      with a real type (new Float). The resulting new package is used as
+--      the generic actual to package Complex_IO.
+--      
+-- SPECIAL REQUIREMENTS:
+--      Implementations for which Float'Signed_Zeros is True must provide
+--      a body for ImpDef.Annex_G.Negative_Zero which returns a negative 
+--      zero.
+--
+-- APPLICABILITY CRITERIA
+--      This test only applies to implementations that support the
+--      numerics annex.
+--
+--         
+--       
+-- CHANGE HISTORY:
+--      06 Dec 94   SAIC    ACVC 2.0
+--      16 Nov 95   SAIC    Corrected visibility problems for ACVC 2.0.1.
+--      21 Feb 96   SAIC    Incorporated new structure for package Impdef.
+--      29 Sep 96   SAIC    Incorporated reviewer comments.
+--
+--!
+
+with Ada.Numerics.Generic_Complex_Types;
+with Ada.Numerics.Generic_Complex_Elementary_Functions;
+with ImpDef.Annex_G;
+with Report;
+
+procedure CXG1005 is
+begin
+
+   Report.Test ("CXG1005", "Check that the subprograms defined in "  &
+                           "the package Generic_Complex_Elementary_" & 
+                           "Functions provide correct results");
+
+   Test_Block:
+   declare
+
+      type Real_Type is new Float;
+
+      TC_Signed_Zeros : Boolean := Real_Type'Signed_Zeros; 
+
+      package Complex_Pack is new 
+        Ada.Numerics.Generic_Complex_Types(Real_Type);
+
+      package CEF is 
+        new Ada.Numerics.Generic_Complex_Elementary_Functions(Complex_Pack);
+
+      use Ada.Numerics, Complex_Pack, CEF;
+
+      Complex_Zero : constant Complex := Compose_From_Cartesian( 0.0, 0.0);
+      Plus_One     : constant Complex := Compose_From_Cartesian( 1.0, 0.0);
+      Minus_One    : constant Complex := Compose_From_Cartesian(-1.0, 0.0);
+      Plus_i       : constant Complex := Compose_From_Cartesian(i);
+      Minus_i      : constant Complex := Compose_From_Cartesian(-i);
+
+      Complex_Positive_Real      : constant Complex := 
+                                         Compose_From_Cartesian(4.0, 2.0);
+      Complex_Positive_Imaginary : constant Complex := 
+                                         Compose_From_Cartesian(3.0, 5.0);
+      Complex_Negative_Real      : constant Complex := 
+                                         Compose_From_Cartesian(-4.0, 2.0);
+      Complex_Negative_Imaginary : constant Complex := 
+                                         Compose_From_Cartesian(3.0, -5.0);
+
+
+      function A_Zero_Result (Z : Complex) return Boolean is
+      begin
+         return (Re(Z) = 0.0 and Im(Z) = 0.0);
+      end A_Zero_Result;
+
+
+      -- In order to evaluate complex elementary functions that are
+      -- prescribed to return a "real" result (meaning that the imaginary
+      -- component is zero), the Function A_Real_Result is defined.
+
+      function A_Real_Result (Z : Complex) return Boolean is
+      begin
+         return Im(Z) = 0.0;
+      end A_Real_Result;
+
+
+      -- In order to evaluate complex elementary functions that are
+      -- prescribed to return an "imaginary" result (meaning that the real
+      -- component of the complex number is zero, and the imaginary
+      -- component is non-zero), the Function An_Imaginary_Result is defined.
+
+      function An_Imaginary_Result (Z : Complex) return Boolean is
+      begin
+         return  (Re(Z) = 0.0 and Im(Z) /= 0.0);
+      end An_Imaginary_Result;
+
+
+   begin
+
+      -- Check that when the input parameter value is zero, the following
+      -- functions yield a zero result.
+
+      if not A_Zero_Result( Sqrt(Complex_Zero) ) then
+         Report.Failed("Non-zero result from Function Sqrt with zero input");
+      end if;
+
+      if not A_Zero_Result( Sin(Complex_Zero) ) then
+         Report.Failed("Non-zero result from Function Sin with zero input");
+      end if;
+
+      if not A_Zero_Result( Arcsin(Complex_Zero) ) then
+         Report.Failed("Non-zero result from Function Arcsin with zero " &
+                       "input");
+      end if;
+
+      if not A_Zero_Result( Tan(Complex_Zero) ) then
+         Report.Failed("Non-zero result from Function Tan with zero input");
+      end if;
+
+      if not A_Zero_Result( Arctan(Complex_Zero) ) then
+         Report.Failed("Non-zero result from Function Arctan with zero " &
+                       "input");
+      end if;
+
+      if not A_Zero_Result( Sinh(Complex_Zero) ) then
+         Report.Failed("Non-zero result from Function Sinh with zero input");
+      end if;
+
+      if not A_Zero_Result( Arcsinh(Complex_Zero) ) then
+         Report.Failed("Non-zero result from Function Arcsinh with zero " &
+                       "input");
+      end if;
+
+      if not A_Zero_Result( Tanh(Complex_Zero) ) then
+         Report.Failed("Non-zero result from Function Tanh with zero input");
+      end if;
+
+      if not A_Zero_Result( Arctanh(Complex_Zero) ) then
+         Report.Failed("Non-zero result from Function Arctanh with zero " &
+                       "input");
+      end if;
+
+
+      -- Check that when the input parameter value is zero, the following
+      -- functions yield a result of one.
+
+      if Exp(Complex_Zero) /= Plus_One 
+      then
+         Report.Failed("Non-zero result from Function Exp with zero input");
+      end if;
+
+      if Cos(Complex_Zero) /= Plus_One 
+      then
+         Report.Failed("Non-zero result from Function Cos with zero input");
+      end if;
+
+      if Cosh(Complex_Zero) /= Plus_One 
+      then
+         Report.Failed("Non-zero result from Function Cosh with zero input");
+      end if;
+
+
+      -- Check that when the input parameter value is zero, the following
+      -- functions yield a real result.
+
+      if not A_Real_Result( Arccos(Complex_Zero) ) then
+        Report.Failed("Non-real result from Function Arccos with zero input");
+      end if;
+
+      if not A_Real_Result( Arccot(Complex_Zero) ) then
+        Report.Failed("Non-real result from Function Arccot with zero input");
+      end if;
+
+
+      -- Check that when the input parameter value is zero, the following
+      -- functions yield an imaginary result.
+
+      if not An_Imaginary_Result( Arccoth(Complex_Zero) ) then
+        Report.Failed("Non-imaginary result from Function Arccoth with " &
+                      "zero input");
+      end if;
+
+
+      -- Check that when the input parameter value is one, the Sqrt function 
+      -- yields a result of one.
+
+      if Sqrt(Plus_One) /= Plus_One then
+         Report.Failed("Incorrect result from Function Sqrt with input " &
+                       "value of one");
+      end if;
+
+
+      -- Check that when the input parameter value is one, the following 
+      -- functions yield a result of zero.
+
+      if not A_Zero_Result( Log(Plus_One) ) then
+         Report.Failed("Non-zero result from Function Log with input " &
+                       "value of one");
+      end if;
+
+      if not A_Zero_Result( Arccos(Plus_One) ) then
+         Report.Failed("Non-zero result from Function Arccos with input " &
+                       "value of one");
+      end if;
+
+      if not A_Zero_Result( Arccosh(Plus_One) ) then
+         Report.Failed("Non-zero result from Function Arccosh with input " &
+                       "value of one");
+      end if;
+
+
+      -- Check that when the input parameter value is one, the Arcsin 
+      -- function yields a real result.
+
+      if not A_Real_Result( Arcsin(Plus_One) ) then
+         Report.Failed("Non-real result from Function Arcsin with input " &
+                       "value of one");
+      end if;
+
+
+      -- Check that when the input parameter value is minus one, the Sqrt 
+      -- function yields a result of "i", when the sign of the imaginary
+      -- component of the input parameter is positive (and yields "-i", if 
+      -- the sign on the imaginary component is negative), and the 
+      -- Complex_Types.Real'Signed_Zeros attribute is True.
+
+      if TC_Signed_Zeros then
+
+         declare
+            Minus_One_With_Pos_Zero_Im_Component : Complex := 
+                                  Compose_From_Cartesian(-1.0, +0.0);
+            Minus_One_With_Neg_Zero_Im_Component : Complex := 
+              Compose_From_Cartesian
+                (-1.0, Real_Type(ImpDef.Annex_G.Negative_Zero));
+         begin
+
+            if Sqrt(Minus_One_With_Pos_Zero_Im_Component) /= Plus_i then
+               Report.Failed("Incorrect result from Function Sqrt, when " &
+                             "input value is minus one with a positive "  &
+                             "imaginary component, Signed_Zeros being True");
+            end if;
+
+            if Sqrt(Minus_One_With_Neg_Zero_Im_Component) /= Minus_i then
+               Report.Failed("Incorrect result from Function Sqrt, when " &
+                             "input value is minus one with a negative "  &
+                             "imaginary component, Signed_Zeros being True");
+            end if;
+         end;
+
+      else   -- Signed_Zeros is False.
+
+         -- Check that when the input parameter value is minus one, the Sqrt 
+         -- function yields a result of "i", when the 
+         -- Complex_Types.Real'Signed_Zeros attribute is False.
+
+         if Sqrt(Minus_One) /= Plus_i then
+            Report.Failed("Incorrect result from Function Sqrt, when "    &
+                          "input value is minus one, Signed_Zeros being " & 
+                          "False");
+         end if;
+
+      end if;
+
+
+      -- Check that when the input parameter value is minus one, the Log
+      -- function yields an imaginary result.
+
+      if not An_Imaginary_Result( Log(Minus_One) ) then
+         Report.Failed("Non-imaginary result from Function Log with a " &
+                       "minus one input value");
+      end if;
+
+      -- Check that when the input parameter is minus one, the following 
+      -- functions yield a real result.
+
+      if not A_Real_Result( Arcsin(Minus_One) ) then
+         Report.Failed("Non-real result from Function Arcsin with a " &
+                       "minus one input value");
+      end if;
+
+      if not A_Real_Result( Arccos(Minus_One) ) then
+         Report.Failed("Non-real result from Function Arccos with a " &
+                       "minus one input value");
+      end if;
+
+
+      -- Check that when the input parameter has a value of +i or -i, the
+      -- Log function yields an imaginary result.
+
+      if not An_Imaginary_Result( Log(Plus_i) ) then
+         Report.Failed("Non-imaginary result from Function Log with an " &
+                       "input value of ""+i""");
+      end if;
+
+      if not An_Imaginary_Result( Log(Minus_i) ) then
+         Report.Failed("Non-imaginary result from Function Log with an " &
+                       "input value of ""-i""");
+      end if;
+
+
+      -- Check that exponentiation by a zero exponent yields the value one.
+
+      if "**"(Left  => Compose_From_Cartesian(5.0, 3.0), 
+              Right => Complex_Zero)                     /= Plus_One  or
+         Complex_Negative_Real**0.0                      /= Plus_One  or
+         15.0**Complex_Zero                              /= Plus_One
+      then
+         Report.Failed("Incorrect result from exponentiation with a zero " &
+                       "exponent");
+      end if;
+
+
+      -- Check that exponentiation by a unit exponent yields the value of 
+      -- the left operand (as a complex value).
+      -- Note: a "unit exponent" is considered the complex number (1.0, 0.0)
+
+      if "**"(Complex_Negative_Real, Plus_One) /= 
+         Complex_Negative_Real                    or
+         Complex_Negative_Imaginary**Plus_One  /= 
+         Complex_Negative_Imaginary               or
+         4.0**Plus_One                         /= 
+         Compose_From_Cartesian(4.0, 0.0)
+      then
+         Report.Failed("Incorrect result from exponentiation with a unit " &
+                       "exponent");
+      end if;
+
+
+      -- Check that exponentiation of the value one yields the value one.
+
+      if "**"(Plus_One, Complex_Negative_Imaginary) /= Plus_One  or
+         Plus_One**9.0                              /= Plus_One  or
+         1.0**Complex_Negative_Real                 /= Plus_One
+      then
+         Report.Failed("Incorrect result from exponentiation of the value " &
+                       "One");
+      end if;
+
+
+      -- Check that exponentiation of the value zero yields the value zero.
+      begin
+         if not A_Zero_Result("**"(Complex_Zero, 
+                                   Complex_Positive_Imaginary)) or
+            not A_Zero_Result(Complex_Zero**4.0)                or
+            not A_Zero_Result(0.0**Complex_Positive_Real)
+         then
+            Report.Failed("Incorrect result from exponentiation of the " &
+                          "value zero");
+         end if;
+      exception
+         when others =>
+           Report.Failed("Exception raised during the exponentiation of " &
+                         "the complex value zero");
+      end;
+
+
+   exception
+      when others => Report.Failed ("Exception raised in Test_Block");
+   end Test_Block;
+
+   Report.Result;
+
+end CXG1005;