-- Test GENERIC_INTEGER_ARRAYS 
--
-- The testing is performed by comparison to a model. The model,
-- a primitive implementation that can be checked against the standard
-- by inspection, is used to generate the test results. Simple
-- compare procedures are used for scalars, vectors and matrices
-- to determine exact match of array elements and attributes.
-- The function name REF is used for the model reference function.
-- The required formal parameter names are checked at compile time.

generic

  type INTEGER_TYPE is range <>;
  type INTEGER_VECTOR is array(INTEGER range <>) of INTEGER_TYPE;
  type INTEGER_MATRIX is array(INTEGER range <>,INTEGER range <>)
                                                        of INTEGER_TYPE;
  with function "+" (RIGHT : INTEGER_VECTOR) return INTEGER_VECTOR is <>;
  with function "-" (RIGHT : INTEGER_VECTOR) return INTEGER_VECTOR is <>;
  with function "abs" (RIGHT : INTEGER_VECTOR) return INTEGER_VECTOR is <>; 
  with function "+" (LEFT, RIGHT : INTEGER_VECTOR) return INTEGER_VECTOR is <>;
  with function "-" (LEFT, RIGHT : INTEGER_VECTOR) return INTEGER_VECTOR is <>;
  with function "*" (LEFT, RIGHT : INTEGER_VECTOR) return INTEGER_VECTOR is <>;
  with function "/" (LEFT, RIGHT : INTEGER_VECTOR) return INTEGER_VECTOR is <>;
  with function "**" (LEFT  : INTEGER_VECTOR; 
                 RIGHT : INTEGER) return INTEGER_VECTOR is <>;
  with function "*" (LEFT, RIGHT : INTEGER_VECTOR) return INTEGER_TYPE is <>; 
  with function "*" (LEFT  : INTEGER_TYPE;
                RIGHT : INTEGER_VECTOR) return INTEGER_VECTOR is <>;
  with function "*" (LEFT  : INTEGER_VECTOR;
                RIGHT : INTEGER_TYPE) return INTEGER_VECTOR is <>;
  with function "/" (LEFT  : INTEGER_VECTOR;
                RIGHT : INTEGER_TYPE) return INTEGER_VECTOR is <>;
  with function UNIT_VECTOR (INDEX : INTEGER;
                        ORDER : NATURAL;
                        FIRST : INTEGER := 1) return INTEGER_VECTOR is <>;  
  with function "+" (RIGHT : INTEGER_MATRIX) return INTEGER_MATRIX is <>;
  with function "-" (RIGHT : INTEGER_MATRIX) return INTEGER_MATRIX is <>;
  with function "abs" (RIGHT : INTEGER_MATRIX) return INTEGER_MATRIX is <>;
  with function TRANSPOSE (X : INTEGER_MATRIX) return INTEGER_MATRIX is <>;
  with function "+" (LEFT, RIGHT : INTEGER_MATRIX) return INTEGER_MATRIX is <>;
  with function "-" (LEFT, RIGHT : INTEGER_MATRIX) return INTEGER_MATRIX is <>;
  with function "*" (LEFT, RIGHT : INTEGER_MATRIX) return INTEGER_MATRIX is <>;
  with function "*" (LEFT, RIGHT : INTEGER_VECTOR) return INTEGER_MATRIX is <>;
  with function "*" (LEFT  : INTEGER_VECTOR;
                RIGHT : INTEGER_MATRIX) return INTEGER_VECTOR is <>;
  with function "*" (LEFT  : INTEGER_MATRIX;
                RIGHT : INTEGER_VECTOR) return INTEGER_VECTOR is <>;
  with function "*" (LEFT  : INTEGER_TYPE;
                RIGHT : INTEGER_MATRIX) return INTEGER_MATRIX is <>;
  with function "*" (LEFT  : INTEGER_MATRIX;
                RIGHT : INTEGER_TYPE) return INTEGER_MATRIX is <>;
  with function "/" (LEFT  : INTEGER_MATRIX;
                RIGHT : INTEGER_TYPE) return INTEGER_MATRIX is <>;
  with function IDENTITY_MATRIX (ORDER : NATURAL;
                                 FIRST_1, FIRST_2 : INTEGER := 1)
                                 return INTEGER_MATRIX is <>;


procedure TEST_GENERIC_INTEGER_ARRAYS; -- end of specification


