-------------------------------------------------------------------------------
|
-------------------------------------------------------------------------------
|
--
|
--
|
-- RapidIO IP Library Core
|
-- RapidIO IP Library Core
|
--
|
--
|
-- This file is part of the RapidIO IP library project
|
-- This file is part of the RapidIO IP library project
|
-- http://www.opencores.org/cores/rio/
|
-- http://www.opencores.org/cores/rio/
|
--
|
--
|
-- Description
|
-- Description
|
-- Contains automatic simulation test code to verify a RioPacketBufferWindow
|
-- Contains automatic simulation test code to verify a RioPacketBufferWindow
|
-- implementation.
|
-- implementation.
|
--
|
--
|
-- To Do:
|
-- To Do:
|
-- -
|
-- - Update this to handle the readContentEnd being output at the last content
|
|
-- in a frame in the window-version. There are some errors indicated by this
|
|
-- testbench due to this.
|
--
|
--
|
-- Author(s):
|
-- Author(s):
|
-- - Magnus Rosenius, magro732@opencores.org
|
-- - Magnus Rosenius, magro732@opencores.org
|
--
|
--
|
-------------------------------------------------------------------------------
|
-------------------------------------------------------------------------------
|
--
|
--
|
-- Copyright (C) 2013 Authors and OPENCORES.ORG
|
-- Copyright (C) 2013 Authors and OPENCORES.ORG
|
--
|
--
|
-- This source file may be used and distributed without
|
-- This source file may be used and distributed without
|
-- restriction provided that this copyright statement is not
|
-- restriction provided that this copyright statement is not
|
-- removed from the file and that any derivative work contains
|
-- removed from the file and that any derivative work contains
|
-- the original copyright notice and the associated disclaimer.
|
-- the original copyright notice and the associated disclaimer.
|
--
|
--
|
-- This source file is free software; you can redistribute it
|
-- This source file is free software; you can redistribute it
|
-- and/or modify it under the terms of the GNU Lesser General
|
-- and/or modify it under the terms of the GNU Lesser General
|
-- Public License as published by the Free Software Foundation;
|
-- Public License as published by the Free Software Foundation;
|
-- either version 2.1 of the License, or (at your option) any
|
-- either version 2.1 of the License, or (at your option) any
|
-- later version.
|
-- later version.
|
--
|
--
|
-- This source is distributed in the hope that it will be
|
-- This source is distributed in the hope that it will be
|
-- useful, but WITHOUT ANY WARRANTY; without even the implied
|
-- useful, but WITHOUT ANY WARRANTY; without even the implied
|
-- warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
-- warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
-- PURPOSE. See the GNU Lesser General Public License for more
|
-- PURPOSE. See the GNU Lesser General Public License for more
|
-- details.
|
-- details.
|
--
|
--
|
-- You should have received a copy of the GNU Lesser General
|
-- You should have received a copy of the GNU Lesser General
|
-- Public License along with this source; if not, download it
|
-- Public License along with this source; if not, download it
|
-- from http://www.opencores.org/lgpl.shtml
|
-- from http://www.opencores.org/lgpl.shtml
|
--
|
--
|
-------------------------------------------------------------------------------
|
-------------------------------------------------------------------------------
|
|
|
-------------------------------------------------------------------------------
|
-------------------------------------------------------------------------------
|
-- TestRioPacketBuffer.
|
-- TestRioPacketBuffer.
|
-------------------------------------------------------------------------------
|
-------------------------------------------------------------------------------
|
|
|
library ieee;
|
library ieee;
|
use ieee.std_logic_1164.all;
|
use ieee.std_logic_1164.all;
|
use ieee.numeric_std.all;
|
use ieee.numeric_std.all;
|
use ieee.math_real.all;
|
use ieee.math_real.all;
|
library std;
|
library std;
|
use std.textio.all;
|
use std.textio.all;
|
use work.rio_common.all;
|
use work.rio_common.all;
|
|
use work.TestPortPackage.all;
|
|
|
|
|
-------------------------------------------------------------------------------
|
-------------------------------------------------------------------------------
|
-- Entity for TestRioPacketBuffer.
|
-- Entity for TestRioPacketBuffer.
|
-------------------------------------------------------------------------------
|
-------------------------------------------------------------------------------
|
entity TestRioPacketBuffer is
|
entity TestRioPacketBuffer is
|
end entity;
|
end entity;
|
|
|
|
|
-------------------------------------------------------------------------------
|
-------------------------------------------------------------------------------
|
-- Architecture for TestRioPacketBuffer.
|
-- Architecture for TestRioPacketBuffer.
|
-------------------------------------------------------------------------------
|
-------------------------------------------------------------------------------
|
architecture TestRioPacketBufferImpl of TestRioPacketBuffer is
|
architecture TestRioPacketBufferImpl of TestRioPacketBuffer is
|
|
|
component RioPacketBufferWindow is
|
component RioPacketBufferWindow is
|
port(
|
port(
|
clk : in std_logic;
|
clk : in std_logic;
|
areset_n : in std_logic;
|
areset_n : in std_logic;
|
|
|
inboundWriteFrameFull_o : out std_logic;
|
inboundWriteFrameFull_o : out std_logic;
|
inboundWriteFrame_i : in std_logic;
|
inboundWriteFrame_i : in std_logic;
|
inboundWriteFrameAbort_i : in std_logic;
|
inboundWriteFrameAbort_i : in std_logic;
|
inboundWriteContent_i : in std_logic;
|
inboundWriteContent_i : in std_logic;
|
inboundWriteContentData_i : in std_logic_vector(31 downto 0);
|
inboundWriteContentData_i : in std_logic_vector(31 downto 0);
|
inboundReadFrameEmpty_o : out std_logic;
|
inboundReadFrameEmpty_o : out std_logic;
|
inboundReadFrame_i : in std_logic;
|
inboundReadFrame_i : in std_logic;
|
inboundReadFrameRestart_i : in std_logic;
|
inboundReadFrameRestart_i : in std_logic;
|
inboundReadFrameAborted_o : out std_logic;
|
inboundReadFrameAborted_o : out std_logic;
|
inboundReadContentEmpty_o : out std_logic;
|
inboundReadContentEmpty_o : out std_logic;
|
inboundReadContent_i : in std_logic;
|
inboundReadContent_i : in std_logic;
|
inboundReadContentEnd_o : out std_logic;
|
inboundReadContentEnd_o : out std_logic;
|
inboundReadContentData_o : out std_logic_vector(31 downto 0);
|
inboundReadContentData_o : out std_logic_vector(31 downto 0);
|
|
|
outboundWriteFrameFull_o : out std_logic;
|
outboundWriteFrameFull_o : out std_logic;
|
outboundWriteFrame_i : in std_logic;
|
outboundWriteFrame_i : in std_logic;
|
outboundWriteFrameAbort_i : in std_logic;
|
outboundWriteFrameAbort_i : in std_logic;
|
outboundWriteContent_i : in std_logic;
|
outboundWriteContent_i : in std_logic;
|
outboundWriteContentData_i : in std_logic_vector(31 downto 0);
|
outboundWriteContentData_i : in std_logic_vector(31 downto 0);
|
outboundReadFrameEmpty_o : out std_logic;
|
outboundReadFrameEmpty_o : out std_logic;
|
outboundReadFrame_i : in std_logic;
|
outboundReadFrame_i : in std_logic;
|
outboundReadFrameRestart_i : in std_logic;
|
outboundReadFrameRestart_i : in std_logic;
|
outboundReadFrameAborted_o : out std_logic;
|
outboundReadFrameAborted_o : out std_logic;
|
outboundReadWindowEmpty_o : out std_logic;
|
outboundReadWindowEmpty_o : out std_logic;
|
outboundReadWindowReset_i : in std_logic;
|
outboundReadWindowReset_i : in std_logic;
|
outboundReadWindowNext_i : in std_logic;
|
outboundReadWindowNext_i : in std_logic;
|
outboundReadContentEmpty_o : out std_logic;
|
outboundReadContentEmpty_o : out std_logic;
|
outboundReadContent_i : in std_logic;
|
outboundReadContent_i : in std_logic;
|
outboundReadContentEnd_o : out std_logic;
|
outboundReadContentEnd_o : out std_logic;
|
outboundReadContentData_o : out std_logic_vector(31 downto 0));
|
outboundReadContentData_o : out std_logic_vector(31 downto 0));
|
end component;
|
end component;
|
|
|
signal clk : std_logic;
|
signal clk : std_logic;
|
signal areset_n : std_logic;
|
signal areset_n : std_logic;
|
|
|
signal inboundWriteFrameFull : std_logic;
|
signal inboundWriteFrameFull : std_logic;
|
signal inboundWriteFrame : std_logic;
|
signal inboundWriteFrame : std_logic;
|
signal inboundWriteFrameAbort : std_logic;
|
signal inboundWriteFrameAbort : std_logic;
|
signal inboundWriteContent : std_logic;
|
signal inboundWriteContent : std_logic;
|
signal inboundWriteContentData : std_logic_vector(31 downto 0);
|
signal inboundWriteContentData : std_logic_vector(31 downto 0);
|
signal inboundReadFrameEmpty : std_logic;
|
signal inboundReadFrameEmpty : std_logic;
|
signal inboundReadFrame : std_logic;
|
signal inboundReadFrame : std_logic;
|
signal inboundReadFrameRestart : std_logic;
|
signal inboundReadFrameRestart : std_logic;
|
signal inboundReadFrameAborted : std_logic;
|
signal inboundReadFrameAborted : std_logic;
|
signal inboundReadContentEmpty : std_logic;
|
signal inboundReadContentEmpty : std_logic;
|
signal inboundReadContent : std_logic;
|
signal inboundReadContent : std_logic;
|
signal inboundReadContentEnd : std_logic;
|
signal inboundReadContentEnd : std_logic;
|
signal inboundReadContentData : std_logic_vector(31 downto 0);
|
signal inboundReadContentData : std_logic_vector(31 downto 0);
|
|
|
signal outboundWriteFrameFull : std_logic;
|
signal outboundWriteFrameFull : std_logic;
|
signal outboundWriteFrame : std_logic;
|
signal outboundWriteFrame : std_logic;
|
signal outboundWriteFrameAbort : std_logic;
|
signal outboundWriteFrameAbort : std_logic;
|
signal outboundWriteContent : std_logic;
|
signal outboundWriteContent : std_logic;
|
signal outboundWriteContentData : std_logic_vector(31 downto 0);
|
signal outboundWriteContentData : std_logic_vector(31 downto 0);
|
signal outboundReadFrameEmpty : std_logic;
|
signal outboundReadFrameEmpty : std_logic;
|
signal outboundReadFrame : std_logic;
|
signal outboundReadFrame : std_logic;
|
signal outboundReadFrameRestart : std_logic;
|
signal outboundReadFrameRestart : std_logic;
|
signal outboundReadFrameAborted : std_logic;
|
signal outboundReadFrameAborted : std_logic;
|
signal outboundReadWindowEmpty : std_logic;
|
signal outboundReadWindowEmpty : std_logic;
|
signal outboundReadWindowReset : std_logic;
|
signal outboundReadWindowReset : std_logic;
|
signal outboundReadWindowNext : std_logic;
|
signal outboundReadWindowNext : std_logic;
|
signal outboundReadContentEmpty : std_logic;
|
signal outboundReadContentEmpty : std_logic;
|
signal outboundReadContent : std_logic;
|
signal outboundReadContent : std_logic;
|
signal outboundReadContentEnd : std_logic;
|
signal outboundReadContentEnd : std_logic;
|
signal outboundReadContentData : std_logic_vector(31 downto 0);
|
signal outboundReadContentData : std_logic_vector(31 downto 0);
|
|
|
begin
|
begin
|
|
|
-----------------------------------------------------------------------------
|
-----------------------------------------------------------------------------
|
-- Clock generation.
|
-- Clock generation.
|
-----------------------------------------------------------------------------
|
-----------------------------------------------------------------------------
|
ClockGenerator: process
|
ClockGenerator: process
|
begin
|
begin
|
clk <= '0';
|
clk <= '0';
|
wait for 20 ns;
|
wait for 20 ns;
|
clk <= '1';
|
clk <= '1';
|
wait for 20 ns;
|
wait for 20 ns;
|
end process;
|
end process;
|
|
|
|
|
-----------------------------------------------------------------------------
|
-----------------------------------------------------------------------------
|
-- Test case driver.
|
-- Test case driver.
|
-----------------------------------------------------------------------------
|
-----------------------------------------------------------------------------
|
TestDriver: process
|
TestDriver: process
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
-- Inbound procedures.
|
-- Inbound procedures.
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
|
|
procedure SetInboundWriteContent(
|
procedure SetInboundWriteContent(
|
constant content : in std_logic_vector(31 downto 0)) is
|
constant content : in std_logic_vector(31 downto 0)) is
|
begin
|
begin
|
assert inboundWriteFrameFull = '0'
|
assert inboundWriteFrameFull = '0'
|
report "Inbound frame cannot be accepted." severity error;
|
report "Inbound frame cannot be accepted." severity error;
|
|
|
inboundWriteContent <= '1';
|
inboundWriteContent <= '1';
|
inboundWriteContentData <= content;
|
inboundWriteContentData <= content;
|
wait until clk'event and clk = '1';
|
wait until clk'event and clk = '1';
|
wait for 1 ns;
|
wait for 1 ns;
|
inboundWriteContent <= '0';
|
inboundWriteContent <= '0';
|
inboundWriteContentData <= (others=>'U');
|
inboundWriteContentData <= (others=>'U');
|
end procedure;
|
end procedure;
|
|
|
procedure SetInboundWriteFrame is
|
procedure SetInboundWriteFrame is
|
begin
|
begin
|
inboundWriteFrame <= '1';
|
inboundWriteFrame <= '1';
|
wait until clk'event and clk = '1';
|
wait until clk'event and clk = '1';
|
wait for 1 ns;
|
wait for 1 ns;
|
|
|
inboundWriteFrame <= '0';
|
inboundWriteFrame <= '0';
|
end procedure;
|
end procedure;
|
|
|
procedure SetInboundWriteFrameAbort is
|
procedure SetInboundWriteFrameAbort is
|
begin
|
begin
|
inboundWriteFrameAbort <= '1';
|
inboundWriteFrameAbort <= '1';
|
wait until clk'event and clk = '1';
|
wait until clk'event and clk = '1';
|
wait for 1 ns;
|
wait for 1 ns;
|
|
|
inboundWriteFrameAbort <= '0';
|
inboundWriteFrameAbort <= '0';
|
end procedure;
|
end procedure;
|
|
|
procedure SetInboundReadContent(
|
procedure SetInboundReadContent(
|
constant content : in std_logic_vector(31 downto 0)) is
|
constant content : in std_logic_vector(31 downto 0)) is
|
begin
|
begin
|
inboundReadContent <= '1';
|
inboundReadContent <= '1';
|
wait until clk'event and clk = '1';
|
wait until clk'event and clk = '1';
|
wait for 1 ns;
|
wait for 1 ns;
|
|
|
assert (inboundReadContentData = content)
|
assert (inboundReadContentData = content)
|
report "Unexpected content read." severity error;
|
report "Unexpected content read." severity error;
|
assert (inboundReadContentEnd = '0')
|
assert (inboundReadContentEnd = '0')
|
report "Unexpected content end." severity error;
|
report "Unexpected content end." severity error;
|
|
|
inboundReadContent <= '0';
|
inboundReadContent <= '0';
|
end procedure;
|
end procedure;
|
|
|
procedure SetInboundReadContentEnd is
|
procedure SetInboundReadContentEnd is
|
begin
|
begin
|
inboundReadContent <= '1';
|
inboundReadContent <= '1';
|
wait until clk'event and clk = '1';
|
wait until clk'event and clk = '1';
|
wait for 1 ns;
|
wait for 1 ns;
|
|
|
assert (inboundReadContentEnd = '1')
|
assert (inboundReadContentEnd = '1')
|
report "Unexpected content end." severity error;
|
report "Unexpected content end." severity error;
|
|
|
inboundReadContent <= '0';
|
inboundReadContent <= '0';
|
end procedure;
|
end procedure;
|
|
|
procedure SetInboundReadFrame is
|
procedure SetInboundReadFrame is
|
begin
|
begin
|
assert inboundReadFrameEmpty = '0'
|
assert inboundReadFrameEmpty = '0'
|
report "No pending inbound frame to be read." severity error;
|
report "No pending inbound frame to be read." severity error;
|
|
|
inboundReadFrame <= '1';
|
inboundReadFrame <= '1';
|
wait until clk'event and clk = '1';
|
wait until clk'event and clk = '1';
|
wait for 1 ns;
|
wait for 1 ns;
|
|
|
inboundReadFrame <= '0';
|
inboundReadFrame <= '0';
|
end procedure;
|
end procedure;
|
|
|
procedure SetInboundReadFrameRestart is
|
procedure SetInboundReadFrameRestart is
|
begin
|
begin
|
inboundReadFrameRestart <= '1';
|
inboundReadFrameRestart <= '1';
|
wait until clk'event and clk = '1';
|
wait until clk'event and clk = '1';
|
wait for 1 ns;
|
wait for 1 ns;
|
|
|
inboundReadFrameRestart <= '0';
|
inboundReadFrameRestart <= '0';
|
end procedure;
|
end procedure;
|
|
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
-- Outbound procedures.
|
-- Outbound procedures.
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
|
|
procedure SetOutboundWriteContent(
|
procedure SetOutboundWriteContent(
|
constant content : in std_logic_vector(31 downto 0)) is
|
constant content : in std_logic_vector(31 downto 0)) is
|
begin
|
begin
|
assert outboundWriteFrameFull = '0'
|
assert outboundWriteFrameFull = '0'
|
report "Outbound frame cannot be accepted." severity error;
|
report "Outbound frame cannot be accepted." severity error;
|
|
|
outboundWriteContent <= '1';
|
outboundWriteContent <= '1';
|
outboundWriteContentData <= content;
|
outboundWriteContentData <= content;
|
wait until clk'event and clk = '1';
|
wait until clk'event and clk = '1';
|
wait for 1 ns;
|
wait for 1 ns;
|
outboundWriteContent <= '0';
|
outboundWriteContent <= '0';
|
outboundWriteContentData <= (others=>'U');
|
outboundWriteContentData <= (others=>'U');
|
end procedure;
|
end procedure;
|
|
|
procedure SetOutboundWriteFrame is
|
procedure SetOutboundWriteFrame is
|
begin
|
begin
|
assert outboundWriteFrameFull = '0'
|
assert outboundWriteFrameFull = '0'
|
report "Outbound frame cannot be accepted." severity error;
|
report "Outbound frame cannot be accepted." severity error;
|
|
|
outboundWriteFrame <= '1';
|
outboundWriteFrame <= '1';
|
wait until clk'event and clk = '1';
|
wait until clk'event and clk = '1';
|
wait for 1 ns;
|
wait for 1 ns;
|
|
|
outboundWriteFrame <= '0';
|
outboundWriteFrame <= '0';
|
end procedure;
|
end procedure;
|
|
|
procedure SetOutboundWriteFrameAbort is
|
procedure SetOutboundWriteFrameAbort is
|
begin
|
begin
|
outboundWriteFrameAbort <= '1';
|
outboundWriteFrameAbort <= '1';
|
wait until clk'event and clk = '1';
|
wait until clk'event and clk = '1';
|
wait for 1 ns;
|
wait for 1 ns;
|
|
|
outboundWriteFrameAbort <= '0';
|
outboundWriteFrameAbort <= '0';
|
end procedure;
|
end procedure;
|
|
|
procedure SetOutboundReadContent(
|
procedure SetOutboundReadContent(
|
constant content : in std_logic_vector(31 downto 0);
|
constant content : in std_logic_vector(31 downto 0);
|
constant ending : in std_logic := '0') is
|
constant ending : in std_logic := '0') is
|
begin
|
begin
|
outboundReadContent <= '1';
|
outboundReadContent <= '1';
|
wait until clk'event and clk = '1';
|
wait until clk'event and clk = '1';
|
wait for 1 ns;
|
wait for 1 ns;
|
|
|
assert (outboundReadContentData = content)
|
assert (outboundReadContentData = content)
|
report "Unexpected content read." severity error;
|
report "Unexpected content read." severity error;
|
assert (outboundReadContentEnd = ending)
|
assert (outboundReadContentEnd = ending)
|
report "Unexpected content end." severity error;
|
report "Unexpected content end." severity error;
|
|
|
outboundReadContent <= '0';
|
outboundReadContent <= '0';
|
end procedure;
|
end procedure;
|
|
|
procedure SetOutboundReadFrame is
|
procedure SetOutboundReadFrame is
|
begin
|
begin
|
assert outboundReadFrameEmpty = '0'
|
assert outboundReadFrameEmpty = '0'
|
report "No pending outbound frame to be read." severity error;
|
report "No pending outbound frame to be read." severity error;
|
|
|
outboundReadFrame <= '1';
|
outboundReadFrame <= '1';
|
wait until clk'event and clk = '1';
|
wait until clk'event and clk = '1';
|
wait for 1 ns;
|
wait for 1 ns;
|
|
|
outboundReadFrame <= '0';
|
outboundReadFrame <= '0';
|
end procedure;
|
end procedure;
|
|
|
procedure SetOutboundReadFrameRestart is
|
procedure SetOutboundReadFrameRestart is
|
begin
|
begin
|
outboundReadFrameRestart <= '1';
|
outboundReadFrameRestart <= '1';
|
wait until clk'event and clk = '1';
|
wait until clk'event and clk = '1';
|
wait for 1 ns;
|
wait for 1 ns;
|
|
|
outboundReadFrameRestart <= '0';
|
outboundReadFrameRestart <= '0';
|
end procedure;
|
end procedure;
|
|
|
procedure SetOutboundReadWindowReset is
|
procedure SetOutboundReadWindowReset is
|
begin
|
begin
|
outboundReadWindowReset <= '1';
|
outboundReadWindowReset <= '1';
|
wait until clk'event and clk = '1';
|
wait until clk'event and clk = '1';
|
wait for 1 ns;
|
wait for 1 ns;
|
|
|
outboundReadWindowReset <= '0';
|
outboundReadWindowReset <= '0';
|
end procedure;
|
end procedure;
|
|
|
procedure SetOutboundReadWindowNext is
|
procedure SetOutboundReadWindowNext is
|
begin
|
begin
|
assert outboundReadWindowEmpty = '0'
|
assert outboundReadWindowEmpty = '0'
|
report "No pending outbound window frame to be read." severity error;
|
report "No pending outbound window frame to be read." severity error;
|
|
|
outboundReadWindowNext <= '1';
|
outboundReadWindowNext <= '1';
|
wait until clk'event and clk = '1';
|
wait until clk'event and clk = '1';
|
wait for 1 ns;
|
wait for 1 ns;
|
|
|
outboundReadWindowNext <= '0';
|
outboundReadWindowNext <= '0';
|
end procedure;
|
end procedure;
|
|
|
begin
|
begin
|
inboundWriteFrame <= '0';
|
inboundWriteFrame <= '0';
|
inboundWriteFrameAbort <= '0';
|
inboundWriteFrameAbort <= '0';
|
inboundWriteContent <= '0';
|
inboundWriteContent <= '0';
|
inboundWriteContentData <= (others=>'U');
|
inboundWriteContentData <= (others=>'U');
|
inboundReadFrame <= '0';
|
inboundReadFrame <= '0';
|
inboundReadFrameRestart <= '0';
|
inboundReadFrameRestart <= '0';
|
inboundReadContent <= '0';
|
inboundReadContent <= '0';
|
|
|
outboundWriteFrame <= '0';
|
outboundWriteFrame <= '0';
|
outboundWriteFrameAbort <= '0';
|
outboundWriteFrameAbort <= '0';
|
outboundWriteContent <= '0';
|
outboundWriteContent <= '0';
|
outboundWriteContentData <= (others=>'U');
|
outboundWriteContentData <= (others=>'U');
|
outboundReadFrame <= '0';
|
outboundReadFrame <= '0';
|
outboundReadFrameRestart <= '0';
|
outboundReadFrameRestart <= '0';
|
outboundReadWindowReset <= '0';
|
outboundReadWindowReset <= '0';
|
outboundReadWindowNext <= '0';
|
outboundReadWindowNext <= '0';
|
outboundReadContent <= '0';
|
outboundReadContent <= '0';
|
|
|
areset_n <= '0';
|
areset_n <= '0';
|
wait until clk'event and clk = '1';
|
wait until clk'event and clk = '1';
|
wait until clk'event and clk = '1';
|
wait until clk'event and clk = '1';
|
areset_n <= '1';
|
areset_n <= '1';
|
wait until clk'event and clk = '1';
|
wait until clk'event and clk = '1';
|
wait until clk'event and clk = '1';
|
wait until clk'event and clk = '1';
|
|
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
PrintS("-----------------------------------------------------------------");
|
TestSpec("-----------------------------------------------------------------");
|
PrintS("TG_RioPacketBuffer");
|
TestSpec("TG_RioPacketBuffer");
|
PrintS("-----------------------------------------------------------------");
|
TestSpec("-----------------------------------------------------------------");
|
PrintS("TG_RioPacketBuffer-TC1");
|
TestSpec("TG_RioPacketBuffer-TC1");
|
PrintS("Description: Test normal operation without using the window. Only");
|
TestSpec("Description: Test normal operation without using the window. Only");
|
PrintS(" full frames are tested.");
|
TestSpec(" full frames are tested.");
|
PrintS("Requirement: XXXXX");
|
TestSpec("Requirement: XXXXX");
|
PrintS("-----------------------------------------------------------------");
|
TestSpec("-----------------------------------------------------------------");
|
PrintS("Step 1:");
|
TestSpec("Step 1:");
|
PrintS("Action: Complete a small frame and read it.");
|
TestSpec("Action: Complete a small frame and read it.");
|
PrintS("Result: The read frame should be equal to the one written.");
|
TestSpec("Result: The read frame should be equal to the one written.");
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
PrintR("TG_RioPacketBuffer-TC1-Step1");
|
TestCaseStart("TG_RioPacketBuffer-TC1-Step1");
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
-- REMARK: Update testcases for inbound and outbound...
|
-- REMARK: Update testcases for inbound and outbound...
|
|
|
assert (inboundWriteFrameFull = '0')
|
assert (inboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (inboundReadFrameEmpty = '1')
|
assert (inboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
|
|
SetInboundWriteContent(x"deadbeef");
|
SetInboundWriteContent(x"deadbeef");
|
|
|
assert (inboundWriteFrameFull = '0')
|
assert (inboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (inboundReadFrameEmpty = '1')
|
assert (inboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
|
|
SetInboundWriteFrame;
|
SetInboundWriteFrame;
|
|
|
assert (inboundWriteFrameFull = '0')
|
assert (inboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (inboundReadFrameEmpty = '0')
|
assert (inboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
|
|
SetInboundReadContent(x"deadbeef");
|
SetInboundReadContent(x"deadbeef");
|
|
|
assert (inboundWriteFrameFull = '0')
|
assert (inboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (inboundReadFrameEmpty = '0')
|
assert (inboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
|
|
SetInboundReadContentEnd;
|
SetInboundReadContentEnd;
|
|
|
assert (inboundWriteFrameFull = '0')
|
assert (inboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (inboundReadFrameEmpty = '0')
|
assert (inboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
|
|
SetInboundReadFrame;
|
SetInboundReadFrame;
|
|
|
assert (inboundWriteFrameFull = '0')
|
assert (inboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (inboundReadFrameEmpty = '1')
|
assert (inboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
|
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
PrintS("-----------------------------------------------------------------");
|
TestSpec("-----------------------------------------------------------------");
|
PrintS("Step 2:");
|
TestSpec("Step 2:");
|
PrintS("Action: Write a rio maximum size frame and read it.");
|
TestSpec("Action: Write a rio maximum size frame and read it.");
|
PrintS("Result: The read frame should be equal to the one written.");
|
TestSpec("Result: The read frame should be equal to the one written.");
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
PrintR("TG_RioPacketBuffer-TC1-Step2");
|
TestCaseStart("TG_RioPacketBuffer-TC1-Step2");
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
|
|
for i in 0 to 68 loop
|
for i in 0 to 68 loop
|
SetInboundWriteContent(std_logic_vector(to_unsigned(i, 32)));
|
SetInboundWriteContent(std_logic_vector(to_unsigned(i, 32)));
|
|
|
assert (inboundWriteFrameFull = '0')
|
assert (inboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (inboundReadFrameEmpty = '1')
|
assert (inboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
SetInboundWriteFrame;
|
SetInboundWriteFrame;
|
|
|
assert (inboundWriteFrameFull = '0')
|
assert (inboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (inboundReadFrameEmpty = '0')
|
assert (inboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
|
|
for i in 0 to 68 loop
|
for i in 0 to 68 loop
|
SetInboundReadContent(std_logic_vector(to_unsigned(i, 32)));
|
SetInboundReadContent(std_logic_vector(to_unsigned(i, 32)));
|
|
|
assert (inboundWriteFrameFull = '0')
|
assert (inboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (inboundReadFrameEmpty = '0')
|
assert (inboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
SetInboundReadContentEnd;
|
SetInboundReadContentEnd;
|
|
|
assert (inboundWriteFrameFull = '0')
|
assert (inboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (inboundReadFrameEmpty = '0')
|
assert (inboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
|
|
SetInboundReadFrame;
|
SetInboundReadFrame;
|
|
|
assert (inboundWriteFrameFull = '0')
|
assert (inboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (inboundReadFrameEmpty = '1')
|
assert (inboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
|
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
PrintS("-----------------------------------------------------------------");
|
TestSpec("-----------------------------------------------------------------");
|
PrintS("Step 3:");
|
TestSpec("Step 3:");
|
PrintS("Action: Fill the maximum number of small frames without filling ");
|
TestSpec("Action: Fill the maximum number of small frames without filling ");
|
PrintS(" the memory.");
|
TestSpec(" the memory.");
|
PrintS("Result: The frame buffer should accept 63 frames.");
|
TestSpec("Result: The frame buffer should accept 63 frames.");
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
PrintR("TG_RioPacketBuffer-TC1-Step3");
|
TestCaseStart("TG_RioPacketBuffer-TC1-Step3");
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
|
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
-- Write maximum number of frames.
|
-- Write maximum number of frames.
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
|
|
for i in 0 to 2 loop
|
for i in 0 to 2 loop
|
SetInboundWriteContent(std_logic_vector(to_unsigned(i, 32)));
|
SetInboundWriteContent(std_logic_vector(to_unsigned(i, 32)));
|
assert (inboundWriteFrameFull = '0')
|
assert (inboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (inboundReadFrameEmpty = '1')
|
assert (inboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
for j in 1 to 62 loop
|
for j in 1 to 62 loop
|
SetInboundWriteFrame;
|
SetInboundWriteFrame;
|
assert (inboundWriteFrameFull = '0')
|
assert (inboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (inboundReadFrameEmpty = '0')
|
assert (inboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
|
|
for i in 0 to 2 loop
|
for i in 0 to 2 loop
|
SetInboundWriteContent(std_logic_vector(to_unsigned(j+i, 32)));
|
SetInboundWriteContent(std_logic_vector(to_unsigned(j+i, 32)));
|
|
|
assert (inboundWriteFrameFull = '0')
|
assert (inboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (inboundReadFrameEmpty = '0')
|
assert (inboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
end loop;
|
end loop;
|
end loop;
|
end loop;
|
|
|
SetInboundWriteFrame;
|
SetInboundWriteFrame;
|
assert (inboundWriteFrameFull = '1')
|
assert (inboundWriteFrameFull = '1')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (inboundReadFrameEmpty = '0')
|
assert (inboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
|
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
-- Read the frames written in the above steps.
|
-- Read the frames written in the above steps.
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
|
|
for i in 0 to 2 loop
|
for i in 0 to 2 loop
|
SetInboundReadContent(std_logic_vector(to_unsigned(i, 32)));
|
SetInboundReadContent(std_logic_vector(to_unsigned(i, 32)));
|
|
|
assert (inboundWriteFrameFull = '1')
|
assert (inboundWriteFrameFull = '1')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (inboundReadFrameEmpty = '0')
|
assert (inboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
SetInboundReadContentEnd;
|
SetInboundReadContentEnd;
|
assert (inboundWriteFrameFull = '1')
|
assert (inboundWriteFrameFull = '1')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (inboundReadFrameEmpty = '0')
|
assert (inboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
|
|
for j in 1 to 62 loop
|
for j in 1 to 62 loop
|
SetInboundReadFrame;
|
SetInboundReadFrame;
|
assert (inboundWriteFrameFull = '0')
|
assert (inboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (inboundReadFrameEmpty = '0')
|
assert (inboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
|
|
for i in 0 to 2 loop
|
for i in 0 to 2 loop
|
SetInboundReadContent(std_logic_vector(to_unsigned(j+i, 32)));
|
SetInboundReadContent(std_logic_vector(to_unsigned(j+i, 32)));
|
|
|
assert (inboundWriteFrameFull = '0')
|
assert (inboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (inboundReadFrameEmpty = '0')
|
assert (inboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
SetInboundReadContentEnd;
|
SetInboundReadContentEnd;
|
assert (inboundWriteFrameFull = '0')
|
assert (inboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (inboundReadFrameEmpty = '0')
|
assert (inboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
SetInboundReadFrame;
|
SetInboundReadFrame;
|
assert (inboundWriteFrameFull = '0')
|
assert (inboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (inboundReadFrameEmpty = '1')
|
assert (inboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
|
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
PrintS("-----------------------------------------------------------------");
|
TestSpec("-----------------------------------------------------------------");
|
PrintS("Step 4:");
|
TestSpec("Step 4:");
|
PrintS("Action: Fill the memory to its limit.");
|
TestSpec("Action: Fill the memory to its limit.");
|
PrintS("Result: The frame buffer should accept 255-69 words.");
|
TestSpec("Result: The frame buffer should accept 255-69 words.");
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
PrintR("TG_RioPacketBuffer-TC1-Step4");
|
TestCaseStart("TG_RioPacketBuffer-TC1-Step4");
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
|
|
for i in 0 to 186 loop
|
for i in 0 to 186 loop
|
SetInboundWriteContent(std_logic_vector(to_unsigned(i, 32)));
|
SetInboundWriteContent(std_logic_vector(to_unsigned(i, 32)));
|
assert (inboundWriteFrameFull = '0')
|
assert (inboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (inboundReadFrameEmpty = '1')
|
assert (inboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
SetInboundWriteFrame;
|
SetInboundWriteFrame;
|
assert (inboundWriteFrameFull = '1')
|
assert (inboundWriteFrameFull = '1')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (inboundReadFrameEmpty = '0')
|
assert (inboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
|
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
|
|
for i in 0 to 186 loop
|
for i in 0 to 186 loop
|
SetInboundReadContent(std_logic_vector(to_unsigned(i, 32)));
|
SetInboundReadContent(std_logic_vector(to_unsigned(i, 32)));
|
|
|
assert (inboundWriteFrameFull = '1')
|
assert (inboundWriteFrameFull = '1')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (inboundReadFrameEmpty = '0')
|
assert (inboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
SetInboundReadContentEnd;
|
SetInboundReadContentEnd;
|
assert (inboundWriteFrameFull = '1')
|
assert (inboundWriteFrameFull = '1')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (inboundReadFrameEmpty = '0')
|
assert (inboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
|
|
SetInboundReadFrame;
|
SetInboundReadFrame;
|
assert (inboundWriteFrameFull = '0')
|
assert (inboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (inboundReadFrameEmpty = '1')
|
assert (inboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
|
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
PrintS("-----------------------------------------------------------------");
|
TestSpec("-----------------------------------------------------------------");
|
PrintS("TG_RioPacketBuffer-TC2");
|
TestSpec("TG_RioPacketBuffer-TC2");
|
PrintS("Description: Test operation when using the window.");
|
TestSpec("Description: Test operation when using the window.");
|
PrintS("Requirement: XXXXX");
|
TestSpec("Requirement: XXXXX");
|
PrintS("-----------------------------------------------------------------");
|
TestSpec("-----------------------------------------------------------------");
|
PrintS("Step 1:");
|
TestSpec("Step 1:");
|
PrintS("Action: Add one frame and update the window.");
|
TestSpec("Action: Add one frame and update the window.");
|
PrintS("Result: The window empty flag and the read frame empty flag should");
|
TestSpec("Result: The window empty flag and the read frame empty flag should");
|
PrintS(" be updated and it should be possible to read the frame again.");
|
TestSpec(" be updated and it should be possible to read the frame again.");
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
PrintR("TG_RioPacketBuffer-TC2-Step1");
|
TestCaseStart("TG_RioPacketBuffer-TC2-Step1");
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
|
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '1')
|
assert (outboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
for i in 0 to 2 loop
|
for i in 0 to 2 loop
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(i, 32)));
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(i, 32)));
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '1')
|
assert (outboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
SetOutboundWriteFrame;
|
SetOutboundWriteFrame;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
|
|
for i in 0 to 1 loop
|
for i in 0 to 1 loop
|
SetOutboundReadContent(std_logic_vector(to_unsigned(i, 32)));
|
SetOutboundReadContent(std_logic_vector(to_unsigned(i, 32)));
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
SetOutboundReadContent(std_logic_vector(to_unsigned(2, 32)), '1');
|
SetOutboundReadContent(std_logic_vector(to_unsigned(2, 32)), '1');
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
SetOutboundReadWindowReset;
|
SetOutboundReadWindowReset;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
for i in 0 to 1 loop
|
for i in 0 to 1 loop
|
SetOutboundReadContent(std_logic_vector(to_unsigned(i, 32)));
|
SetOutboundReadContent(std_logic_vector(to_unsigned(i, 32)));
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
SetOutboundReadContent(std_logic_vector(to_unsigned(2, 32)), '1');
|
SetOutboundReadContent(std_logic_vector(to_unsigned(2, 32)), '1');
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
SetOutboundReadWindowNext;
|
SetOutboundReadWindowNext;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
SetOutboundReadFrame;
|
SetOutboundReadFrame;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '1')
|
assert (outboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
PrintS("-----------------------------------------------------------------");
|
TestSpec("-----------------------------------------------------------------");
|
PrintS("Step 2:");
|
TestSpec("Step 2:");
|
PrintS("Action: Add two frames and test the window accesses.");
|
TestSpec("Action: Add two frames and test the window accesses.");
|
PrintS("Result: .");
|
TestSpec("Result: .");
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
PrintR("TG_RioPacketBuffer-TC2-Step2");
|
TestCaseStart("TG_RioPacketBuffer-TC2-Step2");
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
|
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
-- Write two frames.
|
-- Write two frames.
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
|
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '1')
|
assert (outboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
for i in 0 to 2 loop
|
for i in 0 to 2 loop
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(1+i, 32)));
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(1+i, 32)));
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '1')
|
assert (outboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
SetOutboundWriteFrame;
|
SetOutboundWriteFrame;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
for i in 0 to 2 loop
|
for i in 0 to 2 loop
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(2+i, 32)));
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(2+i, 32)));
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
SetOutboundWriteFrame;
|
SetOutboundWriteFrame;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
-- Read the frames using the window mechanism.
|
-- Read the frames using the window mechanism.
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
|
|
for i in 0 to 1 loop
|
for i in 0 to 1 loop
|
SetOutboundReadContent(std_logic_vector(to_unsigned(1+i, 32)));
|
SetOutboundReadContent(std_logic_vector(to_unsigned(1+i, 32)));
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
SetOutboundReadContent(std_logic_vector(to_unsigned(1+2, 32)), '1');
|
SetOutboundReadContent(std_logic_vector(to_unsigned(1+2, 32)), '1');
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
SetOutboundReadWindowNext;
|
SetOutboundReadWindowNext;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
for i in 0 to 1 loop
|
for i in 0 to 1 loop
|
SetOutboundReadContent(std_logic_vector(to_unsigned(2+i, 32)));
|
SetOutboundReadContent(std_logic_vector(to_unsigned(2+i, 32)));
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
SetOutboundReadContent(std_logic_vector(to_unsigned(2+2, 32)), '1');
|
SetOutboundReadContent(std_logic_vector(to_unsigned(2+2, 32)), '1');
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
SetOutboundReadWindowNext;
|
SetOutboundReadWindowNext;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
-- Reset the window and read the frames again.
|
-- Reset the window and read the frames again.
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
|
|
SetOutboundReadWindowReset;
|
SetOutboundReadWindowReset;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
for i in 0 to 1 loop
|
for i in 0 to 1 loop
|
SetOutboundReadContent(std_logic_vector(to_unsigned(1+i, 32)));
|
SetOutboundReadContent(std_logic_vector(to_unsigned(1+i, 32)));
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
SetOutboundReadContent(std_logic_vector(to_unsigned(1+2, 32)), '1');
|
SetOutboundReadContent(std_logic_vector(to_unsigned(1+2, 32)), '1');
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
SetOutboundReadWindowNext;
|
SetOutboundReadWindowNext;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
for i in 0 to 1 loop
|
for i in 0 to 1 loop
|
SetOutboundReadContent(std_logic_vector(to_unsigned(2+i, 32)));
|
SetOutboundReadContent(std_logic_vector(to_unsigned(2+i, 32)));
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
SetOutboundReadContent(std_logic_vector(to_unsigned(2+2, 32)), '1');
|
SetOutboundReadContent(std_logic_vector(to_unsigned(2+2, 32)), '1');
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
SetOutboundReadWindowNext;
|
SetOutboundReadWindowNext;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
-- Remove one frame and access the remaining frame.
|
-- Remove one frame and access the remaining frame.
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
SetOutboundReadFrame;
|
SetOutboundReadFrame;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
SetOutboundReadWindowReset;
|
SetOutboundReadWindowReset;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
for i in 0 to 1 loop
|
for i in 0 to 1 loop
|
SetOutboundReadContent(std_logic_vector(to_unsigned(2+i, 32)));
|
SetOutboundReadContent(std_logic_vector(to_unsigned(2+i, 32)));
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
SetOutboundReadContent(std_logic_vector(to_unsigned(2+2, 32)), '1');
|
SetOutboundReadContent(std_logic_vector(to_unsigned(2+2, 32)), '1');
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
SetOutboundReadWindowNext;
|
SetOutboundReadWindowNext;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
-- Remove the remaining frame.
|
-- Remove the remaining frame.
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
|
|
SetOutboundReadFrame;
|
SetOutboundReadFrame;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '1')
|
assert (outboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
SetOutboundReadWindowReset;
|
SetOutboundReadWindowReset;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '1')
|
assert (outboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
PrintS("-----------------------------------------------------------------");
|
TestSpec("-----------------------------------------------------------------");
|
PrintS("Step 3:");
|
TestSpec("Step 3:");
|
PrintS("Action: Add maximum number of frames and test the window accesses.");
|
TestSpec("Action: Add maximum number of frames and test the window accesses.");
|
PrintS("Result: The buffer should be full and not accept more frames.");
|
TestSpec("Result: The buffer should be full and not accept more frames.");
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
PrintR("TG_RioPacketBuffer-TC2-Step3");
|
TestCaseStart("TG_RioPacketBuffer-TC2-Step3");
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
|
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '1')
|
assert (outboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
-- Write 3*63 frames => maximum number of frames.
|
-- Write 3*63 frames => maximum number of frames.
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
|
|
for i in 0 to 2 loop
|
for i in 0 to 2 loop
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(i, 32)));
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(i, 32)));
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '1')
|
assert (outboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
for j in 1 to 62 loop
|
for j in 1 to 62 loop
|
SetOutboundWriteFrame;
|
SetOutboundWriteFrame;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
for i in 0 to 2 loop
|
for i in 0 to 2 loop
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(j+i, 32)));
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(j+i, 32)));
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
end loop;
|
end loop;
|
end loop;
|
end loop;
|
|
|
SetOutboundWriteFrame;
|
SetOutboundWriteFrame;
|
assert (outboundWriteFrameFull = '1')
|
assert (outboundWriteFrameFull = '1')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
-- Read the whole window until it is empty.
|
-- Read the whole window until it is empty.
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
|
|
for j in 0 to 61 loop
|
for j in 0 to 61 loop
|
for i in 0 to 1 loop
|
for i in 0 to 1 loop
|
SetOutboundReadContent(std_logic_vector(to_unsigned(j+i, 32)));
|
SetOutboundReadContent(std_logic_vector(to_unsigned(j+i, 32)));
|
assert (outboundWriteFrameFull = '1')
|
assert (outboundWriteFrameFull = '1')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
SetOutboundReadContent(std_logic_vector(to_unsigned(j+2, 32)), '1');
|
SetOutboundReadContent(std_logic_vector(to_unsigned(j+2, 32)), '1');
|
assert (outboundWriteFrameFull = '1')
|
assert (outboundWriteFrameFull = '1')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
SetOutboundReadWindowNext;
|
SetOutboundReadWindowNext;
|
assert (outboundWriteFrameFull = '1')
|
assert (outboundWriteFrameFull = '1')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
for i in 0 to 1 loop
|
for i in 0 to 1 loop
|
SetOutboundReadContent(std_logic_vector(to_unsigned(62+i, 32)));
|
SetOutboundReadContent(std_logic_vector(to_unsigned(62+i, 32)));
|
assert (outboundWriteFrameFull = '1')
|
assert (outboundWriteFrameFull = '1')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
SetOutboundReadContent(std_logic_vector(to_unsigned(62+2, 32)), '1');
|
SetOutboundReadContent(std_logic_vector(to_unsigned(62+2, 32)), '1');
|
assert (outboundWriteFrameFull = '1')
|
assert (outboundWriteFrameFull = '1')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
SetOutboundReadWindowNext;
|
SetOutboundReadWindowNext;
|
assert (outboundWriteFrameFull = '1')
|
assert (outboundWriteFrameFull = '1')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
-- Reset the window and remove all frames.
|
-- Reset the window and remove all frames.
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
|
|
SetOutboundReadWindowReset;
|
SetOutboundReadWindowReset;
|
assert (outboundWriteFrameFull = '1')
|
assert (outboundWriteFrameFull = '1')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
for j in 0 to 61 loop
|
for j in 0 to 61 loop
|
SetOutboundReadFrame;
|
SetOutboundReadFrame;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
SetOutboundReadWindowReset;
|
SetOutboundReadWindowReset;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
for i in 0 to 1 loop
|
for i in 0 to 1 loop
|
SetOutboundReadContent(std_logic_vector(to_unsigned(62+i, 32)));
|
SetOutboundReadContent(std_logic_vector(to_unsigned(62+i, 32)));
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
SetOutboundReadContent(std_logic_vector(to_unsigned(62+2, 32)), '1');
|
SetOutboundReadContent(std_logic_vector(to_unsigned(62+2, 32)), '1');
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
SetOutboundReadWindowNext;
|
SetOutboundReadWindowNext;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
SetOutboundReadFrame;
|
SetOutboundReadFrame;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '1')
|
assert (outboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
PrintS("-----------------------------------------------------------------");
|
TestSpec("-----------------------------------------------------------------");
|
PrintS("Step 4:");
|
TestSpec("Step 4:");
|
PrintS("Action: Add maximum number of words and test the window accesses.");
|
TestSpec("Action: Add maximum number of words and test the window accesses.");
|
PrintS("Result: The content memory should be full.");
|
TestSpec("Result: The content memory should be full.");
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
PrintR("TG_RioPacketBuffer-TC2-Step4");
|
TestCaseStart("TG_RioPacketBuffer-TC2-Step4");
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
|
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '1')
|
assert (outboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
-- Write 6*31+69=255 words and 7 frames => full content.
|
-- Write 6*31+69=255 words and 7 frames => full content.
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
|
|
for i in 0 to 30 loop
|
for i in 0 to 30 loop
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(i, 32)));
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(i, 32)));
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '1')
|
assert (outboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
for j in 1 to 5 loop
|
for j in 1 to 5 loop
|
SetOutboundWriteFrame;
|
SetOutboundWriteFrame;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
for i in 0 to 30 loop
|
for i in 0 to 30 loop
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(j+i, 32)));
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(j+i, 32)));
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
end loop;
|
end loop;
|
end loop;
|
end loop;
|
|
|
SetOutboundWriteFrame;
|
SetOutboundWriteFrame;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
for i in 0 to 68 loop
|
for i in 0 to 68 loop
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(1024+i, 32)));
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(1024+i, 32)));
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
SetOutboundWriteFrame;
|
SetOutboundWriteFrame;
|
assert (outboundWriteFrameFull = '1')
|
assert (outboundWriteFrameFull = '1')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
-- Read the whole window until it is empty.
|
-- Read the whole window until it is empty.
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
|
|
for j in 0 to 5 loop
|
for j in 0 to 5 loop
|
for i in 0 to 29 loop
|
for i in 0 to 29 loop
|
SetOutboundReadContent(std_logic_vector(to_unsigned(j+i, 32)));
|
SetOutboundReadContent(std_logic_vector(to_unsigned(j+i, 32)));
|
assert (outboundWriteFrameFull = '1')
|
assert (outboundWriteFrameFull = '1')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
SetOutboundReadContent(std_logic_vector(to_unsigned(j+30, 32)), '1');
|
SetOutboundReadContent(std_logic_vector(to_unsigned(j+30, 32)), '1');
|
assert (outboundWriteFrameFull = '1')
|
assert (outboundWriteFrameFull = '1')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
SetOutboundReadWindowNext;
|
SetOutboundReadWindowNext;
|
assert (outboundWriteFrameFull = '1')
|
assert (outboundWriteFrameFull = '1')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
for i in 0 to 67 loop
|
for i in 0 to 67 loop
|
SetOutboundReadContent(std_logic_vector(to_unsigned(1024+i, 32)));
|
SetOutboundReadContent(std_logic_vector(to_unsigned(1024+i, 32)));
|
assert (outboundWriteFrameFull = '1')
|
assert (outboundWriteFrameFull = '1')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
SetOutboundReadContent(std_logic_vector(to_unsigned(1024+68, 32)), '1');
|
SetOutboundReadContent(std_logic_vector(to_unsigned(1024+68, 32)), '1');
|
assert (outboundWriteFrameFull = '1')
|
assert (outboundWriteFrameFull = '1')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
SetOutboundReadWindowNext;
|
SetOutboundReadWindowNext;
|
assert (outboundWriteFrameFull = '1')
|
assert (outboundWriteFrameFull = '1')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
-- Reset the window and remove all frames.
|
-- Reset the window and remove all frames.
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
|
|
SetOutboundReadWindowReset;
|
SetOutboundReadWindowReset;
|
assert (outboundWriteFrameFull = '1')
|
assert (outboundWriteFrameFull = '1')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
for j in 0 to 1 loop
|
for j in 0 to 1 loop
|
SetOutboundReadFrame;
|
SetOutboundReadFrame;
|
assert (outboundWriteFrameFull = '1')
|
assert (outboundWriteFrameFull = '1')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
for j in 2 to 5 loop
|
for j in 2 to 5 loop
|
SetOutboundReadFrame;
|
SetOutboundReadFrame;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
SetOutboundReadWindowReset;
|
SetOutboundReadWindowReset;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
for i in 0 to 67 loop
|
for i in 0 to 67 loop
|
SetOutboundReadContent(std_logic_vector(to_unsigned(1024+i, 32)));
|
SetOutboundReadContent(std_logic_vector(to_unsigned(1024+i, 32)));
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
SetOutboundReadContent(std_logic_vector(to_unsigned(1024+68, 32)), '1');
|
SetOutboundReadContent(std_logic_vector(to_unsigned(1024+68, 32)), '1');
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
SetOutboundReadWindowNext;
|
SetOutboundReadWindowNext;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
SetOutboundReadFrame;
|
SetOutboundReadFrame;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '1')
|
assert (outboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
PrintS("-----------------------------------------------------------------");
|
TestSpec("-----------------------------------------------------------------");
|
PrintS("Step 5:");
|
TestSpec("Step 5:");
|
PrintS("Action: Add maximum number of words -1 and test the window accesses.");
|
TestSpec("Action: Add maximum number of words -1 and test the window accesses.");
|
PrintS("Result: The content memory should not accept more frames.");
|
TestSpec("Result: The content memory should not accept more frames.");
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
PrintR("TG_RioPacketBuffer-TC2-Step5");
|
TestCaseStart("TG_RioPacketBuffer-TC2-Step5");
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
|
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '1')
|
assert (outboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
-- Write 11*17=187 (one full frame will not fit).
|
-- Write 11*17=187 (one full frame will not fit).
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
|
|
for i in 0 to 16 loop
|
for i in 0 to 16 loop
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(i, 32)));
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(i, 32)));
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '1')
|
assert (outboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
for j in 1 to 10 loop
|
for j in 1 to 10 loop
|
SetOutboundWriteFrame;
|
SetOutboundWriteFrame;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
for i in 0 to 16 loop
|
for i in 0 to 16 loop
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(j+i, 32)));
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(j+i, 32)));
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
end loop;
|
end loop;
|
end loop;
|
end loop;
|
|
|
SetOutboundWriteFrame;
|
SetOutboundWriteFrame;
|
assert (outboundWriteFrameFull = '1')
|
assert (outboundWriteFrameFull = '1')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
-- Reset the window and remove all frames.
|
-- Reset the window and remove all frames.
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
|
|
SetOutboundReadWindowReset;
|
SetOutboundReadWindowReset;
|
assert (outboundWriteFrameFull = '1')
|
assert (outboundWriteFrameFull = '1')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
SetOutboundReadWindowNext;
|
SetOutboundReadWindowNext;
|
assert (outboundWriteFrameFull = '1')
|
assert (outboundWriteFrameFull = '1')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
SetOutboundReadFrame;
|
SetOutboundReadFrame;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
for j in 1 to 9 loop
|
for j in 1 to 9 loop
|
SetOutboundReadWindowNext;
|
SetOutboundReadWindowNext;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
SetOutboundReadFrame;
|
SetOutboundReadFrame;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
SetOutboundReadWindowNext;
|
SetOutboundReadWindowNext;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
SetOutboundReadFrame;
|
SetOutboundReadFrame;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '1')
|
assert (outboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
PrintS("-----------------------------------------------------------------");
|
TestSpec("-----------------------------------------------------------------");
|
PrintS("Step 6:");
|
TestSpec("Step 6:");
|
PrintS("Action: Add two frames and start reading the second, then remove");
|
TestSpec("Action: Add two frames and start reading the second, then remove");
|
PrintS(" the first.");
|
TestSpec(" the first.");
|
PrintS("Result: The readContentEnd flag should not be changed when frames");
|
TestSpec("Result: The readContentEnd flag should not be changed when frames");
|
PrintS(" are removed.");
|
TestSpec(" are removed.");
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
PrintR("TG_RioPacketBuffer-TC2-Step6");
|
TestCaseStart("TG_RioPacketBuffer-TC2-Step6");
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
|
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '1')
|
assert (outboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
--
|
--
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
|
|
for i in 0 to 3 loop
|
for i in 0 to 3 loop
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(i, 32)));
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(i, 32)));
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
|
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '1')
|
assert (outboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
SetOutboundWriteFrame;
|
SetOutboundWriteFrame;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
for i in 0 to 3 loop
|
for i in 0 to 3 loop
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(i+1, 32)));
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(i+1, 32)));
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
SetOutboundWriteFrame;
|
SetOutboundWriteFrame;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
--
|
--
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
|
|
for i in 0 to 2 loop
|
for i in 0 to 2 loop
|
SetOutboundReadContent(std_logic_vector(to_unsigned(i, 32)));
|
SetOutboundReadContent(std_logic_vector(to_unsigned(i, 32)));
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
SetOutboundReadContent(std_logic_vector(to_unsigned(3, 32)), '1');
|
SetOutboundReadContent(std_logic_vector(to_unsigned(3, 32)), '1');
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
SetOutboundReadWindowNext;
|
SetOutboundReadWindowNext;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
SetOutboundReadContent(std_logic_vector(to_unsigned(1, 32)));
|
SetOutboundReadContent(std_logic_vector(to_unsigned(1, 32)));
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
SetOutboundReadFrame;
|
SetOutboundReadFrame;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
SetOutboundReadContent(std_logic_vector(to_unsigned(2, 32)));
|
SetOutboundReadContent(std_logic_vector(to_unsigned(2, 32)));
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
SetOutboundReadContent(std_logic_vector(to_unsigned(3, 32)));
|
SetOutboundReadContent(std_logic_vector(to_unsigned(3, 32)));
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
SetOutboundReadContent(std_logic_vector(to_unsigned(4, 32)), '1');
|
SetOutboundReadContent(std_logic_vector(to_unsigned(4, 32)), '1');
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
SetOutboundReadWindowNext;
|
SetOutboundReadWindowNext;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
SetOutboundReadFrame;
|
SetOutboundReadFrame;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '1')
|
assert (outboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
PrintS("-----------------------------------------------------------------");
|
TestSpec("-----------------------------------------------------------------");
|
PrintS("TG_RioPacketBuffer");
|
TestSpec("TG_RioPacketBuffer");
|
PrintS("-----------------------------------------------------------------");
|
TestSpec("-----------------------------------------------------------------");
|
PrintS("TG_RioPacketBuffer-TC3");
|
TestSpec("TG_RioPacketBuffer-TC3");
|
PrintS("Description: Test operation when restarting and aborting frames.");
|
TestSpec("Description: Test operation when restarting and aborting frames.");
|
PrintS("Requirement: XXXXX");
|
TestSpec("Requirement: XXXXX");
|
PrintS("-----------------------------------------------------------------");
|
TestSpec("-----------------------------------------------------------------");
|
PrintS("Step 1:");
|
TestSpec("Step 1:");
|
PrintS("Action: Write one frame and abort it.");
|
TestSpec("Action: Write one frame and abort it.");
|
PrintS("Result: The aborted frame should be discarded.");
|
TestSpec("Result: The aborted frame should be discarded.");
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
PrintR("TG_RioPacketBuffer-TC3-Step1");
|
TestCaseStart("TG_RioPacketBuffer-TC3-Step1");
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
|
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '1')
|
assert (outboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
for i in 0 to 3 loop
|
for i in 0 to 3 loop
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(i, 32)));
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(i, 32)));
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '1')
|
assert (outboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
SetOutboundWriteFrameAbort;
|
SetOutboundWriteFrameAbort;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '1')
|
assert (outboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
PrintS("-----------------------------------------------------------------");
|
TestSpec("-----------------------------------------------------------------");
|
PrintS("Step 2:");
|
TestSpec("Step 2:");
|
PrintS("Action: Write one full frame then one more that is aborted.");
|
TestSpec("Action: Write one full frame then one more that is aborted.");
|
PrintS("Result: The first frame should remain and the aborted should be ");
|
TestSpec("Result: The first frame should remain and the aborted should be ");
|
PrintS(" discarded.");
|
TestSpec(" discarded.");
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
PrintR("TG_RioPacketBuffer-TC3-Step2");
|
TestCaseStart("TG_RioPacketBuffer-TC3-Step2");
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
|
|
for i in 0 to 3 loop
|
for i in 0 to 3 loop
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(1+i, 32)));
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(1+i, 32)));
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '1')
|
assert (outboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
SetOutboundWriteFrame;
|
SetOutboundWriteFrame;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
for i in 0 to 3 loop
|
for i in 0 to 3 loop
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(2+i, 32)));
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(2+i, 32)));
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
SetOutboundWriteFrameAbort;
|
SetOutboundWriteFrameAbort;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
for i in 0 to 3 loop
|
for i in 0 to 3 loop
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(3+i, 32)));
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(3+i, 32)));
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
SetOutboundWriteFrame;
|
SetOutboundWriteFrame;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
for i in 0 to 2 loop
|
for i in 0 to 2 loop
|
SetOutboundReadContent(std_logic_vector(to_unsigned(1+i, 32)));
|
SetOutboundReadContent(std_logic_vector(to_unsigned(1+i, 32)));
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
SetOutboundReadContent(std_logic_vector(to_unsigned(1+3, 32)), '1');
|
SetOutboundReadContent(std_logic_vector(to_unsigned(1+3, 32)), '1');
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
SetOutboundReadWindowNext;
|
SetOutboundReadWindowNext;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
SetOutboundReadFrame;
|
SetOutboundReadFrame;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
for i in 0 to 2 loop
|
for i in 0 to 2 loop
|
SetOutboundReadContent(std_logic_vector(to_unsigned(3+i, 32)));
|
SetOutboundReadContent(std_logic_vector(to_unsigned(3+i, 32)));
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
SetOutboundReadContent(std_logic_vector(to_unsigned(3+3, 32)), '1');
|
SetOutboundReadContent(std_logic_vector(to_unsigned(3+3, 32)), '1');
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
SetOutboundReadWindowNext;
|
SetOutboundReadWindowNext;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
SetOutboundReadFrame;
|
SetOutboundReadFrame;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '1')
|
assert (outboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
PrintS("-----------------------------------------------------------------");
|
TestSpec("-----------------------------------------------------------------");
|
PrintS("Step 3:");
|
TestSpec("Step 3:");
|
PrintS("Action: Write one full frame then read one that is restarted.");
|
TestSpec("Action: Write one full frame then read one that is restarted.");
|
PrintS("Result: The content of the first frame should be read twice. ");
|
TestSpec("Result: The content of the first frame should be read twice. ");
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
PrintR("TG_RioPacketBuffer-TC3-Step3");
|
TestCaseStart("TG_RioPacketBuffer-TC3-Step3");
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
|
|
for i in 0 to 3 loop
|
for i in 0 to 3 loop
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(1+i, 32)));
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(1+i, 32)));
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '1')
|
assert (outboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
SetOutboundWriteFrame;
|
SetOutboundWriteFrame;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
for i in 0 to 2 loop
|
for i in 0 to 2 loop
|
SetOutboundReadContent(std_logic_vector(to_unsigned(1+i, 32)));
|
SetOutboundReadContent(std_logic_vector(to_unsigned(1+i, 32)));
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
SetOutboundReadContent(std_logic_vector(to_unsigned(1+3, 32)), '1');
|
SetOutboundReadContent(std_logic_vector(to_unsigned(1+3, 32)), '1');
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
SetOutboundReadFrameRestart;
|
SetOutboundReadFrameRestart;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
for i in 0 to 2 loop
|
for i in 0 to 2 loop
|
SetOutboundReadContent(std_logic_vector(to_unsigned(1+i, 32)));
|
SetOutboundReadContent(std_logic_vector(to_unsigned(1+i, 32)));
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
end loop;
|
end loop;
|
|
|
SetOutboundReadContent(std_logic_vector(to_unsigned(1+3, 32)), '1');
|
SetOutboundReadContent(std_logic_vector(to_unsigned(1+3, 32)), '1');
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
SetOutboundReadWindowNext;
|
SetOutboundReadWindowNext;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
SetOutboundReadFrame;
|
SetOutboundReadFrame;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '1')
|
assert (outboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
|
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
PrintS("-----------------------------------------------------------------");
|
TestSpec("-----------------------------------------------------------------");
|
PrintS("TG_RioPacketBuffer");
|
TestSpec("TG_RioPacketBuffer");
|
PrintS("-----------------------------------------------------------------");
|
TestSpec("-----------------------------------------------------------------");
|
PrintS("TG_RioPacketBuffer-TC4");
|
TestSpec("TG_RioPacketBuffer-TC4");
|
PrintS("Description: Test operation when partial frames are read.");
|
TestSpec("Description: Test operation when partial frames are read.");
|
PrintS("Requirement: XXXXX");
|
TestSpec("Requirement: XXXXX");
|
PrintS("-----------------------------------------------------------------");
|
TestSpec("-----------------------------------------------------------------");
|
PrintS("Step 1:");
|
TestSpec("Step 1:");
|
PrintS("Action: Write a one word frame and read it before it is completed.");
|
TestSpec("Action: Write a one word frame and read it before it is completed.");
|
PrintS("Result: Empty signals should reflect the status of the frame.");
|
TestSpec("Result: Empty signals should reflect the status of the frame.");
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
PrintR("TG_RioPacketBuffer-TC4-Step1");
|
TestCaseStart("TG_RioPacketBuffer-TC4-Step1");
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
|
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '1')
|
assert (outboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
assert (outboundReadContentEmpty = '1')
|
assert (outboundReadContentEmpty = '1')
|
report "Unexpected readContentEmpty." severity error;
|
report "Unexpected readContentEmpty." severity error;
|
|
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(1, 32)));
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(1, 32)));
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '1')
|
assert (outboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
assert (outboundReadContentEmpty = '0')
|
assert (outboundReadContentEmpty = '0')
|
report "Unexpected readContentEmpty." severity error;
|
report "Unexpected readContentEmpty." severity error;
|
|
|
SetOutboundReadContent(std_logic_vector(to_unsigned(1, 32)), '1');
|
SetOutboundReadContent(std_logic_vector(to_unsigned(1, 32)), '1');
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '1')
|
assert (outboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
assert (outboundReadContentEmpty = '1')
|
assert (outboundReadContentEmpty = '1')
|
report "Unexpected readContentEmpty." severity error;
|
report "Unexpected readContentEmpty." severity error;
|
|
|
SetOutboundWriteFrame;
|
SetOutboundWriteFrame;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
assert (outboundReadContentEmpty = '0')
|
assert (outboundReadContentEmpty = '0')
|
report "Unexpected readContentEmpty." severity error;
|
report "Unexpected readContentEmpty." severity error;
|
|
|
SetOutboundReadWindowNext;
|
SetOutboundReadWindowNext;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
assert (outboundReadContentEmpty = '1')
|
assert (outboundReadContentEmpty = '1')
|
report "Unexpected readContentEmpty." severity error;
|
report "Unexpected readContentEmpty." severity error;
|
|
|
SetOutboundReadFrame;
|
SetOutboundReadFrame;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '1')
|
assert (outboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
assert (outboundReadContentEmpty = '1')
|
assert (outboundReadContentEmpty = '1')
|
report "Unexpected readContentEmpty." severity error;
|
report "Unexpected readContentEmpty." severity error;
|
|
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
PrintS("-----------------------------------------------------------------");
|
TestSpec("-----------------------------------------------------------------");
|
PrintS("Step 2:");
|
TestSpec("Step 2:");
|
PrintS("Action: Write content to a frame and read it, then abort the frame.");
|
TestSpec("Action: Write content to a frame and read it, then abort the frame.");
|
PrintS("Result: The reader should be notified about the aborted frame. The");
|
TestSpec("Result: The reader should be notified about the aborted frame. The");
|
PrintS(" notification should be reset when the frame has been ");
|
TestSpec(" notification should be reset when the frame has been ");
|
PrintS(" restarted.");
|
TestSpec(" restarted.");
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
PrintR("TG_RioPacketBuffer-TC4-Step2");
|
TestCaseStart("TG_RioPacketBuffer-TC4-Step2");
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
|
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(1, 32)));
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(1, 32)));
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '1')
|
assert (outboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
assert (outboundReadContentEmpty = '0')
|
assert (outboundReadContentEmpty = '0')
|
report "Unexpected readContentEmpty." severity error;
|
report "Unexpected readContentEmpty." severity error;
|
assert (outboundReadFrameAborted = '0')
|
assert (outboundReadFrameAborted = '0')
|
report "Unexpected readFrameAborted." severity error;
|
report "Unexpected readFrameAborted." severity error;
|
|
|
SetOutboundReadContent(std_logic_vector(to_unsigned(1, 32)));
|
SetOutboundReadContent(std_logic_vector(to_unsigned(1, 32)));
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '1')
|
assert (outboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
assert (outboundReadContentEmpty = '1')
|
assert (outboundReadContentEmpty = '1')
|
report "Unexpected readContentEmpty." severity error;
|
report "Unexpected readContentEmpty." severity error;
|
assert (outboundReadFrameAborted = '0')
|
assert (outboundReadFrameAborted = '0')
|
report "Unexpected readFrameAborted." severity error;
|
report "Unexpected readFrameAborted." severity error;
|
|
|
SetOutboundWriteFrameAbort;
|
SetOutboundWriteFrameAbort;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '1')
|
assert (outboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
assert (outboundReadContentEmpty = '0')
|
assert (outboundReadContentEmpty = '0')
|
report "Unexpected readContentEmpty." severity error;
|
report "Unexpected readContentEmpty." severity error;
|
assert (outboundReadFrameAborted = '1')
|
assert (outboundReadFrameAborted = '1')
|
report "Unexpected readFrameAborted." severity error;
|
report "Unexpected readFrameAborted." severity error;
|
|
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(2, 32)));
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(2, 32)));
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '1')
|
assert (outboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
assert (outboundReadContentEmpty = '1')
|
assert (outboundReadContentEmpty = '1')
|
report "Unexpected readContentEmpty." severity error;
|
report "Unexpected readContentEmpty." severity error;
|
assert (outboundReadFrameAborted = '1')
|
assert (outboundReadFrameAborted = '1')
|
report "Unexpected readFrameAborted." severity error;
|
report "Unexpected readFrameAborted." severity error;
|
|
|
SetOutboundReadFrameRestart;
|
SetOutboundReadFrameRestart;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '1')
|
assert (outboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
assert (outboundReadContentEmpty = '0')
|
assert (outboundReadContentEmpty = '0')
|
report "Unexpected readContentEmpty." severity error;
|
report "Unexpected readContentEmpty." severity error;
|
assert (outboundReadFrameAborted = '0')
|
assert (outboundReadFrameAborted = '0')
|
report "Unexpected readFrameAborted." severity error;
|
report "Unexpected readFrameAborted." severity error;
|
|
|
SetOutboundReadContent(std_logic_vector(to_unsigned(2, 32)), '1');
|
SetOutboundReadContent(std_logic_vector(to_unsigned(2, 32)), '1');
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '1')
|
assert (outboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
assert (outboundReadContentEmpty = '1')
|
assert (outboundReadContentEmpty = '1')
|
report "Unexpected readContentEmpty." severity error;
|
report "Unexpected readContentEmpty." severity error;
|
assert (outboundReadFrameAborted = '0')
|
assert (outboundReadFrameAborted = '0')
|
report "Unexpected readFrameAborted." severity error;
|
report "Unexpected readFrameAborted." severity error;
|
|
|
SetOutboundWriteFrame;
|
SetOutboundWriteFrame;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
assert (outboundReadContentEmpty = '0')
|
assert (outboundReadContentEmpty = '0')
|
report "Unexpected readContentEmpty." severity error;
|
report "Unexpected readContentEmpty." severity error;
|
assert (outboundReadFrameAborted = '0')
|
assert (outboundReadFrameAborted = '0')
|
report "Unexpected readFrameAborted." severity error;
|
report "Unexpected readFrameAborted." severity error;
|
|
|
SetOutboundReadWindowNext;
|
SetOutboundReadWindowNext;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
assert (outboundReadContentEmpty = '1')
|
assert (outboundReadContentEmpty = '1')
|
report "Unexpected readContentEmpty." severity error;
|
report "Unexpected readContentEmpty." severity error;
|
assert (outboundReadFrameAborted = '0')
|
assert (outboundReadFrameAborted = '0')
|
report "Unexpected readFrameAborted." severity error;
|
report "Unexpected readFrameAborted." severity error;
|
|
|
SetOutboundReadFrame;
|
SetOutboundReadFrame;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '1')
|
assert (outboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
assert (outboundReadContentEmpty = '1')
|
assert (outboundReadContentEmpty = '1')
|
report "Unexpected readContentEmpty." severity error;
|
report "Unexpected readContentEmpty." severity error;
|
assert (outboundReadFrameAborted = '0')
|
assert (outboundReadFrameAborted = '0')
|
report "Unexpected readFrameAborted." severity error;
|
report "Unexpected readFrameAborted." severity error;
|
|
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
PrintS("-----------------------------------------------------------------");
|
TestSpec("-----------------------------------------------------------------");
|
PrintS("Step 3:");
|
TestSpec("Step 3:");
|
PrintS("Action: Write one complete frame then abort a second.");
|
TestSpec("Action: Write one complete frame then abort a second.");
|
PrintS("Result: The reader should not notice the aborted frame. ");
|
TestSpec("Result: The reader should not notice the aborted frame. ");
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
PrintR("TG_RioPacketBuffer-TC4-Step3");
|
TestCaseStart("TG_RioPacketBuffer-TC4-Step3");
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
|
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(1, 32)));
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(1, 32)));
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '1')
|
assert (outboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
assert (outboundReadContentEmpty = '0')
|
assert (outboundReadContentEmpty = '0')
|
report "Unexpected readContentEmpty." severity error;
|
report "Unexpected readContentEmpty." severity error;
|
assert (outboundReadFrameAborted = '0')
|
assert (outboundReadFrameAborted = '0')
|
report "Unexpected readFrameAborted." severity error;
|
report "Unexpected readFrameAborted." severity error;
|
|
|
SetOutboundReadContent(std_logic_vector(to_unsigned(1, 32)), '1');
|
SetOutboundReadContent(std_logic_vector(to_unsigned(1, 32)), '1');
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '1')
|
assert (outboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
assert (outboundReadContentEmpty = '1')
|
assert (outboundReadContentEmpty = '1')
|
report "Unexpected readContentEmpty." severity error;
|
report "Unexpected readContentEmpty." severity error;
|
assert (outboundReadFrameAborted = '0')
|
assert (outboundReadFrameAborted = '0')
|
report "Unexpected readFrameAborted." severity error;
|
report "Unexpected readFrameAborted." severity error;
|
|
|
SetOutboundWriteFrame;
|
SetOutboundWriteFrame;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
assert (outboundReadContentEmpty = '0')
|
assert (outboundReadContentEmpty = '0')
|
report "Unexpected readContentEmpty." severity error;
|
report "Unexpected readContentEmpty." severity error;
|
assert (outboundReadFrameAborted = '0')
|
assert (outboundReadFrameAborted = '0')
|
report "Unexpected readFrameAborted." severity error;
|
report "Unexpected readFrameAborted." severity error;
|
|
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(2, 32)));
|
SetOutboundWriteContent(std_logic_vector(to_unsigned(2, 32)));
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
assert (outboundReadContentEmpty = '0')
|
assert (outboundReadContentEmpty = '0')
|
report "Unexpected readContentEmpty." severity error;
|
report "Unexpected readContentEmpty." severity error;
|
assert (outboundReadFrameAborted = '0')
|
assert (outboundReadFrameAborted = '0')
|
report "Unexpected readFrameAborted." severity error;
|
report "Unexpected readFrameAborted." severity error;
|
|
|
SetOutboundWriteFrameAbort;
|
SetOutboundWriteFrameAbort;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '0')
|
assert (outboundReadWindowEmpty = '0')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
assert (outboundReadContentEmpty = '0')
|
assert (outboundReadContentEmpty = '0')
|
report "Unexpected readContentEmpty." severity error;
|
report "Unexpected readContentEmpty." severity error;
|
assert (outboundReadFrameAborted = '0')
|
assert (outboundReadFrameAborted = '0')
|
report "Unexpected readFrameAborted." severity error;
|
report "Unexpected readFrameAborted." severity error;
|
|
|
SetOutboundReadWindowNext;
|
SetOutboundReadWindowNext;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '0')
|
assert (outboundReadFrameEmpty = '0')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
assert (outboundReadContentEmpty = '1')
|
assert (outboundReadContentEmpty = '1')
|
report "Unexpected readContentEmpty." severity error;
|
report "Unexpected readContentEmpty." severity error;
|
assert (outboundReadFrameAborted = '0')
|
assert (outboundReadFrameAborted = '0')
|
report "Unexpected readFrameAborted." severity error;
|
report "Unexpected readFrameAborted." severity error;
|
|
|
SetOutboundReadFrame;
|
SetOutboundReadFrame;
|
assert (outboundWriteFrameFull = '0')
|
assert (outboundWriteFrameFull = '0')
|
report "Unexpected writeFrameFull." severity error;
|
report "Unexpected writeFrameFull." severity error;
|
assert (outboundReadFrameEmpty = '1')
|
assert (outboundReadFrameEmpty = '1')
|
report "Unexpected readFrameEmpty." severity error;
|
report "Unexpected readFrameEmpty." severity error;
|
assert (outboundReadWindowEmpty = '1')
|
assert (outboundReadWindowEmpty = '1')
|
report "Unexpected readWindowEmpty." severity error;
|
report "Unexpected readWindowEmpty." severity error;
|
assert (outboundReadContentEmpty = '1')
|
assert (outboundReadContentEmpty = '1')
|
report "Unexpected readContentEmpty." severity error;
|
report "Unexpected readContentEmpty." severity error;
|
assert (outboundReadFrameAborted = '0')
|
assert (outboundReadFrameAborted = '0')
|
report "Unexpected readFrameAborted." severity error;
|
report "Unexpected readFrameAborted." severity error;
|
|
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
-- Test completed.
|
-- Test completed.
|
---------------------------------------------------------------------------
|
---------------------------------------------------------------------------
|
|
|
TestEnd;
|
TestEnd;
|
end process;
|
end process;
|
|
|
-----------------------------------------------------------------------------
|
-----------------------------------------------------------------------------
|
-- Instantiate the testobject.
|
-- Instantiate the testobject.
|
-----------------------------------------------------------------------------
|
-----------------------------------------------------------------------------
|
|
|
TestPacketBuffer: RioPacketBufferWindow
|
TestPacketBuffer: RioPacketBufferWindow
|
port map(
|
port map(
|
clk=>clk, areset_n=>areset_n,
|
clk=>clk, areset_n=>areset_n,
|
inboundWriteFrameFull_o=>inboundWriteFrameFull,
|
inboundWriteFrameFull_o=>inboundWriteFrameFull,
|
inboundWriteFrame_i=>inboundWriteFrame,
|
inboundWriteFrame_i=>inboundWriteFrame,
|
inboundWriteFrameAbort_i=>inboundWriteFrameAbort,
|
inboundWriteFrameAbort_i=>inboundWriteFrameAbort,
|
inboundWriteContent_i=>inboundWriteContent,
|
inboundWriteContent_i=>inboundWriteContent,
|
inboundWriteContentData_i=>inboundWriteContentData,
|
inboundWriteContentData_i=>inboundWriteContentData,
|
inboundReadFrameEmpty_o=>inboundReadFrameEmpty,
|
inboundReadFrameEmpty_o=>inboundReadFrameEmpty,
|
inboundReadFrame_i=>inboundReadFrame,
|
inboundReadFrame_i=>inboundReadFrame,
|
inboundReadFrameRestart_i=>inboundReadFrameRestart,
|
inboundReadFrameRestart_i=>inboundReadFrameRestart,
|
inboundReadFrameAborted_o=>inboundReadFrameAborted,
|
inboundReadFrameAborted_o=>inboundReadFrameAborted,
|
inboundReadContentEmpty_o=>inboundReadContentEmpty,
|
inboundReadContentEmpty_o=>inboundReadContentEmpty,
|
inboundReadContent_i=>inboundReadContent,
|
inboundReadContent_i=>inboundReadContent,
|
inboundReadContentEnd_o=>inboundReadContentEnd,
|
inboundReadContentEnd_o=>inboundReadContentEnd,
|
inboundReadContentData_o=>inboundReadContentData,
|
inboundReadContentData_o=>inboundReadContentData,
|
outboundWriteFrameFull_o=>outboundWriteFrameFull,
|
outboundWriteFrameFull_o=>outboundWriteFrameFull,
|
outboundWriteFrame_i=>outboundWriteFrame,
|
outboundWriteFrame_i=>outboundWriteFrame,
|
outboundWriteFrameAbort_i=>outboundWriteFrameAbort,
|
outboundWriteFrameAbort_i=>outboundWriteFrameAbort,
|
outboundWriteContent_i=>outboundWriteContent,
|
outboundWriteContent_i=>outboundWriteContent,
|
outboundWriteContentData_i=>outboundWriteContentData,
|
outboundWriteContentData_i=>outboundWriteContentData,
|
outboundReadFrameEmpty_o=>outboundReadFrameEmpty,
|
outboundReadFrameEmpty_o=>outboundReadFrameEmpty,
|
outboundReadFrame_i=>outboundReadFrame,
|
outboundReadFrame_i=>outboundReadFrame,
|
outboundReadFrameRestart_i=>outboundReadFrameRestart,
|
outboundReadFrameRestart_i=>outboundReadFrameRestart,
|
outboundReadFrameAborted_o=>outboundReadFrameAborted,
|
outboundReadFrameAborted_o=>outboundReadFrameAborted,
|
outboundReadWindowEmpty_o=>outboundReadWindowEmpty,
|
outboundReadWindowEmpty_o=>outboundReadWindowEmpty,
|
outboundReadWindowReset_i=>outboundReadWindowReset,
|
outboundReadWindowReset_i=>outboundReadWindowReset,
|
outboundReadWindowNext_i=>outboundReadWindowNext,
|
outboundReadWindowNext_i=>outboundReadWindowNext,
|
outboundReadContentEmpty_o=>outboundReadContentEmpty,
|
outboundReadContentEmpty_o=>outboundReadContentEmpty,
|
outboundReadContent_i=>outboundReadContent,
|
outboundReadContent_i=>outboundReadContent,
|
outboundReadContentEnd_o=>outboundReadContentEnd,
|
outboundReadContentEnd_o=>outboundReadContentEnd,
|
outboundReadContentData_o=>outboundReadContentData);
|
outboundReadContentData_o=>outboundReadContentData);
|
|
|
end architecture;
|
end architecture;
|
|
|