Subversion Repositories sincos

 
--------------------------------------------------------------------------------
-- (c) 2005.. Hoffmann RF & DSP  opencores@hoffmann-hochfrequenz.de
-- V1.0 published under BSD license
--------------------------------------------------------------------------------
-- file name:      un_signed_sprt_tb.vhd
-- tool version:   Modelsim 6.1, 6.5
-- description:    test bed for signed / unsigned support library
-- calls libs:     ieee standard
-- calls entities: 
--------------------------------------------------------------------------------
 
 
 
library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
use ieee.math_real.all;
 
use work.un_signed_sprt.all;
 
entity un_signed_sprt_tb is 
begin 
end un_signed_sprt_tb;
 
 
architecture tb of un_signed_sprt_tb is
 
 
--------------------------------------------------------------------------------
 
procedure check_to_un_signed is
  variable s:   signed(7 downto 0);
  variable u: unsigned(7 downto 0);
  variable v: string(1 to 8);
begin
  report "Check_to_un_signed()";
 
 
  report "#### signed 0";      
  s := to_signed('0', s);
  if s = to_signed(0, 8)
  then
    report "passed";
  else
    report "s = <"  & signed2string(s) & ">,  should be 0";
  end if;
 
  report "#### signed X";      
  s := to_signed('X', s);
  if signed2string(s) = "XXXXXXXX" 
  then 
    report "passed";
  else
    report "s = <"  & signed2string(s) & ">,  should be XXXXXXXX";
  end if;
 
 
  report "#### signed -1";      
  s := to_signed('1', s);
  if  s = to_signed(-1, 8)
  then
    report "passed";
  else
    report "failed:  s 0 <" & signed2string(s) & ">, should be -1";
  end if;
 
 
  report "#### unsigned 0";      
  u := to_unsigned('0', u);
  if  u = to_unsigned(0, 8)
  then
    report "passed";
  else
    report "failed:  <" & unsigned2string(u) & ">, should be 0";
  end if;
 
 
  report "#### unsigned X";      
  u := to_unsigned('X', u);
  v := unsigned2string(u);
  if v = "XXXXXXXX" 
  then 
    report "passed";
  else
    report "u = <"  & unsigned2string(u) & ">,  should be XXXXXXXX";
  end if;
 
 
  report "#### unsigned 1";      
  u := to_unsigned('1', u);
  if u = to_unsigned(255, 8)
  then
    report "passed";
  else
    report  "<" & unsigned2string(u) & ">, should be 11111111";
  end if;
 
end procedure check_to_un_signed;
 
 
--------------------------------------------------------------------------------
 
procedure check_real2unsigned is
  variable u: unsigned (7 downto 0);
begin
  report "check_real2unsigned()";
 
  u := real2unsigned(0.0, u);
  assert to_integer(u) = 0;
 
  u := real2unsigned(255.0, u);
  assert to_integer(u) = 255;
 
  u := real2unsigned(256.0, u); -- must give warning
  assert to_integer(u) = 0;
 
  u := real2unsigned(-5.0, u);  -- must give warning
  assert to_integer(u) = 0;
end;
 
 
--------------------------------------------------------------------------------
procedure check_real2signed is
  variable s: signed (7 downto 0);
begin
  report "check_real2signed()";
 
  s := real2signed(0.0, s);
  assert to_integer(s) = 0;
 
  s := real2signed(7.0, s);
  assert to_integer(s) = 7;
 
  s := real2signed(127.0, s);
  assert to_integer(s) = 127;
 
  s := real2signed(-127.0, s);
  assert to_integer(s) = -127;
 
  s := real2signed(-128.0, s);  -- still must work
  assert to_integer(s) = -128;
 
  s := real2signed(128.0, s); -- must give warning
  assert to_integer(s) = 0;
 
  s := real2signed(-129.0, s);  -- must give warning
  assert to_integer(s) = 0;  
end;
 
--------------------------------------------------------------------------------
 
procedure check_unsigned2real is
  variable u: unsigned (7 downto 0);
begin
  report "check_unsigned2real";
 
  u := unsigned'("00000000");
  assert unsigned2real(u) = 0.0;
 
  u := unsigned'("00000100");
  assert unsigned2real(u) = 4.0;
 
  u := unsigned'("11111111");
  assert unsigned2real(u) = 255.0;
 
  u := unsigned'("0XXXXXXX");   -- must give warning
  assert unsigned2real(u) = 0.0;
 
  u := unsigned'("X0000000");   -- must give warning
  assert unsigned2real(u) = 0.0;
 
end;
 
 
--------------------------------------------------------------------------------
-- checking reals for equality is problematic b/c of precision
 
