CristalCaveGem » LustreC » Lustrec-Tests

-- Copyright (C) 1996 Morgan Kaufmann Publishers, Inc

-- This file is part of VESTs (Vhdl tESTs).

-- VESTs is free software; you can redistribute it and/or modify it

-- under the terms of the GNU General Public License as published by the

-- Free Software Foundation; either version 2 of the License, or (at

-- your option) any later version. 

-- VESTs 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 General Public License

-- for more details. 

-- You should have received a copy of the GNU General Public License

-- along with VESTs; if not, write to the Free Software Foundation,

-- Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 

-- ---------------------------------------------------------------------

--

-- $Id: ch_10_bvat-b.vhd,v 1.3 2001-10-26 16:29:35 paw Exp $

-- $Revision: 1.3 $

--

-- ---------------------------------------------------------------------

library bv_utilities;

use std.textio.all, bv_utilities.bv_arithmetic.all;

architecture bench of bv_test is

begin

  process is

            variable L : line;

          variable byte : bit_vector(0 to 7);

          variable word : bit_vector(1 to 32);

          variable half_byte : bit_vector(1 to 4);

          variable overflow, div_by_zero, result : boolean;

  begin

    wait for 1 ns;

    ----------------------------------------------------------------

    ----------------------------------------------------------------

    -- test bit_vector to numeric conversions

    ----------------------------------------------------------------

    ----------------------------------------------------------------

    write(L, string'("Testing bv_to_natural:"));

    writeline(output, L);

    write(L, string'("  bv_to_natural(X""02"") = "));

    write(L, bv_to_natural(X"02"));

    writeline(output, L);

    assert bv_to_natural(X"02") = 2;

    write(L, string'("  bv_to_natural(X""FE"") = "));

    write(L, bv_to_natural(X"FE"));

    writeline(output, L);

    assert bv_to_natural(X"FE") = 254;

    ----------------------------------------------------------------

    write(L, string'("Testing natural_to_bv:"));

    writeline(output, L);

    write(L, string'("  natural_to_bv(2) = "));

    write(L, natural_to_bv(2, 8));

    writeline(output, L);

    assert natural_to_bv(2, 8) = X"02";

    write(L, string'("  natural_to_bv(254) = "));

    write(L, natural_to_bv(254, 8));

    writeline(output, L);

    assert natural_to_bv(254, 8) = X"FE";

    ----------------------------------------------------------------

    write(L, string'("Testing bv_to_integer:"));

    writeline(output, L);

    write(L, string'("  bv_to_integer(X""02"") = "));

    write(L, bv_to_integer(X"02"));

    writeline(output, L);

    assert bv_to_integer(X"02") = 2;

    write(L, string'("  bv_to_integer(X""FE"") = "));

    write(L, bv_to_integer(X"FE"));

    writeline(output, L);

    assert bv_to_integer(X"FE") = -2;

    ----------------------------------------------------------------

    write(L, string'("Testing integer_to_bv:"));

    writeline(output, L);

    write(L, string'("  integer_to_bv(2) = "));

    write(L, integer_to_bv(2, 8));

    writeline(output, L);

    assert integer_to_bv(2, 8) = X"02";

    write(L, string'("  integer_to_bv(-2) = "));

    write(L, integer_to_bv(-2, 8));

    writeline(output, L);

    assert integer_to_bv(-2, 8) = X"FE";

    ----------------------------------------------------------------

    ----------------------------------------------------------------

    --  Arithmetic operations

    ----------------------------------------------------------------

    ----------------------------------------------------------------

    ----------------------------------------------------------------

    -- bv_add: Signed addition with overflow detection

    ----------------------------------------------------------------

    writeline(output, L);

    write(L, string'("Testing bv_add with overflow:"));

    writeline(output, L);

    write(L, string'("  2+2 = "));

    bv_add(X"02", X"02", byte, overflow);

    write(L, byte);

    write(L, string'(", overflow = "));  write(L, overflow);

    writeline(output, L);

    assert byte = X"04" and not overflow;

    write(L, string'("  2+(-3) = "));

    bv_add(X"02", X"FD", byte, overflow);

    write(L, byte);

    write(L, string'(", overflow = "));  write(L, overflow);

    writeline(output, L);

    assert byte = X"FF" and not overflow;

    write(L, string'("  64+64 = "));

    bv_add(X"40", X"40", byte, overflow);

    write(L, byte);

    write(L, string'(", overflow = "));  write(L, overflow);

    writeline(output, L);

    assert byte = X"80" and overflow;

    write(L, string'("  -64+(-64) = "));

    bv_add(X"C0", X"C0", byte, overflow);

    write(L, byte);

    write(L, string'(", overflow = "));  write(L, overflow);

    writeline(output, L);

    assert byte = X"80" and not overflow;

    ----------------------------------------------------------------

    -- "+": Signed addition without overflow detection

    ----------------------------------------------------------------

    writeline(output, L);

    write(L, string'("Testing ""+"" without overflow:"));

    writeline(output, L);

    write(L, string'("  2+2 = "));

    byte := X"02" + X"02";

    write(L, byte);

    writeline(output, L);

    assert byte = X"04";

    write(L, string'("  2+(-3) = "));

    byte := X"02" + X"FD";

    write(L, byte);

    writeline(output, L);

    assert byte = X"FF";

    write(L, string'("  64+64 = "));

    byte := X"40" + X"40";

    write(L, byte);

    writeline(output, L);

    assert byte = X"80";

    write(L, string'("  -64+(-64) = "));

    byte := X"C0" + X"C0";

    write(L, byte);

    writeline(output, L);

    assert byte = X"80";

    ----------------------------------------------------------------

    -- bv_sub: Signed subtraction with overflow detection

    ----------------------------------------------------------------

    writeline(output, L);

    write(L, string'("Testing bv_sub with overflow:"));

    writeline(output, L);

    write(L, string'("  2-2 = "));

    bv_sub(X"02", X"02", byte, overflow);

    write(L, byte);

    write(L, string'(", overflow = "));  write(L, overflow);

    writeline(output, L);

    assert byte = X"00" and not overflow;

    write(L, string'("  2-(-3) = "));

    bv_sub(X"02", X"FD", byte, overflow);

    write(L, byte);

    write(L, string'(", overflow = "));  write(L, overflow);

    writeline(output, L);

    assert byte = X"05" and not overflow;

    write(L, string'("  64-(-64) = "));

    bv_sub(X"40", X"C0", byte, overflow);

    write(L, byte);

    write(L, string'(", overflow = "));  write(L, overflow);

    writeline(output, L);

    assert byte = X"80" and overflow;

    write(L, string'("  -64-64 = "));

    bv_sub(X"C0", X"40", byte, overflow);

    write(L, byte);

    write(L, string'(", overflow = "));  write(L, overflow);

    writeline(output, L);

    assert byte = X"80" and not overflow;

    ----------------------------------------------------------------

    -- "-": Signed subtraction without overflow detection

    ----------------------------------------------------------------

    writeline(output, L);

    write(L, string'("Testing ""-"" without overflow:"));

    writeline(output, L);

    write(L, string'("  2-2 = "));

    byte := X"02" - X"02";

    write(L, byte);

    writeline(output, L);

    assert byte = X"00";

    write(L, string'("  2-(-3) = "));

    byte := X"02" - X"FD";

    write(L, byte);

    writeline(output, L);

    assert byte = X"05";

    write(L, string'("  64-(-64) = "));

    byte := X"40" - X"C0";

    write(L, byte);

    writeline(output, L);

    assert byte = X"80";

    write(L, string'("  -64-64 = "));

    byte := X"C0" - X"40";

    write(L, byte);

    writeline(output, L);

    assert byte = X"80";

    ----------------------------------------------------------------

    -- bv_addu:  Unsigned addition with overflow detection

    ----------------------------------------------------------------

    writeline(output, L);

    write(L, string'("Testing bv_addu with overflow:"));

    writeline(output, L);

    write(L, string'("  2+2 = "));

    bv_addu(X"02", X"02", byte, overflow);

    write(L, byte);

    write(L, string'(", overflow = "));  write(L, overflow);

    writeline(output, L);

    assert byte = X"04" and not overflow;

    write(L, string'("  64+64 = "));

    bv_addu(X"40", X"40", byte, overflow);

    write(L, byte);

    write(L, string'(", overflow = "));  write(L, overflow);

    writeline(output, L);

    assert byte = X"80" and not overflow;

    write(L, string'("  128+128 = "));

    bv_addu(X"80", X"80", byte, overflow);

    write(L, byte);

    write(L, string'(", overflow = "));  write(L, overflow);

    writeline(output, L);

    assert byte = X"00" and overflow;

    ----------------------------------------------------------------

    -- bv_addu: Unsigned addition without overflow detection

    ----------------------------------------------------------------

    writeline(output, L);

    write(L, string'("Testing bv_addu without overflow:"));

    writeline(output, L);

    write(L, string'("  2+2 = "));

    byte := bv_addu(X"02", X"02");

    write(L, byte);

    writeline(output, L);

    assert byte = X"04";

    write(L, string'("  64+64 = "));

    byte := bv_addu(X"40", X"40");

    write(L, byte);

    writeline(output, L);

    assert byte = X"80";

    write(L, string'("  128+128 = "));

    byte := bv_addu(X"80", X"80");

    write(L, byte);

    writeline(output, L);

    assert byte = X"00";

    ----------------------------------------------------------------

    -- bv_subu: Unsigned subtraction with overflow detection

    ----------------------------------------------------------------

    writeline(output, L);

    write(L, string'("Testing bv_subu with overflow:"));

    writeline(output, L);

    write(L, string'("  3-2 = "));

    bv_subu(X"03", X"02", byte, overflow);

    write(L, byte);

    write(L, string'(", overflow = "));  write(L, overflow);

    writeline(output, L);

    assert byte = X"01" and not overflow;

    write(L, string'("  64-64 = "));

    bv_subu(X"40", X"40", byte, overflow);

    write(L, byte);

    write(L, string'(", overflow = "));  write(L, overflow);

    writeline(output, L);

    assert byte = X"00" and not overflow;

    write(L, string'("  64-128 = "));

    bv_subu(X"40", X"80", byte, overflow);

    write(L, byte);

    write(L, string'(", overflow = "));  write(L, overflow);

    writeline(output, L);

    assert byte = X"C0" and overflow;

    ----------------------------------------------------------------

    -- bv_subu: Unsigned subtraction without overflow detection

    ----------------------------------------------------------------

    writeline(output, L);

    write(L, string'("Testing bv_subu without overflow:"));

    writeline(output, L);

    write(L, string'("  3-2 = "));

    byte := bv_subu(X"03", X"02");

    write(L, byte);

    writeline(output, L);

    assert byte = X"01";

    write(L, string'("  64-64 = "));

    byte := bv_subu(X"40", X"40");

    write(L, byte);

    writeline(output, L);

    assert byte = X"00";

    write(L, string'("  64-128 = "));

    byte := bv_subu(X"40", X"80");

    write(L, byte);

    writeline(output, L);

    assert byte = X"C0";

    ----------------------------------------------------------------

    -- bv_neg: Signed negation with overflow detection

    ----------------------------------------------------------------

    writeline(output, L);

    write(L, string'("Testing bv_neg with overflow:"));

    writeline(output, L);

    write(L, string'("  -(3) = "));

    bv_neg(X"03", byte, overflow);

    write(L, byte);

    write(L, string'(", overflow = "));  write(L, overflow);

    writeline(output, L);

    assert byte = X"FD" and not overflow;

    write(L, string'("  -(-3) = "));

    bv_neg(X"FD", byte, overflow);

    write(L, byte);

    write(L, string'(", overflow = "));  write(L, overflow);

    writeline(output, L);

    assert byte = X"03" and not overflow;

    write(L, string'("  -(127) = "));

    bv_neg(X"7F", byte, overflow);

    write(L, byte);

    write(L, string'(", overflow = "));  write(L, overflow);

    writeline(output, L);

    assert byte = X"81" and not overflow;

    write(L, string'("  -(-128) = "));

    bv_neg(X"80", byte, overflow);

    write(L, byte);

    write(L, string'(", overflow = "));  write(L, overflow);

    writeline(output, L);

    assert byte = X"80" and overflow;

    ----------------------------------------------------------------

    -- "-": Signed negation without overflow detection

    ----------------------------------------------------------------

    writeline(output, L);

    write(L, string'("Testing ""-"" without overflow:"));

    writeline(output, L);

    write(L, string'("  -(3) = "));

    byte := - X"03";

    write(L, byte);

    writeline(output, L);

    assert byte = X"FD";

    write(L, string'("  -(-3) = "));

    byte := - X"FD";

    write(L, byte);

    writeline(output, L);

    assert byte = X"03";

    write(L, string'("  -(127) = "));

    byte := - X"7F";

    write(L, byte);

    writeline(output, L);

    assert byte = X"81";

    write(L, string'("  -(-128) = "));

    byte := - X"80";

    write(L, byte);

    writeline(output, L);

    assert byte = X"80";

    ----------------------------------------------------------------

    -- bv_mult: Signed multiplication with overflow detection

    ----------------------------------------------------------------

    writeline(output, L);

    write(L, string'("Testing bv_mult with overflow:"));

    writeline(output, L);

    write(L, string'("  5*(-3) = "));

    bv_mult(X"05", X"FD", byte, overflow);

    write(L, byte);

    write(L, string'(", overflow = "));  write(L, overflow);

    writeline(output, L);

    assert byte = X"F1" and not overflow;

    write(L, string'("  (-5)*(-3) = "));

    bv_mult(X"FB", X"FD", byte, overflow);

    write(L, byte);

    write(L, string'(", overflow = "));  write(L, overflow);

    writeline(output, L);

    assert byte = X"0F" and not overflow;

    write(L, string'("  16*8 = "));

    bv_mult(X"10", X"08", byte, overflow);

    write(L, byte);

    write(L, string'(", overflow = "));  write(L, overflow);

    writeline(output, L);

    assert byte = X"80" and overflow;

    write(L, string'("  16*16 = "));

    bv_mult(X"10", X"10", byte, overflow);

    write(L, byte);

    write(L, string'(", overflow = "));  write(L, overflow);

    writeline(output, L);

    assert byte = X"00" and overflow;

    write(L, string'("  16*(-8) = "));

    bv_mult(X"10", X"F8", byte, overflow);

    write(L, byte);

    write(L, string'(", overflow = "));  write(L, overflow);

    writeline(output, L);

    assert byte = X"80" and not overflow;

    write(L, string'("  16*(-16) = "));

    bv_mult(X"10", X"F0", byte, overflow);

    write(L, byte);

    write(L, string'(", overflow = "));  write(L, overflow);

    writeline(output, L);

    assert byte = X"00" and overflow;

    ----------------------------------------------------------------

    -- "*":  Signed multiplication without overflow detection

    ----------------------------------------------------------------

    writeline(output, L);

    write(L, string'("Testing ""*"" without overflow:"));

    writeline(output, L);

    write(L, string'("  5*(-3) = "));

    byte := X"05" * X"FD";

    write(L, byte);

    writeline(output, L);

    assert byte = X"F1";

    write(L, string'("  (-5)*(-3) = "));

    byte := X"FB" * X"FD";

    write(L, byte);

    writeline(output, L);

    assert byte = X"0F";

    write(L, string'("  16*8 = "));

    byte := X"10" * X"08";

    write(L, byte);

    writeline(output, L);

    assert byte = X"80";

    write(L, string'("  16*16 = "));

    byte := X"10" * X"10";

    write(L, byte);

    writeline(output, L);

    assert byte = X"00";

    write(L, string'("  16*(-8) = "));

    byte := X"10" * X"F8";

    write(L, byte);

    writeline(output, L);

    assert byte = X"80";

    write(L, string'("  16*(-16) = "));

    byte := X"10" * X"F0";

    write(L, byte);

    writeline(output, L);

    assert byte = X"00";

    ----------------------------------------------------------------

    -- bv_multu:  Unsigned multiplication with overflow detection

    ----------------------------------------------------------------

    writeline(output, L);

    write(L, string'("Testing bv_multu with overflow:"));

    writeline(output, L);

    write(L, string'("  5*7 = "));

    bv_multu(X"05", X"07", byte, overflow);

    write(L, byte);

    write(L, string'(", overflow = "));  write(L, overflow);

    writeline(output, L);

    assert byte = X"23" and not overflow;

    write(L, string'("  16*8 = "));

    bv_multu(X"10", X"08", byte, overflow);

    write(L, byte);

    write(L, string'(", overflow = "));  write(L, overflow);

    writeline(output, L);

    assert byte = X"80" and not overflow;

    write(L, string'("  16*16 = "));

    bv_multu(X"10", X"10", byte, overflow);

    write(L, byte);

    write(L, string'(", overflow = "));  write(L, overflow);

    writeline(output, L);

    assert byte = X"00" and overflow;

    ----------------------------------------------------------------

    --  bv_multu: Unsigned multiplication without overflow detection

    ----------------------------------------------------------------

    writeline(output, L);

    write(L, string'("Testing bv_multu without overflow:"));

    writeline(output, L);

    write(L, string'("  5*7 = "));

    byte := bv_multu(X"05", X"07");

    write(L, byte);

    writeline(output, L);

    assert byte = X"23";

    write(L, string'("  16*8 = "));

    byte := bv_multu(X"10", X"08");

    write(L, byte);

    writeline(output, L);

    assert byte = X"80";

    write(L, string'("  16*16 = "));

    byte := bv_multu(X"10", X"10");

    write(L, byte);

    writeline(output, L);

    assert byte = X"00";

    ----------------------------------------------------------------

    -- bv_div: Signed division with divide by zero and overflow detection

    ----------------------------------------------------------------

    writeline(output, L);

    write(L, string'("Testing bv_div with flags:"));

    writeline(output, L);

    write(L, string'("  7/2 = "));

    bv_div(X"07", X"02", byte, div_by_zero, overflow);

    write(L, byte);

    write(L, string'(", div_by_zero = "));  write(L, div_by_zero);

    write(L, string'(", overflow = "));  write(L, overflow);

    writeline(output, L);

    assert byte = X"03" and not div_by_zero and not overflow;

    write(L, string'("  -7/2 = "));

    bv_div(X"F9", X"02", byte, div_by_zero, overflow);

    write(L, byte);

    write(L, string'(", div_by_zero = "));  write(L, div_by_zero);

    write(L, string'(", overflow = "));  write(L, overflow);

    writeline(output, L);

    assert byte = X"FD" and not div_by_zero and not overflow;

    write(L, string'("  7/-2 = "));

    bv_div(X"07", X"FE", byte, div_by_zero, overflow);

    write(L, byte);

    write(L, string'(", div_by_zero = "));  write(L, div_by_zero);

    write(L, string'(", overflow = "));  write(L, overflow);

    writeline(output, L);

    assert byte = X"FD" and not div_by_zero and not overflow;

    write(L, string'("  -7/-2 = "));

    bv_div(X"F9", X"FE", byte, div_by_zero, overflow);

    write(L, byte);

    write(L, string'(", div_by_zero = "));  write(L, div_by_zero);

    write(L, string'(", overflow = "));  write(L, overflow);

    writeline(output, L);

    assert byte = X"03" and not div_by_zero and not overflow;

    write(L, string'("  -128/1 = "));

    bv_div(X"80", X"01", byte, div_by_zero, overflow);

    write(L, byte);

    write(L, string'(", div_by_zero = "));  write(L, div_by_zero);

    write(L, string'(", overflow = "));  write(L, overflow);

    writeline(output, L);

    assert byte = X"80" and not div_by_zero and not overflow;

    write(L, string'("  -128/-1 = "));

    bv_div(X"80", X"FF", byte, div_by_zero, overflow);

    write(L, byte);

    write(L, string'(", div_by_zero = "));  write(L, div_by_zero);

    write(L, string'(", overflow = "));  write(L, overflow);

    writeline(output, L);

    assert byte = X"80" and not div_by_zero and overflow;

    write(L, string'("  -16/0 = "));

    bv_div(X"F0", X"00", byte, div_by_zero, overflow);

    write(L, byte);

    write(L, string'(", div_by_zero = "));  write(L, div_by_zero);

    write(L, string'(", overflow = "));  write(L, overflow);

    writeline(output, L);

    assert byte = X"00" and div_by_zero and not overflow;

    ----------------------------------------------------------------

    -- "/": Signed division without divide by zero and overflow detection

    ----------------------------------------------------------------

    writeline(output, L);

    write(L, string'("Testing ""/"" without flags:"));

    writeline(output, L);

    write(L, string'("  7/2 = "));

    byte := X"07" / X"02";

    write(L, byte);

    writeline(output, L);

    assert byte = X"03";

    write(L, string'("  -7/2 = "));

    byte := X"F9" / X"02";

    write(L, byte);

    writeline(output, L);

    assert byte = X"FD";

    write(L, string'("  7/-2 = "));

    byte := X"07" / X"FE";

    write(L, byte);

    writeline(output, L);

    assert byte = X"FD";

    write(L, string'("  -7/-2 = "));

    byte := X"F9" / X"FE";

    write(L, byte);

    writeline(output, L);

    assert byte = X"03";

    write(L, string'("  -128/1 = "));

    byte := X"80" / X"01";

    write(L, byte);

    writeline(output, L);

    assert byte = X"80";

    write(L, string'("  -128/-1 = "));

    byte := X"80" / X"FF";

    write(L, byte);

    writeline(output, L);

    assert byte = X"80";

    write(L, string'("  -16/0 = "));

    byte := X"F0" / X"00";

    write(L, byte);

    writeline(output, L);

    assert byte = X"00";

    ----------------------------------------------------------------

    -- bv_divu: Unsigned division with divide by zero detection

    ----------------------------------------------------------------

    writeline(output, L);

    write(L, string'("Testing bv_divu with flag:"));

    writeline(output, L);

    write(L, string'("  7/2 = "));

    bv_divu(X"07", X"02", byte, div_by_zero);

    write(L, byte);

    write(L, string'(", div_by_zero = "));  write(L, div_by_zero);

    writeline(output, L);

    assert byte = X"03" and not div_by_zero;

    write(L, string'("  14/7 = "));

    bv_divu(X"0E", X"07", byte, div_by_zero);

    write(L, byte);

    write(L, string'(", div_by_zero = "));  write(L, div_by_zero);

    writeline(output, L);

    assert byte = X"02" and not div_by_zero;

    write(L, string'("  16/1 = "));

    bv_divu(X"10", X"01", byte, div_by_zero);

    write(L, byte);

    write(L, string'(", div_by_zero = "));  write(L, div_by_zero);

    writeline(output, L);

    assert byte = X"10" and not div_by_zero;

    write(L, string'("  16/0 = "));

    bv_divu(X"10", X"00", byte, div_by_zero);

    write(L, byte);

    write(L, string'(", div_by_zero = "));  write(L, div_by_zero);

    writeline(output, L);

    assert byte = X"10" and div_by_zero;

    write(L, string'("  16/16 = "));

    bv_divu(X"10", X"10", byte, div_by_zero);

    write(L, byte);

    write(L, string'(", div_by_zero = "));  write(L, div_by_zero);

    writeline(output, L);

    assert byte = X"01" and not div_by_zero;