-- Test conformance of a GENERIC_COMPLEX_ELEMENTARY_FUNCTIONS implementation to
-- Draft XX, <date>, of proposed standard (just a start of a series of tests)
-- !!!!!! check against ISO 8652:1995
-- A better "Check" routine will be provided late,  Jon
-- More cases will be provided later, Jon
--
--Copyright (C) 1993 Free Software Foundation
--written by Jon Squire with assistance from many others 
--
--This file is part of the numerics library. This library
--is free software; you can redistribute it and/or modify it under the
--terms of the GNU Library General Public License as published by the Free
--Software Foundation; either version 2 of the License, or (at your
--option) any later version.  This library is distributed in the hope
--that it will be useful, but WITHOUT ANY WARRANTY; without even the
--implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
--PURPOSE.  See the GNU Library General Public License for more details.
--You should have received a copy of the GNU Library General Public
--License along with this library; if not, write to the Free Software
--Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
--

with GENERIC_COMPLEX_TYPES;
with GENERIC_COMPLEX_ELEMENTARY_FUNCTIONS;
with CALENDAR;
with TEXT_IO; use TEXT_IO;
with COMPLEX_IO;

procedure TEST_GENERIC_COMPLEX_ELEMENTARY_FUNCTIONS is

  type REAL is new FLOAT;  -- need to test each built in type implemented

  package COMPLEX_TYPES is new GENERIC_COMPLEX_TYPES(REAL);
  use COMPLEX_TYPES;

  package COMPLEX_ELEMENTARY_FUNCTIONS is new 
        GENERIC_COMPLEX_ELEMENTARY_FUNCTIONS(REAL, COMPLEX, IMAGINARY) ;
  use COMPLEX_ELEMENTARY_FUNCTIONS;

  package CX_IO is new COMPLEX_IO
                  (REAL, COMPLEX);
  use CX_IO;

  package REAL_IO is new FLOAT_IO(REAL);
  use REAL_IO;

  FAILED : BOOLEAN := FALSE;
  subtype MSG_TYPE is STRING(1..65);
  NOW : DURATION := CALENDAR.SECONDS(CALENDAR.CLOCK);
  PI        : constant := 3.14159_26535_89793_23846_26433_83279_50288_41971 ;
  NATURAL_E : constant := 2.71828_18284_59045_23536_02874_71352_66249_77572 ;
  SQRT_2    : constant := 1.41421_35623_73095_04880_16887_24209_69807_85696 ;
  BIG       : REAL := REAL'SAFE_LARGE; -- REAL'LAST should work also
  Y         : COMPLEX;

  function MAKE_MSG ( MESSAGE : STRING ) return MSG_TYPE is
    STD_MSG : MSG_TYPE := (others => ' ');
  begin
    if MESSAGE'LENGTH > MSG_TYPE'LENGTH then
      TEXT_IO.PUT_LINE("//// message truncated");
      STD_MSG(MSG_TYPE'RANGE) := MESSAGE(MSG_TYPE'RANGE);
    else
      STD_MSG(MESSAGE'RANGE) := MESSAGE;
    end if;
    return STD_MSG;
  end MAKE_MSG;

  procedure PASS ( ERROR_MESSAGE : STRING ) is
  begin
    TEXT_IO.PUT_LINE("++++ PASSED " & ERROR_MESSAGE );
  end PASS;
    
  procedure FAIL ( ERROR_MESSAGE : STRING ) is
  begin
    TEXT_IO.PUT_LINE("---- FAILED " & ERROR_MESSAGE );
    FAILED := TRUE ;
  end FAIL;
    
  procedure MESSAGE ( ERROR_MESSAGE : STRING ) is
  begin
    TEXT_IO.PUT_LINE("            " & ERROR_MESSAGE );
  end MESSAGE;
    
  procedure COMPARE ( EXPECTED, MEASURED : COMPLEX;
                      ERROR_MESSAGE : STRING;
                      TOLERANCE : REAL := 0.0) is
  begin
    if RE(EXPECTED) = RE(MEASURED) and IM(EXPECTED) = IM(MEASURED) then
      PASS(ERROR_MESSAGE);
      if NOW = DURATION'LAST then -- should never print
        PUT("     "); PUT(EXPECTED); PUT_LINE(" = expected");
        PUT("     "); PUT(MEASURED); PUT_LINE(" = measured");
      end if;
    elsif TOLERANCE = 0.0 then
      FAIL(ERROR_MESSAGE);
      -- add optional output here if desired ( five (5) leading spaces please ).
      PUT("     "); PUT(EXPECTED); PUT_LINE(" = expected");
      PUT("     "); PUT(MEASURED); PUT_LINE(" = measured");
      NEW_LINE;
    else
      if abs(EXPECTED-MEASURED) < abs(EXPECTED) * TOLERANCE * REAL'EPSILON then
        PASS(ERROR_MESSAGE);
        if NOW = DURATION'LAST then -- should never print
          PUT("     "); PUT(EXPECTED); PUT_LINE(" = expected");
          PUT("     "); PUT(MEASURED); PUT_LINE(" = measured");
        end if;
      else
        FAIL(ERROR_MESSAGE);
        -- add optional output here if desired ( five (5) leading spaces please ).
        PUT("     "); PUT(EXPECTED); PUT_LINE(" = expected");
        PUT("     "); PUT(MEASURED); PUT_LINE(" = measured");
        NEW_LINE;
      end if;
    end if;
  end COMPARE;

  procedure REPORT_RESULTS is
  begin
    MESSAGE("");
    MESSAGE("***************************************************");
    MESSAGE("");
    if FAILED then
      MESSAGE("test of Generic Complex Elementary Functions, part 1,  FAILED.");
    else
      MESSAGE("test of Generic Complex Elementary Functions, part 1,  PASSED.");
    end if;
    MESSAGE("");
    MESSAGE("***************************************************");
    MESSAGE("");
  end REPORT_RESULTS;

begin -- start

  PUT_LINE("TEST_GENERIC_COMPLEX_ELEMENTARY_FUNCTIONS");

  declare
    TEST_MSG : MSG_TYPE := MAKE_MSG("SQRT(X:COMPLEX)return COMPLEX");
  begin
    COMPARE( (0.0, 0.0), SQRT(X=>(0.0,0.0)) ,TEST_MSG, 0.0); -- 0.0 means exact
    COMPARE( (1.0, 0.0), SQRT((1.0,0.0)) ,TEST_MSG, 0.0);
    COMPARE( (0.0, 1.0), SQRT((-1.0,0.0)) ,TEST_MSG, 0.0);
    COMPARE( (sqrt_2/2.0, sqrt_2/2.0), SQRT((0.0,1.0)) ,TEST_MSG, 6.0);
    COMPARE( (sqrt_2/2.0, -sqrt_2/2.0), SQRT((0.0,-1.0)) ,TEST_MSG, 6.0);
    COMPARE( (4.0, 1.0), SQRT((15.0,8.0)) ,TEST_MSG, 6.0);
    COMPARE( (1.0, -4.0), SQRT((-15.0,-8.0)) ,TEST_MSG, 6.0);
    COMPARE( (4.0, -1.0), SQRT((15.0,-8.0)) ,TEST_MSG, 6.0);
    COMPARE( (1.0, 4.0), SQRT((-15.0,8.0)) ,TEST_MSG, 6.0);
    COMPARE( (3.0, 4.0), SQRT((-7.0,24.0)) ,TEST_MSG, 6.0);
    COMPARE( (4.0, 3.0), SQRT((7.0,24.0)) ,TEST_MSG, 6.0);
    COMPARE( (3.0, -4.0), SQRT((-7.0,-24.0)) ,TEST_MSG, 6.0);
    COMPARE( (4.0, -3.0), SQRT((7.0,-24.0)) ,TEST_MSG, 6.0);
  exception
    when others =>
      FAIL(TEST_MSG);
end;


  declare
    TEST_MSG : MSG_TYPE := MAKE_MSG("LOG(X:COMPLEX)return COMPLEX");
  begin
    COMPARE( (0.0, 0.0), LOG(X=>(1.0,0.0)) ,TEST_MSG, 0.0);
    COMPARE( (0.0, Pi), LOG((-1.0,0.0)) ,TEST_MSG, 4.0); -- pure imaginary
    COMPARE( (0.0, -Pi), LOG((-1.0,-FLOAT'SMALL)) ,TEST_MSG, 4.0);
    COMPARE( (0.0, Pi/2.0), LOG((0.0,1.0)) ,TEST_MSG, 4.0);
    COMPARE( (0.0, -Pi/2.0), LOG((0.0,-1.0)) ,TEST_MSG, 4.0);
    begin
      COMPARE( (0.0, 0.0), LOG((0.0,0.0)) ,TEST_MSG);
      FAIL(TEST_MSG & " no CONSTRAINT_ERROR");
    exception
      when CONSTRAINT_ERROR | NUMERIC_ERROR =>
        PASS(TEST_MSG);
      when COMPLEX_ELEMENTARY_FUNCTIONS.ARGUMENT_ERROR =>
        FAIL(TEST_MSG & " argument");
      when others =>
        FAIL(TEST_MSG & " others");
    end;
  exception
    when others =>
      FAIL(TEST_MSG);
  end;


  declare
    TEST_MSG : MSG_TYPE := MAKE_MSG("EXP(X:COMPLEX)return COMPLEX;");
  begin
    COMPARE( (1.0, 0.0), EXP(X=>(0.0,0.0)) ,TEST_MSG);
    COMPARE( (natural_e, 0.0), EXP((1.0,0.0)) ,TEST_MSG, 7.0);
    begin
      Y := EXP((BIG,0.0));
      FAIL(TEST_MSG & " no CONSTRAINT_ERROR");
    exception
      when CONSTRAINT_ERROR | NUMERIC_ERROR =>
        PASS(TEST_MSG);
      when COMPLEX_ELEMENTARY_FUNCTIONS.ARGUMENT_ERROR =>
        FAIL(TEST_MSG & " argument");
      when others =>
        FAIL(TEST_MSG & " others");
    end;
  exception
    when others =>
      FAIL(TEST_MSG);
  end;


  declare
    TEST_MSG : MSG_TYPE := MAKE_MSG("EXP(X:IMAGINARY)return COMPLEX");
  begin
    COMPARE( (1.0, 0.0), EXP(X=>0.0*I) ,TEST_MSG, 0.0);
    COMPARE( (sqrt_2/2.0, sqrt_2/2.0), EXP((Pi/4.0)*I) ,TEST_MSG, 2.0);
    COMPARE( (0.0, 1.0), EXP((Pi/2.0)*I) ,TEST_MSG, 2.0);
    COMPARE( (-sqrt_2/2.0, sqrt_2/2.0), EXP((3.0*Pi/4.0)*I) ,TEST_MSG, 2.0);
    COMPARE( (-1.0, 0.0), EXP(Pi*I) ,TEST_MSG, 2.0);
    begin
      Y := EXP(BIG*I);
      PASS(TEST_MSG); -- no exception
    exception
      when CONSTRAINT_ERROR | NUMERIC_ERROR =>
        FAIL(TEST_MSG & " constraint ");
      when COMPLEX_ELEMENTARY_FUNCTIONS.ARGUMENT_ERROR =>
        FAIL(TEST_MSG & " argument");
      when others =>
        FAIL(TEST_MSG & " others");
    end;
  exception
    when others =>
      FAIL(TEST_MSG);
  end;


  declare
    TEST_MSG : MSG_TYPE := MAKE_MSG("**(L,R:COMPLEX)return COMPLEX");
  begin
    COMPARE( (1.0, 0.0), "**"(LEFT=>(-2.0,-2.0),RIGHT=>(0.0,0.0)),TEST_MSG,0.0);
    COMPARE( (0.0, 0.0), "**"((0.0,0.0),(1000.0,0.0)) ,TEST_MSG, 0.0);
    COMPARE( (1.0, 0.0), "**"((1.0,0.0),(1000.0,1000.0)) ,TEST_MSG, 0.0);
    COMPARE( (pi, natural_e), "**"((Pi,natural_e),(1.0,0.0)) ,TEST_MSG, 0.0);
    begin
      COMPARE( (0.0, 0.0), "**"((0.0,0.0),(0.0,0.0)) ,TEST_MSG);
      FAIL(TEST_MSG & " no ARGUMENT_ERROR");
    exception
      when CONSTRAINT_ERROR | NUMERIC_ERROR =>
        FAIL(TEST_MSG & " constraint");
      when COMPLEX_ELEMENTARY_FUNCTIONS.ARGUMENT_ERROR =>
        PASS(TEST_MSG);
      when others =>
        FAIL(TEST_MSG & " others");
    end;
    begin
      COMPARE( (0.0, 0.0), "**"((0.0,0.0),(-1.0,0.0)) ,TEST_MSG);
      FAIL(TEST_MSG & " no CONSTRAINT_ERROR");
    exception
      when CONSTRAINT_ERROR | NUMERIC_ERROR =>
        PASS(TEST_MSG);
      when COMPLEX_ELEMENTARY_FUNCTIONS.ARGUMENT_ERROR =>
        FAIL(TEST_MSG & " argument");
      when others =>
        FAIL(TEST_MSG & " others");
    end;
  exception
    when others =>
      FAIL(TEST_MSG);
  end;


  declare
    TEST_MSG : MSG_TYPE := MAKE_MSG("**(L:COMPLEX;R:REAL)return COMPLEX");
  begin
    COMPARE( (1.0, 0.0), "**"(LEFT=>(-2.0,-2.0),RIGHT=>0.0) ,TEST_MSG, 0.0);
    COMPARE( (0.0, 0.0), "**"((0.0,0.0),1000.0) ,TEST_MSG, 0.0);
    COMPARE( (1.0, 0.0), "**"((1.0,0.0),1000.0) ,TEST_MSG, 0.0);
    COMPARE( (pi, natural_e), "**"((Pi,natural_e),1.0) ,TEST_MSG, 0.0);
    begin
      COMPARE( (0.0, 0.0), "**"((0.0,0.0),0.0) ,TEST_MSG);
      FAIL(TEST_MSG & " no ARGUMENT_ERROR");
    exception
      when CONSTRAINT_ERROR | NUMERIC_ERROR =>
        FAIL(TEST_MSG & " constraint");
      when COMPLEX_ELEMENTARY_FUNCTIONS.ARGUMENT_ERROR =>
        PASS(TEST_MSG);
      when others =>
        FAIL(TEST_MSG & " others");
    end;
    begin
      COMPARE( (0.0, 0.0), "**"((0.0,0.0),-1.0) ,TEST_MSG);
      FAIL(TEST_MSG & " no CONSTRAINT_ERROR");
    exception
      when CONSTRAINT_ERROR | NUMERIC_ERROR =>
        PASS(TEST_MSG);
      when COMPLEX_ELEMENTARY_FUNCTIONS.ARGUMENT_ERROR =>
        FAIL(TEST_MSG & " argument");
      when others =>
        FAIL(TEST_MSG & " others");
    end;
  exception
    when others =>
      FAIL(TEST_MSG);
  end;


  declare
    TEST_MSG : MSG_TYPE := MAKE_MSG("**(L:REAL;R:COMPLEX)return COMPLEX");
  begin
    COMPARE( (1.0, 0.0), "**"(LEFT=>-2.0,RIGHT=>(0.0,0.0)) ,TEST_MSG, 0.0);
    COMPARE( (0.0, 0.0), "**"(0.0,(1000.0,0.0)) ,TEST_MSG, 0.0);
    COMPARE( (1.0, 0.0), "**"(1.0,(1000.0,1000.0)) ,TEST_MSG, 0.0);
    COMPARE( (pi,  0.0), "**"(Pi,(1.0,0.0)) ,TEST_MSG, 0.0);
    begin
      COMPARE( (0.0, 0.0), "**"(0.0,(0.0,0.0)) ,TEST_MSG);
      FAIL(TEST_MSG & " no ARGUMENT_ERROR");
    exception
      when CONSTRAINT_ERROR | NUMERIC_ERROR =>
        FAIL(TEST_MSG & " constraint");
      when COMPLEX_ELEMENTARY_FUNCTIONS.ARGUMENT_ERROR =>
        PASS(TEST_MSG);
      when others =>
        FAIL(TEST_MSG & " others");
    end;
    begin
      COMPARE( (0.0, 0.0), "**"(0.0,(-1.0,0.0)) ,TEST_MSG);
      FAIL(TEST_MSG & " no CONSTRAINT_ERROR");
    exception
      when CONSTRAINT_ERROR | NUMERIC_ERROR =>
        PASS(TEST_MSG);
      when COMPLEX_ELEMENTARY_FUNCTIONS.ARGUMENT_ERROR =>
        FAIL(TEST_MSG & " argument");
      when others =>
        FAIL(TEST_MSG & " others");
    end;
  exception
    when others =>
      FAIL(TEST_MSG);
  end;


  declare
    TEST_MSG : MSG_TYPE := MAKE_MSG("SIN(X:COMPLEX)return COMPLEX;");
  begin
    COMPARE( (0.0, 0.0), SIN(X=>(0.0,0.0)) ,TEST_MSG, 0.0);
    COMPARE( (sqrt_2/2.0, 0.0), SIN((Pi/4.0,0.0)) ,TEST_MSG, 11.0);
    COMPARE( (-sqrt_2/2.0, 0.0), SIN((-Pi/4.0,0.0)) ,TEST_MSG, 11.0);
    begin
      Y := SIN((0.0,BIG));
      FAIL(TEST_MSG & " no CONSTRAINT_ERROR");
    exception
      when CONSTRAINT_ERROR | NUMERIC_ERROR =>
        PASS(TEST_MSG);
      when COMPLEX_ELEMENTARY_FUNCTIONS.ARGUMENT_ERROR =>
        FAIL(TEST_MSG & " argument");
      when others =>
        FAIL(TEST_MSG & " others");
    end;
  exception
    when others =>
      FAIL(TEST_MSG);
  end;



  declare
    TEST_MSG : MSG_TYPE := MAKE_MSG("COS(X:COMPLEX)return COMPLEX;");
  begin
    COMPARE( (1.0, 0.0), COS(X=>(0.0,0.0)) ,TEST_MSG, 0.0);
    COMPARE( (sqrt_2/2.0, 0.0), COS((Pi/4.0,0.0)) ,TEST_MSG, 11.0);
    COMPARE( (sqrt_2/2.0, 0.0), COS((-Pi/4.0,0.0)) ,TEST_MSG, 11.0);
    begin
      Y := COS((0.0,BIG));
      FAIL(TEST_MSG & " no CONSTRAINT_ERROR");
    exception
      when CONSTRAINT_ERROR | NUMERIC_ERROR =>
        PASS(TEST_MSG);
      when COMPLEX_ELEMENTARY_FUNCTIONS.ARGUMENT_ERROR =>
        FAIL(TEST_MSG & " argument");
      when others =>
        FAIL(TEST_MSG & " others");
    end;
  exception
    when others =>
      FAIL(TEST_MSG);
  end;


  declare
    TEST_MSG : MSG_TYPE := MAKE_MSG("TAN(X:COMPLEX)return COMPLEX;");
  begin
    COMPARE( (0.0, 0.0), TAN(X=>(0.0,0.0)) ,TEST_MSG, 0.0);
    COMPARE( (1.0, 0.0), TAN((Pi/4.0,0.0)) ,TEST_MSG, 35.0);
  exception
    when others =>
      FAIL(TEST_MSG);
  end;


  declare
    TEST_MSG : MSG_TYPE := MAKE_MSG("COT(X:COMPLEX)return COMPLEX;");
  begin
    COMPARE( (1.0, 0.0), COT(X=>(Pi/4.0,0.0)) ,TEST_MSG, 34.0);
    begin
      Y := COT((0.0,0.0));
      FAIL(TEST_MSG & " no CONSTRAINT_ERROR");
    exception
      when CONSTRAINT_ERROR | NUMERIC_ERROR =>
        PASS(TEST_MSG);
      when COMPLEX_ELEMENTARY_FUNCTIONS.ARGUMENT_ERROR =>
        FAIL(TEST_MSG & " argument");
      when others =>
        FAIL(TEST_MSG & " others");
    end;
  exception
    when others =>
      FAIL(TEST_MSG);
  end;


  declare
    TEST_MSG : MSG_TYPE := MAKE_MSG("ARCSIN(X:COMPLEX)return COMPLEX;");
  begin
    COMPARE( (0.0, 0.0), ARCSIN(X=>(0.0,0.0)) ,TEST_MSG, 0.0);
    COMPARE( (Pi/2.0, 0.0), ARCSIN((1.0,0.0)) ,TEST_MSG, 14.0);
    COMPARE( (-Pi/2.0, 0.0), ARCSIN((-1.0,0.0)) ,TEST_MSG, 14.0);
  exception
    when others =>
      FAIL(TEST_MSG);
  end;


  declare
    TEST_MSG : MSG_TYPE := MAKE_MSG("ARCCOS(X:COMPLEX)return COMPLEX;");
  begin
    COMPARE( (0.0, 0.0), ARCCOS(X=>(1.0,0.0)) ,TEST_MSG, 0.0);
    COMPARE( (Pi/2.0, 0.0), ARCCOS((0.0,0.0)) ,TEST_MSG, 14.0);
    COMPARE( (Pi, 0.0), ARCCOS((-1.0,0.0)) ,TEST_MSG, 14.0);
  exception
    when others =>
      FAIL(TEST_MSG);
  end;


  declare
    TEST_MSG : MSG_TYPE := MAKE_MSG("ARCTAN(X:COMPLEX)return COMPLEX;");
  begin
    COMPARE( (0.0, 0.0), ARCTAN(X=>(0.0,0.0)) ,TEST_MSG, 0.0);
    COMPARE( (Pi/4.0, 0.0), ARCTAN((1.0,0.0)) ,TEST_MSG, 14.0);
    begin
      Y := ARCTAN((0.0,1.0));
      FAIL(TEST_MSG & " no CONSTRAINT_ERROR");
    exception
      when CONSTRAINT_ERROR | NUMERIC_ERROR =>
        PASS(TEST_MSG);
      when COMPLEX_ELEMENTARY_FUNCTIONS.ARGUMENT_ERROR =>
        FAIL(TEST_MSG & " argument");
      when others =>
        FAIL(TEST_MSG & " others");
    end;
    begin
      Y := ARCTAN((0.0,-1.0));
      FAIL(TEST_MSG & " no CONSTRAINT_ERROR");
    exception
      when CONSTRAINT_ERROR | NUMERIC_ERROR =>
        PASS(TEST_MSG);
      when COMPLEX_ELEMENTARY_FUNCTIONS.ARGUMENT_ERROR =>
        FAIL(TEST_MSG & " argument");
      when others =>
        FAIL(TEST_MSG & " others");
    end;
  exception
    when others =>
      FAIL(TEST_MSG);
  end;


  declare
    TEST_MSG : MSG_TYPE := MAKE_MSG("ARCCOT(X:COMPLEX)return COMPLEX;");
  begin
    COMPARE( (Pi/4.0, 0.0), ARCCOT(X=>(1.0,0.0)) ,TEST_MSG, 14.0);
    begin
      Y := ARCCOT((0.0,1.0));
      FAIL(TEST_MSG & " no CONSTRAINT_ERROR");
    exception
      when CONSTRAINT_ERROR | NUMERIC_ERROR =>
        PASS(TEST_MSG);
      when COMPLEX_ELEMENTARY_FUNCTIONS.ARGUMENT_ERROR =>
        FAIL(TEST_MSG & " argument");
      when others =>
        FAIL(TEST_MSG & " others");
    end;
    begin
      Y := ARCCOT((0.0,-1.0));
      FAIL(TEST_MSG & " no CONSTRAINT_ERROR");
    exception
      when CONSTRAINT_ERROR | NUMERIC_ERROR =>
        PASS(TEST_MSG);
      when COMPLEX_ELEMENTARY_FUNCTIONS.ARGUMENT_ERROR =>
        FAIL(TEST_MSG & " argument");
      when others =>
        FAIL(TEST_MSG & " others");
    end;
  exception
    when others =>
      FAIL(TEST_MSG);
  end;


  declare
    TEST_MSG : MSG_TYPE := MAKE_MSG("SINH(X:COMPLEX)return COMPLEX;");
  begin
    COMPARE( (0.0, 0.0), SINH(X=>(0.0,0.0)) ,TEST_MSG, 0.0);
    COMPARE( (0.0,sqrt_2/2.0), SINH((0.0,Pi/4.0)) ,TEST_MSG, 11.0);
    COMPARE( (0.0,-sqrt_2/2.0), SINH((0.0,-Pi/4.0)) ,TEST_MSG, 11.0);
    begin
      Y := SINH((BIG,0.0));
      FAIL(TEST_MSG & " no CONSTRAINT_ERROR");
    exception
      when CONSTRAINT_ERROR | NUMERIC_ERROR =>
        PASS(TEST_MSG);
      when COMPLEX_ELEMENTARY_FUNCTIONS.ARGUMENT_ERROR =>
        FAIL(TEST_MSG & " argument");
      when others =>
        FAIL(TEST_MSG & " others");
    end;
  exception
    when others =>
      FAIL(TEST_MSG);
  end;


  declare
    TEST_MSG : MSG_TYPE := MAKE_MSG("COSH(X:COMPLEX)return COMPLEX;");
  begin
    COMPARE( (1.0, 0.0), COSH(X=>(0.0,0.0)) ,TEST_MSG, 0.0);
    COMPARE( (sqrt_2/2.0,0.0), COSH((0.0,Pi/4.0)) ,TEST_MSG, 11.0);
    COMPARE( (sqrt_2/2.0,0.0), COSH((0.0,-Pi/4.0)) ,TEST_MSG, 11.0);
    begin
      Y := COSH((BIG,0.0));
      FAIL(TEST_MSG & " no CONSTRAINT_ERROR");
    exception
      when CONSTRAINT_ERROR | NUMERIC_ERROR =>
        PASS(TEST_MSG);
      when COMPLEX_ELEMENTARY_FUNCTIONS.ARGUMENT_ERROR =>
        FAIL(TEST_MSG & " argument");
      when others =>
        FAIL(TEST_MSG & " others");
    end;
  exception
    when others =>
      FAIL(TEST_MSG);
  end;


  declare
    TEST_MSG : MSG_TYPE := MAKE_MSG("TANH(X:COMPLEX)return COMPLEX;");
  begin
    COMPARE( (0.0, 0.0), TANH(X=>(0.0,0.0)) ,TEST_MSG, 0.0);
    COMPARE( (0.0, 1.0), TANH((0.0, Pi/4.0)) ,TEST_MSG, 35.0);
    COMPARE( (0.0,-1.0), TANH((0.0,-Pi/4.0)) ,TEST_MSG, 35.0);
  exception
    when others =>
      FAIL(TEST_MSG);
  end;


  declare
    TEST_MSG : MSG_TYPE := MAKE_MSG("COTH(X:COMPLEX)return COMPLEX;");
  begin
    COMPARE( (0.0, 1.0), COTH(X=>(0.0,-Pi/4.0)) ,TEST_MSG, 35.0);
    COMPARE( (0.0,-1.0), COTH((0.0, Pi/4.0)) ,TEST_MSG, 35.0);
    begin
      Y := COTH((0.0,0.0));
      FAIL(TEST_MSG & " no CONSTRAINT_ERROR");
    exception
      when CONSTRAINT_ERROR | NUMERIC_ERROR =>
        PASS(TEST_MSG);
      when COMPLEX_ELEMENTARY_FUNCTIONS.ARGUMENT_ERROR =>
        FAIL(TEST_MSG & " argument");
      when others =>
        FAIL(TEST_MSG & " others");
    end;
  exception
    when others =>
      FAIL(TEST_MSG);
  end;


  declare
    TEST_MSG : MSG_TYPE := MAKE_MSG("ARCSINH(X:COMPLEX)return COMPLEX;");
  begin
    COMPARE( (0.0, 0.0), ARCSINH(X=>(0.0,0.0)) ,TEST_MSG, 0.0);
    COMPARE( (0.0,Pi/2.0), ARCSINH((0.0,1.0)) ,TEST_MSG, 14.0);
    COMPARE( (0.0,-Pi/2.0), ARCSINH((0.0,-1.0)) ,TEST_MSG, 14.0);
  exception
    when others =>
      FAIL(TEST_MSG);
  end;


  declare
    TEST_MSG : MSG_TYPE := MAKE_MSG("ARCCOSH(X:COMPLEX)return COMPLEX;");
  begin
    COMPARE( (0.0, 0.0), ARCCOSH(X=>(1.0,0.0)) ,TEST_MSG, 0.0);
    -- COMPARE( (0.8813..,-Pi/2.0), ARCCOSH((0.0,1.0)) ,TEST_MSG, 14.0);
    -- COMPARE( (0.8813..,Pi/2.0), ARCCOSH((0.0,-1.0)) ,TEST_MSG, 14.0);
  exception
    when others =>
      FAIL(TEST_MSG);
  end;


  declare
    TEST_MSG : MSG_TYPE := MAKE_MSG("ARCTANH(X:COMPLEX)return COMPLEX;");
  begin
    COMPARE( (0.0, 0.0), ARCTANH(X=>(0.0,0.0)) ,TEST_MSG, 0.0);
    begin
      Y := ARCTANH((1.0,0.0));
      FAIL(TEST_MSG & " no CONSTRAINT_ERROR");
    exception
      when CONSTRAINT_ERROR | NUMERIC_ERROR =>
        PASS(TEST_MSG);
      when COMPLEX_ELEMENTARY_FUNCTIONS.ARGUMENT_ERROR =>
        FAIL(TEST_MSG & " argument");
      when others =>
        FAIL(TEST_MSG & " others");
    end;
    begin
      Y := ARCTANH((-1.0,0.0));
      FAIL(TEST_MSG & " no CONSTRAINT_ERROR");
    exception
      when CONSTRAINT_ERROR | NUMERIC_ERROR =>
        PASS(TEST_MSG);
      when COMPLEX_ELEMENTARY_FUNCTIONS.ARGUMENT_ERROR =>
        FAIL(TEST_MSG & " argument");
      when others =>
        FAIL(TEST_MSG & " others");
    end;
  exception
    when others =>
      FAIL(TEST_MSG);
  end;


  declare
    TEST_MSG : MSG_TYPE := MAKE_MSG("ARCCOTH(X:COMPLEX)return COMPLEX;");
  begin
    COMPARE( (0.0,Pi/2.0), ARCCOTH(X=>(0.0,0.0)) ,TEST_MSG, 14.0);
    begin
      Y := ARCCOTH((1.0,0.0));
      FAIL(TEST_MSG & " no CONSTRAINT_ERROR");
    exception
      when CONSTRAINT_ERROR | NUMERIC_ERROR =>
        PASS(TEST_MSG);
      when COMPLEX_ELEMENTARY_FUNCTIONS.ARGUMENT_ERROR =>
        FAIL(TEST_MSG & " argument");
      when others =>
        FAIL(TEST_MSG & " others");
    end;
    begin
      Y := ARCCOTH((-1.0,0.0));
      FAIL(TEST_MSG & " no CONSTRAINT_ERROR");
    exception
      when CONSTRAINT_ERROR | NUMERIC_ERROR =>
        PASS(TEST_MSG);
      when COMPLEX_ELEMENTARY_FUNCTIONS.ARGUMENT_ERROR =>
        FAIL(TEST_MSG & " argument");
      when others =>
        FAIL(TEST_MSG & " others");
    end;
  exception
    when others =>
      FAIL(TEST_MSG);
  end;


  if Y = (BIG,BIG) then
    TEXT_IO.PUT_LINE("    just make Y be computed");
  end if;

  REPORT_RESULTS;

end TEST_GENERIC_COMPLEX_ELEMENTARY_FUNCTIONS;