procedure check_signed2real is
  variable s: signed (7 downto 0);
  variable r: real;
begin
  report "check_signed2real()";
 
  s := signed'("00000000");
  assert signed2real(s) = 0.0;
 
  s := signed'("00000100");
  assert signed2real(s) = 4.0;
 
  s := signed'("11111011");
  r := signed2real(s);
  assert  r = -5.0;
 
  s := signed'("11111111");
  r := signed2real(s);
  assert r = -1.0;
 
  s := signed'("0XXXXXXX");   -- must give warning
  assert signed2real(s) = 0.0;
 
  s := signed'("X0000000");   -- must give warning
  assert signed2real(s) = 0.0;
 
end;
 
--------------------------------------------------------------------------------
 
procedure check_fract_unsigned2real is
  variable u:  unsigned (7 downto 0);
  variable u4: unsigned(3 downto 0);
  variable r:  real;
begin
  report "check_frac_unsigned2real()";
 
  u := unsigned'("00000000");  
  r := fract_unsigned2real(u);
  assert r = 0.0;
 
  u4 := unsigned'("0111"); 
  r := fract_unsigned2real(u4); 
  assert r = 1.0/4.0 + 1.0/8.0 + 1.0/16.0;  --  0.4375
 
  u := unsigned'("10000000");  
  r := fract_unsigned2real(u);
  assert r = 0.5;
 
  u4 := unsigned'("1111"); 
  r := fract_unsigned2real(u4);   
  assert r = 1.0/2.0 + 1.0/4.0 + 1.0/8.0 + 1.0/16.0;  -- 0.9375
 
 
 end;
 
--------------------------------------------------------------------------------
 
procedure check_fract_signed2real is
  variable s:  signed (7 downto 0);
  variable s4: signed (3 downto 0);
  variable r:  real;
begin
  report "check_frac_signed2real()";
 
  s := signed'("00000000");  
  r := fract_signed2real(s);
  assert r = 0.0;
 
  s4 := signed'("0111"); 
  r := fract_signed2real(s4); 
  assert r = 1.0/2.0 + 1.0/4.0 + 1.0/8.0;
 
  s := signed'("10000000");  
  r := fract_signed2real(s);
  assert r = -1.0;
 
  s4 := signed'("1111"); 
  r := fract_signed2real(s4);   
  assert r = -0.125;
 
end;
--------------------------------------------------------------------------------
procedure check_fract_real2unsigned is
  variable u:  unsigned (7 downto 0);
  variable u4: unsigned(3 downto 0);
  variable r:  real;
begin
  report "check_frac_real2unsigned()";
 
  u := fract_real2unsigned(0.0, u);
  assert u = unsigned'("00000000");
 
  u4 := fract_real2unsigned(1.0/4.0 + 1.0/8.0 + 1.0/16.0, u4);  --  0.4375
  assert u4 = unsigned'("0111");
 
  u := fract_real2unsigned(0.5, u);
  assert u = unsigned'("10000000");
 
  u4 := fract_real2unsigned(1.0/2.0 + 1.0/4.0 + 1.0/8.0 + 1.0/16.0, u4);  -- 0.9375
  assert u4 = unsigned'("1111");
 
  u := fract_real2unsigned(1.5, u);   -- must produce a warning
 
  u := fract_real2unsigned(-0.5, u);  -- must produce a warning
 
 
end;
 
 
--------------------------------------------------------------------------------
 
procedure check_fract_real2signed is
  variable s:  signed (7 downto 0);
  variable s4: signed (3 downto 0);
  variable r:  real;
begin
  report "check_frac_real2signed()";  
 
  s := fract_real2signed(0.0, s);
  assert s = signed'("00000000");
 
  s4 := fract_real2signed(1.0/2.0 + 1.0/4.0 + 1.0/8.0, s4);
  assert s4 = signed'("0111");
 
  s := fract_real2signed(-1.0, s);
  assert s = signed'("10000000");
 
  s4 := fract_real2signed(-0.125, s4);
  assert s4 = signed'("1111"); 
 
  s  := fract_real2signed(-1.5, s);  -- must generate a warning
 
  s  := fract_real2signed(1.5, s);   -- must generate a warning
 
end;
 
 
--------------------------------------------------------------------------------
 
begin
 
p_c: process is 
begin
  check_to_un_signed;        -- ok
  check_real2unsigned;       -- ok
  check_real2signed;         -- ok
  check_unsigned2real;       -- ok
  check_signed2real;         -- ok
  check_fract_signed2real;   -- ok
  check_fract_unsigned2real; -- ok
  check_fract_real2unsigned; -- ok
  check_fract_real2signed;   -- ok
  wait;  -- for good
end process;
 
end architecture tb;