with TEXT_IO;
with ARRAY_EXCEPTIONS;
procedure TEST_GENERIC_INTEGER_ARRAYS is

  FAILED : BOOLEAN := FALSE;
  subtype MSG_TYPE is STRING(1..50);
  ZERO : NATURAL;
  ARRAY_INDEX_ERROR : exception renames ARRAY_EXCEPTIONS.ARRAY_INDEX_ERROR;

  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(MESSAGE'FIRST..
                                         MESSAGE'FIRST+MSG_TYPE'LENGTH-1);
    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 COMPARE ( EXPECTED, MEASURED : INTEGER_TYPE;
                      ERROR_MESSAGE : STRING ) is
  begin
    if EXPECTED = MEASURED then
      PASS(ERROR_MESSAGE);
    else
      FAIL(ERROR_MESSAGE);
      -- add optional output here if desired ( five (5) leading spaces please ).
    end if;
  end COMPARE;

  procedure COMPARE ( EXPECTED, MEASURED : INTEGER_VECTOR;
                      ERROR_MESSAGE : STRING ) is
  begin
    if EXPECTED = MEASURED and then
       EXPECTED'FIRST = MEASURED'FIRST then
      PASS(ERROR_MESSAGE);
    else
      FAIL(ERROR_MESSAGE);
      -- add optional output here if desired ( five (5) leading spaces please ).
    end if;
  end COMPARE;

  procedure COMPARE ( EXPECTED, MEASURED : INTEGER_MATRIX;
                      ERROR_MESSAGE : STRING ) is
  begin
    if EXPECTED = MEASURED and then
       EXPECTED'FIRST(1) = MEASURED'FIRST(1) and then
       EXPECTED'FIRST(2) = MEASURED'FIRST(2) then
      PASS(ERROR_MESSAGE);
    else
      FAIL(ERROR_MESSAGE);
      -- add optional output here if desired ( five (5) leading spaces please ).
    end if;
  end COMPARE;

  procedure REPORT_RESULTS is
  begin
    if FAILED then
      TEXT_IO.PUT_LINE("     test of  GENERIC_INTEGER_ARRAYS  FAILED.");
    else
      TEXT_IO.PUT_LINE("     test of  GENERIC_INTEGER_ARRAYS  PASSED.");
    end if;
  end REPORT_RESULTS;

begin

  ZERO := 0;

-- SUBPROGRAMS for INTEGER_VECTOR TYPES --

  -- VECTOR arithmetic operations --

  declare
    TEST_MESSAGE : MSG_TYPE := MAKE_MSG("unary + on INTEGER_VECTOR");
    V1 : INTEGER_VECTOR(3..5) := ( 3, -4, 7);
    function REF  (V : INTEGER_VECTOR) return INTEGER_VECTOR is
    begin
      return V ;
    end REF;
  begin
    COMPARE( REF(V1), +V1, TEST_MESSAGE );
    V1 := "+"( RIGHT => V1 ); -- parameter name test
  exception
    when others =>
      FAIL(TEST_MESSAGE&"UE");
  end;

  declare
    TEST_MESSAGE : MSG_TYPE := MAKE_MSG("unary - on INTEGER_VECTOR");
    V1 : INTEGER_VECTOR(3..5) := ( 3, -4, 7);
    function REF  (V : INTEGER_VECTOR) return INTEGER_VECTOR is
      C : INTEGER_VECTOR ( V'RANGE ) ;
    begin
      for I in V'RANGE loop
        C(I) := -V(I);
      end loop ;
      return C ;
    end REF;
  begin
    COMPARE( REF(V1), -V1, TEST_MESSAGE );
    V1 := "-"( RIGHT => V1 ); -- parameter name test
  exception
    when others =>
      FAIL(TEST_MESSAGE&"UE");
  end;

  declare
    TEST_MESSAGE : MSG_TYPE := MAKE_MSG("abs on INTEGER_VECTOR");
    V1 : INTEGER_VECTOR(3..5) := ( 3, -4, 7);
    function REF  (V : INTEGER_VECTOR) return INTEGER_VECTOR is
      C : INTEGER_VECTOR ( V'RANGE ) ;
    begin
      for I in V'RANGE loop
        C(I) := abs V(I);
      end loop ;
      return C ;
    end REF;
  begin
    COMPARE( REF(V1), abs V1, TEST_MESSAGE );
    V1 := "abs"( RIGHT => V1 ); -- parameter name test
  exception
    when others =>
      FAIL(TEST_MESSAGE&"UE");
  end;

  declare
    TEST_MESSAGE : MSG_TYPE := MAKE_MSG("+ on INTEGER_VECTORs");
    V1 : INTEGER_VECTOR(3..5) := ( 3, -4, 7);
    V2 : INTEGER_VECTOR(6..8) := (-6,  7, 9);
    VB : INTEGER_VECTOR(2..5) := ( 1, 2, 3, 4); -- raise exception
    function REF  (V, W : INTEGER_VECTOR) return INTEGER_VECTOR is
      C : INTEGER_VECTOR ( V'RANGE ) ;
    begin
      if V'LENGTH /= W'LENGTH then
        raise ARRAY_INDEX_ERROR ;
      end if ;
      for I in V'RANGE loop
        C(I) := V(I) + W(I-V'FIRST+W'FIRST) ;
      end loop ;
      return C ;
    end REF;
  begin
    COMPARE( REF(V1,V2), V1+V2, TEST_MESSAGE );
    begin
      V1 := V2 + VB;
      FAIL(TEST_MESSAGE&'E');
    exception
      when ARRAY_INDEX_ERROR =>
        PASS(TEST_MESSAGE&'E');
    end;
    V1 := "+"( LEFT => V1, RIGHT => V1 ); -- parameter name test
  exception
    when others =>
      FAIL(TEST_MESSAGE&"UE");
  end;

  declare
    TEST_MESSAGE : MSG_TYPE := MAKE_MSG("- on INTEGER_VECTORs");
    V1 : INTEGER_VECTOR(3..5) := ( 3, -4, 7);
    V2 : INTEGER_VECTOR(6..8) := (-6,  7, 9);
    VB : INTEGER_VECTOR(2..5) := ( 1, 2, 3, 4); -- raise exception
    function REF  (V, W : INTEGER_VECTOR) return INTEGER_VECTOR is
     C : INTEGER_VECTOR ( V'RANGE ) ;
    begin
      if V'LENGTH /= W'LENGTH then
        raise ARRAY_INDEX_ERROR ;
      end if ;
      for I in V'RANGE loop
        C(I) := V(I) - W(I-V'FIRST+W'FIRST) ;
      end loop ;
      return C ;
    end REF;
  begin
    COMPARE( REF(V1,V2), V1-V2, TEST_MESSAGE );
    begin
      V1 := V2 - VB;
      FAIL(TEST_MESSAGE&'E');
    exception
      when ARRAY_INDEX_ERROR =>
        PASS(TEST_MESSAGE&'E');
    end;
    V1 := "-"( LEFT => V1, RIGHT => V1 ); -- parameter name test
  exception
    when others =>
      FAIL(TEST_MESSAGE&"UE");
  end;

  declare
    TEST_MESSAGE : MSG_TYPE := MAKE_MSG("* on INTEGER_VECTORs");
    V1 : INTEGER_VECTOR(3..5) := ( 3, -4, 7);
    V2 : INTEGER_VECTOR(6..8) := (-6,  7, 9);
    VB : INTEGER_VECTOR(2..5) := ( 1, 2, 3, 4); -- raise exception
    function REF  (V, W : INTEGER_VECTOR) return INTEGER_VECTOR is
      C : INTEGER_VECTOR ( V'RANGE ) ;
    begin
      if V'LENGTH /= W'LENGTH then
        raise ARRAY_INDEX_ERROR ;
      end if ;
      for I in V'RANGE loop
        C(I) := V(I) * W(I-V'FIRST+W'FIRST) ;
      end loop ;
      return C ;
    end REF;
  begin
    COMPARE( REF(V1,V2), V1*V2, TEST_MESSAGE );
    begin
      V1 := V2 * VB;
      FAIL(TEST_MESSAGE&'E');
    exception
      when ARRAY_INDEX_ERROR =>
        PASS(TEST_MESSAGE&'E');
    end;
    V1 := "*"( LEFT => V1, RIGHT => V1 ); -- parameter name test
  exception
    when others =>
      FAIL(TEST_MESSAGE&"UE");
  end;

  declare
    TEST_MESSAGE : MSG_TYPE := MAKE_MSG("/ on INTEGER_VECTORs");
    V1 : INTEGER_VECTOR(3..5) := ( 3, -4, 8);
    V2 : INTEGER_VECTOR(6..8) := (-6,  4, 4);
    VB : INTEGER_VECTOR(2..5) := ( 1, 2, 3, 4); -- raise exception
    function REF  (V, W : INTEGER_VECTOR) return INTEGER_VECTOR is
      C : INTEGER_VECTOR ( V'RANGE ) ;
    begin
      if V'LENGTH /= W'LENGTH then
        raise ARRAY_INDEX_ERROR ;
      end if ;
      for I in V'RANGE loop
        C(I) := V(I) / W(I-V'FIRST+W'FIRST) ;
        end loop ;
      return C ;
    end REF;
  begin
    COMPARE( REF(V1,V2), V1/V2, TEST_MESSAGE );
    begin
      V1 := V2 / VB;
      FAIL(TEST_MESSAGE&'E');
    exception
      when ARRAY_INDEX_ERROR =>
        PASS(TEST_MESSAGE&'E');
    end;
    V1 := "/"( LEFT => V1, RIGHT => V1 ); -- parameter name test
  exception
    when others =>
      FAIL(TEST_MESSAGE&"UE");
  end;

  declare
    TEST_MESSAGE : MSG_TYPE := MAKE_MSG("** on INTEGER_VECTORs");
    V1 : INTEGER_VECTOR(3..5) := ( 3, -4, 7);
    NN : INTEGER := 3;
    function REF (V : INTEGER_VECTOR; 
                  N : INTEGER) return INTEGER_VECTOR is
      C : INTEGER_VECTOR ( V'RANGE ) ;
    begin
      for I in V'RANGE loop
        C(I) := V(I) ** N;
      end loop ;
      return C ;
    end REF;
  begin
    COMPARE( REF(V1,NN), V1**NN, TEST_MESSAGE );
    V1 := "**"( LEFT => V1, RIGHT => NN ); -- parameter name test
  exception
    when others =>
      FAIL(TEST_MESSAGE&"UE");
  end;

  declare
    TEST_MESSAGE : MSG_TYPE := MAKE_MSG("* on INTEGER_VECTORs returning INTEGER");
    V1 : INTEGER_VECTOR(3..5) := ( 3, -4, 7);
    V2 : INTEGER_VECTOR(6..8) := (-6,  7, 9);
    VB : INTEGER_VECTOR(2..5) := ( 1, 2, 3, 4); -- raise exception
    XX : INTEGER_TYPE;
    function REF  (V, W : INTEGER_VECTOR) return INTEGER_TYPE is
      X : INTEGER_TYPE := 0 ;
      TEMP : INTEGER_TYPE := 0;
    begin
      if V'LENGTH /= W'LENGTH then
        raise ARRAY_INDEX_ERROR ;
      end if ;
      for I in V'RANGE loop
        TEMP := V(I) * W(I-V'FIRST+W'FIRST) ;
        X := X + TEMP * TEMP ;
      end loop ;
      return X;
    end REF;
  begin
    COMPARE( REF(V1,V2), V1*V2, TEST_MESSAGE );
    begin
      XX := V2 * VB;
      FAIL(TEST_MESSAGE&'E');
    exception
      when ARRAY_INDEX_ERROR =>
        PASS(TEST_MESSAGE&'E');
    end;
    XX := "*"( LEFT => V1, RIGHT => V1 ); -- parameter name test
  exception
    when others =>
      FAIL(TEST_MESSAGE&"UE");
  end;

  -- VECTOR scaling operations --

  declare
    TEST_MESSAGE : MSG_TYPE := MAKE_MSG("* scale on INTEGER_VECTOR");
    V1 : INTEGER_VECTOR(3..5) := ( 3, -4, 7);
    XX : INTEGER_TYPE := 5;
    function REF  (X : INTEGER_TYPE;
                   V : INTEGER_VECTOR) return INTEGER_VECTOR is
      C : INTEGER_VECTOR ( V'RANGE ) ;
    begin
      for I in V'RANGE loop
        C(I) := X * V(I);
      end loop ;
      return C ;
    end REF;
  begin
    COMPARE( REF(XX,V1), XX*V1, TEST_MESSAGE );
    V1 := "*"( LEFT => XX, RIGHT => V1); -- parameter name test
  exception
    when others =>
      FAIL(TEST_MESSAGE&"UE");
  end;

  declare
    TEST_MESSAGE : MSG_TYPE := MAKE_MSG("* scale 2 on INTEGER_VECTOR");
    V1 : INTEGER_VECTOR(3..5) := ( 3, -4, 7);
    XX : INTEGER_TYPE := 5;
    function REF (V : INTEGER_VECTOR;
                  X : INTEGER_TYPE) return INTEGER_VECTOR is
      C : INTEGER_VECTOR ( V'RANGE ) ;
    begin
      for I in V'RANGE loop
        C(I) := V(I) * X;
      end loop ;
      return C ;
    end REF;
  begin
    COMPARE( REF(V1,XX), V1*XX, TEST_MESSAGE );
    V1 := "*"( LEFT => V1, RIGHT => XX ); -- parameter name test
  exception
    when others =>
      FAIL(TEST_MESSAGE&"UE");
  end;

  declare
    TEST_MESSAGE : MSG_TYPE := MAKE_MSG("/ scale on INTEGER_VECTOR");
    V1 : INTEGER_VECTOR(3..5) := ( 3, -4, 7);
    XX : INTEGER_TYPE := 4;
    function REF (V : INTEGER_VECTOR;
                  X : INTEGER_TYPE) return INTEGER_VECTOR is
      C : INTEGER_VECTOR ( V'RANGE ) ;
    begin
      for I in V'RANGE loop
        C(I) := V(I) / X;
      end loop ;
      return C ;
    end REF;
  begin
    COMPARE( REF(V1,XX), V1/XX, TEST_MESSAGE );
    V1 := "/"( LEFT => V1, RIGHT => XX ); -- parameter name test
  exception
    when others =>
      FAIL(TEST_MESSAGE&"UE");
  end;

  -- other operations --

  declare
    TEST_MESSAGE : MSG_TYPE := MAKE_MSG("UNIT_VECTOR");
    V1 : INTEGER_VECTOR(3..5) := ( 3, -4, 7);
    function REF (INDEX : INTEGER;
                  ORDER : NATURAL;
                  FIRST : INTEGER := 1 ) return INTEGER_VECTOR is
      C : INTEGER_VECTOR ( FIRST..FIRST+ORDER-1) ;
    begin
      if INDEX < FIRST or INDEX > FIRST+ORDER-1 then
        raise ARRAY_INDEX_ERROR;
      end if;
      for I in C'RANGE loop
        C(I) := 0;
      end loop ;
      C(INDEX) := 1;
      return C ;
    end REF;
  begin
    COMPARE( REF(9,5,7), UNIT_VECTOR(9,5,7), TEST_MESSAGE&'1' );
    COMPARE( REF(5,5), UNIT_VECTOR(5,5), TEST_MESSAGE&'2' );
    begin
      V1 := UNIT_VECTOR(ZERO,ZERO,ZERO); -- can not have null unit vector
      FAIL(TEST_MESSAGE&"E1");
    exception
      when ARRAY_INDEX_ERROR =>
        PASS(TEST_MESSAGE&"E1");
    end;
    begin
      V1 := UNIT_VECTOR(3,5,7);
      FAIL(TEST_MESSAGE&"E2");
    exception
      when ARRAY_INDEX_ERROR =>
        PASS(TEST_MESSAGE&"E2");
    end;
    begin
      V1 := UNIT_VECTOR(INTEGER'LAST-3,5,INTEGER'LAST-3);
      FAIL(TEST_MESSAGE&"E3a");
    exception
      when CONSTRAINT_ERROR =>
        PASS(TEST_MESSAGE&"E3");
      when ARRAY_INDEX_ERROR =>
        FAIL(TEST_MESSAGE&"E3b");
    end;
    V1 := UNIT_VECTOR( INDEX => -2, ORDER => 3, FIRST => -3 );
                               -- parameter name test
  exception
    when others =>
      FAIL(TEST_MESSAGE&"UE");
  end;


-- SUBPROGRAMS for INTEGER_MATRIX TYPES --

  -- MATRIX arithmetic operations --

  declare
    TEST_MESSAGE : MSG_TYPE := MAKE_MSG("unary + on INTEGER_MATRIX");
    A1 : INTEGER_MATRIX(3..4,-3..-1) := (( 3, -4, 7),(-2, 1, -6));
    function REF  (A : INTEGER_MATRIX) return INTEGER_MATRIX is
    begin
      return A ;
    end REF;
  begin
    COMPARE( REF(A1), +A1, TEST_MESSAGE );
    A1 := "+"( RIGHT => A1 ); -- parameter name test
  exception
    when others =>
      FAIL(TEST_MESSAGE&"UE");
  end;

  declare
    TEST_MESSAGE : MSG_TYPE := MAKE_MSG("unary - on INTEGER_MATRIX");
    A1 : INTEGER_MATRIX(3..4,-3..-1) := (( 3, -4, 7),(-2, 1, -6));
    function REF  (A : INTEGER_MATRIX) return INTEGER_MATRIX is
      C : INTEGER_MATRIX ( A'RANGE(1), A'RANGE(2)) ;
    begin
      for I in A'RANGE(1) loop
        for J in A'RANGE(2) loop
          C(I,J) := -A(I,J);
        end loop ;
      end loop ;
      return C ;
    end REF;
  begin
    COMPARE( REF(A1), -A1, TEST_MESSAGE );
    A1 := "-"( RIGHT => A1 ); -- parameter name test
  exception
    when others =>
      FAIL(TEST_MESSAGE&"UE");
  end;

  declare
    TEST_MESSAGE : MSG_TYPE := MAKE_MSG("abs on INTEGER_MATRIX");
    A1 : INTEGER_MATRIX(3..4,-3..-1) := (( 3, -4, 7),(-2, 1, -6));
    function REF  (A : INTEGER_MATRIX) return INTEGER_MATRIX is
      C : INTEGER_MATRIX ( A'RANGE(1), A'RANGE(2)) ;
    begin
      for I in A'RANGE(1) loop
        for J in A'RANGE(2) loop
          C(I,J) := abs A(I,J);
        end loop ;
      end loop ;
      return C ;
    end REF;
  begin
    COMPARE( REF(A1), abs A1, TEST_MESSAGE );
    A1 := "abs"( RIGHT => A1 ); -- parameter name test
  exception
    when others =>
      FAIL(TEST_MESSAGE&"UE");
  end;

  declare
    TEST_MESSAGE : MSG_TYPE := MAKE_MSG("TRANSPOSE on INTEGER_MATRIX");
    A1 : INTEGER_MATRIX(3..4,-3..-1) := (( 3, -4, 7),(-2, 1, -6));
    A2 : INTEGER_MATRIX(6..8,-1..0);
    function REF  (A : INTEGER_MATRIX) return INTEGER_MATRIX is
      C : INTEGER_MATRIX ( A'RANGE(2), A'RANGE(1)) ;
    begin
      for I in A'RANGE(1) loop
        for J in A'RANGE(2) loop
          C(J,I) :=  A(I,J);
        end loop ;
      end loop ;
      return C ;
    end REF;
  begin
    COMPARE( REF(A1), TRANSPOSE(A1), TEST_MESSAGE );
    A2 := TRANSPOSE( X => A1 ); -- parameter name test
  exception
    when others =>
      FAIL(TEST_MESSAGE&"UE");
  end;

  declare
    TEST_MESSAGE : MSG_TYPE := MAKE_MSG("+ on INTEGER_MATRIXs");
    A1 : INTEGER_MATRIX(3..4,-3..-1) := (( 3, -4, 7),(-2, 1,-6));
    A2 : INTEGER_MATRIX(6..7,-1..1) :=  ((-6,  7, 9),( 3,-2, 5));
    AB : INTEGER_MATRIX(2..3,4..5) := (( 1, 2),( 3, 4)); -- raise exception
    function REF  (A, B : INTEGER_MATRIX) return INTEGER_MATRIX is
      C : INTEGER_MATRIX ( A'RANGE(1), A'RANGE(2)) ;
    begin
      if A'LENGTH(1) /= B'LENGTH(1) or
         A'LENGTH(2) /= B'LENGTH(2) then
        raise ARRAY_INDEX_ERROR ;
      end if ;
      for I in A'RANGE(1) loop
        for J in A'RANGE(2) loop
          C(I,J) := A(I,J) + B(I-A'FIRST(1)+B'FIRST(1),
                               J-A'FIRST(2)+B'FIRST(2)) ;
        end loop ;
     end loop ;
      return C ;
    end REF;
  begin
    COMPARE( REF(A1,A2), A1+A2, TEST_MESSAGE );
    begin
      A1 := A2 + AB;
      FAIL(TEST_MESSAGE&'E');
    exception
      when ARRAY_INDEX_ERROR =>
        PASS(TEST_MESSAGE&'E');
    end;
    A1 := "+"( LEFT => A1, RIGHT => A1 ); -- parameter name test
  exception
    when others =>
      FAIL(TEST_MESSAGE&"UE");
  end;

  declare
    TEST_MESSAGE : MSG_TYPE := MAKE_MSG("- on INTEGER_MATRIXs");
    A1 : INTEGER_MATRIX(3..4,-3..-1) := (( 3, -4, 7),(-2, 1,-6));
    A2 : INTEGER_MATRIX(6..7,-1..1) :=  ((-6,  7, 9),( 3,-2, 5));
    AB : INTEGER_MATRIX(2..3,4..5) := (( 1, 2),( 3, 4)); -- raise exception
    function REF  (A, B : INTEGER_MATRIX) return INTEGER_MATRIX is
        C : INTEGER_MATRIX ( A'RANGE(1), A'RANGE(2)) ;
    begin
      if A'LENGTH(1) /= B'LENGTH(1) or
         A'LENGTH(2) /= B'LENGTH(2) then
        raise ARRAY_INDEX_ERROR ;
      end if ;
      for I in A'RANGE(1) loop
        for J in A'RANGE(2) loop
          C(I,J) := A(I,J) - B(I-A'FIRST(1)+B'FIRST(1),
                               J-A'FIRST(2)+B'FIRST(2)) ;
        end loop ;
      end loop ;
      return C ;
    end REF;
  begin
    COMPARE( REF(A1,A2), A1-A2, TEST_MESSAGE );
    begin
      A1 := A2 - AB;
      FAIL(TEST_MESSAGE&'E');
    exception
      when ARRAY_INDEX_ERROR =>
        PASS(TEST_MESSAGE&'E');
    end;
    A1 := "-"( LEFT => A1, RIGHT => A1 ); -- parameter name test
  exception
    when others =>
      FAIL(TEST_MESSAGE&"UE");
  end;

  declare
    TEST_MESSAGE : MSG_TYPE := MAKE_MSG("* on INTEGER_MATRIXs");
    A1 : INTEGER_MATRIX(3..4,-3..-1) := (( 3,-4, 7),(-2, 1,-6));
    A2 : INTEGER_MATRIX(6..8,-1..1) :=  ((-6, 7, 9),
                                      ( 3,-2, 5),
                                      ( 1,-6, 4));
    AB : INTEGER_MATRIX(2..3,4..5) := (( 1, 2),( 3, 4)); -- raise exception
    function REF  (A, B : INTEGER_MATRIX) return INTEGER_MATRIX is
        C : INTEGER_MATRIX ( A'RANGE(1) , B'RANGE(2)) ;
    begin
      if A'LENGTH(2) /= B'LENGTH(1) then
        raise ARRAY_INDEX_ERROR ;
      end if ;
      for I in A'RANGE(1) loop
        for J in B'RANGE(2) loop
          C(I,J) := 0 ;
          for K in A'RANGE(2) loop
            C(I,J) := C(I,J) + A(I,K) * B(K-A'FIRST(2)+B'FIRST(1),J) ;
          end loop ;
        end loop ;
      end loop ;
      return C ;
    end REF;
  begin
    COMPARE( REF(A1,A2), A1*A2, TEST_MESSAGE );
    begin
      A1 := A2 * AB;
      FAIL(TEST_MESSAGE&'E');
    exception
      when ARRAY_INDEX_ERROR =>
        PASS(TEST_MESSAGE&'E');
    end;
    A1 := "*"( LEFT => A1, RIGHT => A2 ); -- parameter name test
  exception
    when others =>
      FAIL(TEST_MESSAGE&"UE");
  end;

  declare
    TEST_MESSAGE : MSG_TYPE := MAKE_MSG("* on INTEGER_VECTOR, INTEGER_VECTOR");
    V1 : INTEGER_VECTOR(-1..1) :=  (-6, 7, 9);
    V2 : INTEGER_VECTOR(7..8) := (3, -4);
    VB : INTEGER_VECTOR(2..4) := (1, 2, 3); -- raise exception
    A1 : INTEGER_MATRIX(0..2,-1..0);
    function REF (V, W : INTEGER_VECTOR) return INTEGER_MATRIX is
      C : INTEGER_MATRIX ( V'RANGE, W'RANGE) ;
    begin
      for I in V'RANGE loop
        for J in W'RANGE loop
          C(I,J) :=  V(I) * W(J);
        end loop ;
      end loop ;
      return C ;
    end REF;
  begin
    COMPARE( REF(V1,V2), V1*V2, TEST_MESSAGE );
    A1 := "*"( LEFT => V1, RIGHT => V2 ); -- parameter name test
  exception
    when others =>
      FAIL(TEST_MESSAGE&"UE");
  end;

  declare
    TEST_MESSAGE : MSG_TYPE := MAKE_MSG("* on INTEGER_VECTOR, INTEGER_MATRIX");
    A1 : INTEGER_MATRIX(-3..-1,3..4) := (( 3,-4),( 7,-2),( 1,-6));
    V1 : INTEGER_VECTOR(-1..1) :=  (-6, 7, 9);
    VB : INTEGER_VECTOR(2..3) := (1, 2); -- raise exception
    V2 : INTEGER_VECTOR(7..8);
    function REF (V : INTEGER_VECTOR;
                  A : INTEGER_MATRIX) return INTEGER_VECTOR is
      CV : INTEGER_VECTOR ( A'RANGE(2)) ;
      SUM : INTEGER_TYPE ;
    begin
      if A'LENGTH(1) /= V'LENGTH then
        raise ARRAY_INDEX_ERROR ;
      end if ;
      for J in A'RANGE(2) loop
        SUM := 0 ;
        for I in A'RANGE(1) loop
          SUM := SUM + V(I-A'FIRST(1)+V'FIRST) * A(I,J) ;
        end loop ;
        CV(J) := SUM ;
      end loop ;
      return CV ;
    end REF;
  begin
    COMPARE( REF(V1,A1), V1*A1, TEST_MESSAGE );
    begin
      V2 := VB * A1;
      FAIL(TEST_MESSAGE&'E');
    exception
      when ARRAY_INDEX_ERROR =>
        PASS(TEST_MESSAGE&'E');
    end;
    V2 := "*"( LEFT => V1, RIGHT => A1 ); -- parameter name test
  exception
    when others =>
      FAIL(TEST_MESSAGE&"UE");
  end;

  declare
    TEST_MESSAGE : MSG_TYPE := MAKE_MSG("* on INTEGER_MATRIX, INTEGER_VECTOR");
    A1 : INTEGER_MATRIX(3..4,-3..-1) := (( 3,-4, 7),(-2, 1,-6));
    V1 : INTEGER_VECTOR(-1..1) :=  (-6, 7, 9);
    VB : INTEGER_VECTOR(2..3) := (1, 2); -- raise exception
    V2 : INTEGER_VECTOR(7..8);
    function REF (A : INTEGER_MATRIX;
                  V : INTEGER_VECTOR) return INTEGER_VECTOR is
      CV : INTEGER_VECTOR ( A'RANGE(1)) ;
      SUM : INTEGER_TYPE ;
    begin
      if A'LENGTH(2) /= V'LENGTH then
        raise ARRAY_INDEX_ERROR ;
      end if ;
      for I in A'RANGE(1) loop
        SUM := 0 ;
        for J in A'RANGE(2) loop
          SUM := SUM + V(J-A'FIRST(2)+V'FIRST) * A(I,J) ;
        end loop ;
        CV(I) := SUM ;
      end loop ;
      return CV ;
    end REF;
  begin
    COMPARE( REF(A1,V1), A1*V1, TEST_MESSAGE );
    begin
      V2 := A1 * VB;
      FAIL(TEST_MESSAGE&'E');
    exception
      when ARRAY_INDEX_ERROR =>
        PASS(TEST_MESSAGE&'E');
    end;
    V2 := "*"( LEFT => A1, RIGHT => V1 ); -- parameter name test
  exception
    when others =>
      FAIL(TEST_MESSAGE&"UE");
  end;

  -- MATRIX scaling operations --

  declare
    TEST_MESSAGE : MSG_TYPE := MAKE_MSG("* scale on INTEGER_MATRIX");
    A1 : INTEGER_MATRIX(3..5,-1..0) := (( 3, -4),( 7, 1),( 6, -5));
    XX : INTEGER_TYPE := 5;
    function REF (X : INTEGER_TYPE;
                  A : INTEGER_MATRIX) return INTEGER_MATRIX is
      C : INTEGER_MATRIX ( A'RANGE(1), A'RANGE(2)) ;
    begin
      for I in A'RANGE(1) loop
        for J in A'RANGE(2) loop
          C(I,J) := X * A(I,J);
        end loop ;
      end loop ;
      return C ;
    end REF;
  begin
    COMPARE( REF(XX,A1), XX*A1, TEST_MESSAGE );
    A1 := "*"( LEFT => XX, RIGHT => A1); -- parameter name test
  exception
    when others =>
      FAIL(TEST_MESSAGE&"UE");
  end;

  declare
    TEST_MESSAGE : MSG_TYPE := MAKE_MSG("* scale 2 on INTEGER_MATRIX");
    A1 : INTEGER_MATRIX(3..5,-1..0) := (( 3, -4),( 7, 1),( 6, -5));
    XX : INTEGER_TYPE := 5;
    function REF (A : INTEGER_MATRIX;
                  X : INTEGER_TYPE) return INTEGER_MATRIX is
      C : INTEGER_MATRIX ( A'RANGE(1), A'RANGE(2)) ;
    begin
      for I in A'RANGE(1) loop
        for J in A'RANGE(2) loop
          C(I,J) := A(I,J)* X;
        end loop ;
      end loop ;
      return C ;
    end REF;
  begin
    COMPARE( REF(A1,XX), A1*XX, TEST_MESSAGE );
    A1 := "*"( LEFT => A1, RIGHT => XX); -- parameter name test
  exception
    when others =>
      FAIL(TEST_MESSAGE&"UE");
  end;


  declare
    TEST_MESSAGE : MSG_TYPE := MAKE_MSG("/ scale on INTEGER_MATRIX");
    A1 : INTEGER_MATRIX(3..5,-1..0) := (( 3, -4),( 7, 1),( 6, -5));
    XX : INTEGER_TYPE := 4;
    function REF (A : INTEGER_MATRIX;
                  X : INTEGER_TYPE) return INTEGER_MATRIX is
      C : INTEGER_MATRIX ( A'RANGE(1), A'RANGE(2)) ;
    begin
      for I in A'RANGE(1) loop
        for J in A'RANGE(2) loop
          C(I,J) := A(I,J) / X;
        end loop ;
      end loop ;
      return C ;
    end REF;
  begin
    COMPARE( REF(A1,XX), A1/XX, TEST_MESSAGE );
    A1 := "/"( LEFT => A1, RIGHT => XX); -- parameter name test
  exception
    when others =>
      FAIL(TEST_MESSAGE&"UE");
  end;


  -- other operations --

  declare
    TEST_MESSAGE : MSG_TYPE := MAKE_MSG("IDENTITY_MATRIX");
    A1 : INTEGER_MATRIX(3..5,-1..1);
    function REF (ORDER : NATURAL;
                  FIRST_1,FIRST_2 : INTEGER := 1)
                  return INTEGER_MATRIX is
      A : INTEGER_MATRIX ( FIRST_1..FIRST_1+ORDER-1, FIRST_2..FIRST_2+ORDER-1) ;
    begin
      for I in A'RANGE(1) loop
        for J in A'RANGE(2) loop
          A(I,J) := 0 ;
        end loop ;
        A(I,I-A'FIRST(1)+A'FIRST(2)) := 1 ;
      end loop ;
      return A ;
    end REF;
  begin
    COMPARE( REF(9,5,-3), IDENTITY_MATRIX(9,5,-3), TEST_MESSAGE&'1' );
    COMPARE( REF(5,5), IDENTITY_MATRIX(5,5), TEST_MESSAGE&'2' );
    COMPARE( REF(6), IDENTITY_MATRIX(6), TEST_MESSAGE&'3' );
    begin
      A1 := IDENTITY_MATRIX(3,1,INTEGER'LAST-2);
      FAIL(TEST_MESSAGE&"E2");
    exception
      when CONSTRAINT_ERROR =>
        PASS(TEST_MESSAGE&"E2");
    end;
    begin
      A1 := IDENTITY_MATRIX(3,INTEGER'LAST-2);
      FAIL(TEST_MESSAGE&"E3a");
    exception
      when CONSTRAINT_ERROR =>
        PASS(TEST_MESSAGE&"E3");
    end;
    A1 := IDENTITY_MATRIX( ORDER => 3, FIRST_1 => -3 , FIRST_2 => -2 );
                               -- parameter name test
  exception
    when others =>
      FAIL(TEST_MESSAGE&"UE");
  end;

  REPORT_RESULTS;

end TEST_GENERIC_INTEGER_ARRAYS;