Subversion Repositories rio

/*******************************************************************************

 *

 * RapidIO IP Library Core

 *

 * This file is part of the RapidIO IP library project

 * http://www.opencores.org/cores/rio/

 *

 * Description:

 * This file contains automatic regression tests for riopacket. Compile and

 * run it by using:

 * gcc -o testriostack test_riostack.c riopacket.c -fprofile-arcs -ftest-coverage

 * ./testriostack

 * gcov test_riostack.c

 *

 * To Do:

 * -

 *

 * Author(s):

 * - Magnus Rosenius, magro732@opencores.org

 *

 *******************************************************************************

 *

 * Copyright (C) 2015 Authors and OPENCORES.ORG

 *

 * This source file may be used and distributed without

 * restriction provided that this copyright statement is not

 * removed from the file and that any derivative work contains

 * the original copyright notice and the associated disclaimer.

 *

 * This source file is free software; you can redistribute it

 * and/or modify it under the terms of the GNU Lesser General

 * Public License as published by the Free Software Foundation;

 * either version 2.1 of the License, or (at your option) any

 * later version.

 *

 * This source is distributed in the hope that it will be

 * useful, but WITHOUT ANY WARRANTY; without even the implied

 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR

 * PURPOSE. See the GNU Lesser General Public License for more

 * details.

 *

 * You should have received a copy of the GNU Lesser General

 * Public License along with this source; if not, download it

 * from http://www.opencores.org/lgpl.shtml

 *

 *******************************************************************************/

#include <stdio.h>

#include <stdlib.h>

#define MODULE_TEST

#include "riostack.c"

#define PrintS(s)                               \

  {                                             \

    FILE *fd;                                   \

    fd=fopen("testspec.txt", "a");              \

    fputs(s "\n", fd);                          \

    fclose(fd);                                 \

  }

#define TESTSTART(s) printf(s)

#define TESTEND printf(" passed.\n");

#define TESTCOND(got)                                   \

  if (!(got))                                           \

  {                                                     \

    printf("\nERROR at line %u:%s=%u (0x%08x)\n",       \

           __LINE__, #got, (got), (got));               \

    exit(1);                                            \

  }

#define TESTEXPR(got, expected)                                         \

  if ((got)!=(expected))                                                \

  {                                                                     \

    printf("\nERROR at line %u:%s=%u (0x%08x) expected=%u (0x%08x)\n",  \

           __LINE__, #got, (got), (got), (expected), (expected));       \

    exit(1);                                                            \

  }

#define TESTSYMBOL(got, expected) testSymbol(__LINE__, #got, (got), (expected))

void testSymbol(uint32_t line, char *expression, RioSymbol_t got, RioSymbol_t expected)

{

  if ((got).type==(expected).type)

  {

    switch ((got).type)

    {

      case RIOSTACK_SYMBOL_TYPE_ERROR:

      case RIOSTACK_SYMBOL_TYPE_IDLE:

        break;

      case RIOSTACK_SYMBOL_TYPE_CONTROL:

        if((got).data != (expected).data)

        {

          if(STYPE0_GET((got).data) != STYPE0_GET((expected).data))

          {

            printf("\nERROR at line %u:STYPE0=0x%02x expected=0x%02x\n",

                   line, STYPE0_GET((got).data), STYPE0_GET((expected).data));

          }

          if(PARAMETER0_GET((got).data) != PARAMETER0_GET((expected).data))

          {

            printf("\nERROR at line %u:PARAMETER0=0x%02x expected=0x%02x\n",

                   line, PARAMETER0_GET((got).data), PARAMETER0_GET((expected).data));

          }

          if(PARAMETER1_GET((got).data) != PARAMETER1_GET((expected).data))

          {

            printf("\nERROR at line %u:PARAMETER1=0x%02x expected=0x%02x\n",

                   line, PARAMETER1_GET((got).data), PARAMETER1_GET((expected).data));

          }

          if(STYPE1_GET((got).data) != STYPE1_GET((expected).data))

          {

            printf("\nERROR at line %u:STYPE1=0x%02x expected=0x%02x\n",

                   line, STYPE1_GET((got).data), STYPE1_GET((expected).data));

          }

          if(CMD_GET((got).data) != CMD_GET((expected).data))

          {

            printf("\nERROR at line %u:CMD=0x%02x expected=0x%02x\n",

                   line, CMD_GET((got).data), CMD_GET((expected).data));

          }

          if(CRC5_GET((got).data) != CRC5_GET((expected).data))

          {

            printf("\nERROR at line %u:CRC5=0x%02x expected=0x%02x\n",

                   line, CRC5_GET((got).data), CRC5_GET((expected).data));

          }

          exit(1);

        }

        break;

      case RIOSTACK_SYMBOL_TYPE_DATA:

        if((got).data != (expected).data)

        {

          printf("\nERROR at line %u:%s=%u (0x%08x) expected=%u (0x%08x)\n",

                 line, expression, (got).data, (got).data, (expected).data, (expected).data);

          exit(1);

        }

        break;

    }

  }

  else

  {

    printf("\nERROR at line %u:%s=%u (0x%08x) expected=%u (0x%08x)\n",

           line, expression, (got).type, (got).type, (expected).type, (expected).type);

    exit(1);

  }

}

uint8_t createDoorbell(uint32_t *doorbell, uint8_t ackId, uint16_t destid, uint16_t srcId, uint8_t tid, uint16_t info)

{

  uint16_t crc;

  uint32_t content;

  /* ackId(4:0)|0|vc|crf|prio(1:0)|tt(1:0)|ftype(3:0)|destinationId(15:0) */

  /* ackId is set when the packet is transmitted. */

  content = 0x001aul << 16;

  content |= (uint32_t) destid;

  crc = RIOPACKET_Crc32(content, 0xffffu);

  doorbell[0] = (((uint32_t) ackId) << 27) | content;

  /* sourceId(15:0)|rsrv(7:0)|srcTID(7:0) */

  content = ((uint32_t) srcId) << 16;

  content |= (uint32_t) tid;

  crc = RIOPACKET_Crc32(content, crc);

  doorbell[1] = content;

  /* infoMSB(7:0)|infoLSB(7:0)|crc(15:0) */

  content = ((uint32_t) info) << 16;

  crc = RIOPACKET_Crc16(info, crc);

  content |= ((uint32_t) crc);

  doorbell[2] = content;

  return 3;

}

/*******************************************************************************

 * Module test for this file.

 *******************************************************************************/

int32_t main(void)

{

  RioStack_t stack;

  uint32_t rxPacketBuffer[RIOSTACK_BUFFER_SIZE*8], txPacketBuffer[RIOSTACK_BUFFER_SIZE*8];

  RioPacket_t rioPacket;

  uint32_t packet[69];

  RioSymbol_t s, c, d;

  int i, j, k;

  uint16_t length;

  uint16_t dstid;

  uint16_t srcid;

  uint8_t tid;

  uint8_t hop;

  uint8_t mailbox;

  uint16_t info;

  uint32_t address;

  uint32_t data;

  uint8_t payload8[256];

  uint8_t payload8Expected[256];

  uint32_t packetLength;

  /*************************************************************************

   * Test prelude.

   * Setup the RIO stack for operation.

   *************************************************************************/

  /* Open the stack and set the port status to initialized. */

  RIOSTACK_open(&stack, NULL,

                RIOSTACK_BUFFER_SIZE*8, &rxPacketBuffer[0],

                RIOSTACK_BUFFER_SIZE*8, &txPacketBuffer[0]);

  /* Set the port timeout. */

  RIOSTACK_portSetTimeout(&stack, 1);

  /* Set the current port time. */

  RIOSTACK_portSetTime(&stack, 0);

  /******************************************************************************/

  PrintS("----------------------------------------------------------------------");

  PrintS("TG_riostack");

  PrintS("----------------------------------------------------------------------");

  PrintS("TG_riostack-TC1");

  PrintS("Description: Test link initialization and normal packet exchange.");

  PrintS("Requirement: XXXXX");

  PrintS("----------------------------------------------------------------------");

  PrintS("Step 1:");

  PrintS("Action: Send packets when port is uninitialized.");

  PrintS("Result: All packets should be ignored during initialization.");

  PrintS("----------------------------------------------------------------------");

  /******************************************************************************/

  TESTSTART("TG_riostack-TC1-Step1");

  /******************************************************************************/

  /* Place a packet in the outbound queue to check that it is received once

     the transmitter is placed in the correct state. */

  RIOPACKET_setDoorbell(&rioPacket, 1, 0xffff, 0, 0xdeaf);

  RIOSTACK_setOutboundPacket(&stack, &rioPacket);

  /* Check that only idle symbols are transmitted when the port has not been

     initialied even if statuses are received. */

  for(i = 0; i < 1024; i++)

  {

    RIOSTACK_portAddSymbol(&stack, CreateControlSymbol(STYPE0_STATUS, 0, 1, STYPE1_NOP, 0));

    s = RIOSTACK_portGetSymbol(&stack);

    TESTEXPR(s.type, RIOSTACK_SYMBOL_TYPE_IDLE);

  }

  /******************************************************************************/

  TESTEND;

  /*****************************************************************************/

  PrintS("----------------------------------------------------------------------");

  PrintS("Step 2:");

  PrintS("Action: Set port initialized and get symbols from the stack.");

  PrintS("Result: Status-control-symbols should be generated each 256 symbol.");

  PrintS("----------------------------------------------------------------------");

  /*****************************************************************************/

  TESTSTART("TG_riostack-TC1-Step2");

  /*****************************************************************************/

  /* Set the port status to intialized. */

  RIOSTACK_portSetStatus(&stack, 1);

  /* Set port time. */

  RIOSTACK_portSetTime(&stack, 1);

  /* Check that status-control-symbols are transmitted once every 256 symbol. */

  for(j = 0; j < 15; j++)

  {

    for(i = 0; i < 255; i++)

    {

      s = RIOSTACK_portGetSymbol(&stack);

      TESTEXPR(s.type, RIOSTACK_SYMBOL_TYPE_IDLE);

    }

    s = RIOSTACK_portGetSymbol(&stack);

    c = CreateControlSymbol(STYPE0_STATUS, 0, 8, STYPE1_NOP, 0);

    TESTEXPR(s.type, c.type);

    TESTEXPR(s.data, c.data);

  }

  /******************************************************************************/

  TESTEND;

  /******************************************************************************/

  PrintS("----------------------------------------------------------------------");

  PrintS("Step 3:");

  PrintS("Action: Add a status-control-symbol to the receiver.");

  PrintS("Result: Status-control-symbols should be generated each 15 symbol.");

  PrintS("----------------------------------------------------------------------");

  /******************************************************************************/

  TESTSTART("TG_riostack-TC1-Step3");

  /*****************************************************************************/

  /* Insert a status-control-symbol in the receive. */

  RIOSTACK_portAddSymbol(&stack, CreateControlSymbol(STYPE0_STATUS, 0, 1, STYPE1_NOP, 0));

  /* Check that status-control-symbols are transmitted once every 16 symbol. */

  for(i = 0; i < 15; i++)

  {

    s = RIOSTACK_portGetSymbol(&stack);

    TESTEXPR(s.type, RIOSTACK_SYMBOL_TYPE_IDLE);

  }

  s = RIOSTACK_portGetSymbol(&stack);

  c = CreateControlSymbol(STYPE0_STATUS, 0, 8, STYPE1_NOP, 0);

  TESTEXPR(s.type, c.type);

  TESTEXPR(s.data, c.data);

  /******************************************************************************/

  TESTEND;

  /******************************************************************************/

  PrintS("----------------------------------------------------------------------");

  PrintS("Step 4:");

  PrintS("Action: Add a packet to the receiver.");

  PrintS("Result: Packet should be ignored until the link is initialized.");

  PrintS("----------------------------------------------------------------------");

  /******************************************************************************/

  TESTSTART("TG_riostack-TC1-Step4");

  /*****************************************************************************/

  /* Send a packet. Note that the start and end of the packet contains a status. */

  packetLength = createDoorbell(packet, 0, 0, 0, 0, 0);

  RIOSTACK_portAddSymbol(&stack, CreateControlSymbol(STYPE0_STATUS, 0, 8, STYPE1_START_OF_PACKET, 0));

  for(i = 0; i < packetLength; i++)

  {

    d.type = RIOSTACK_SYMBOL_TYPE_DATA;

    d.data = packet[i];

    RIOSTACK_portAddSymbol(&stack, d);

  }

  RIOSTACK_portAddSymbol(&stack, CreateControlSymbol(STYPE0_STATUS, 0, 8, STYPE1_END_OF_PACKET, 0));

  /* Check that packet was not received. */

  TESTEXPR(RIOSTACK_getInboundQueueLength(&stack), 0);

  /******************************************************************************/

  TESTEND;

  /******************************************************************************/

  PrintS("----------------------------------------------------------------------");

  PrintS("Step 5:");

  PrintS("Action: Add four more status-control-symbols followed by one with error in ");

  PrintS("        CRC5. Then send a packet.");

  PrintS("Result: The receiver should remain in port initialized and packet should ");

  PrintS("        still be ignored.");

  PrintS("----------------------------------------------------------------------");

  /******************************************************************************/

  TESTSTART("TG_riostack-TC1-Step5");

  /*****************************************************************************/

  /* Send 4 more status-control-symbols followed by one erronous. */

  for(i = 0; i < 4; i++)

  {

    RIOSTACK_portAddSymbol(&stack, CreateControlSymbol(STYPE0_STATUS, 0, 1, STYPE1_NOP, 0));

  }

  c = CreateControlSymbol(STYPE0_STATUS, 0, 1, STYPE1_NOP, 0);

  c.data ^= 1;

  RIOSTACK_portAddSymbol(&stack, c);

  /* Send a packet. Note that the start and end of the packet contains status. */

  packetLength = createDoorbell(packet, 0, 0, 0, 0, 0);

  RIOSTACK_portAddSymbol(&stack, CreateControlSymbol(STYPE0_STATUS, 0, 8, STYPE1_START_OF_PACKET, 0));

  for(i = 0; i < packetLength; i++)

  {

    d.type = RIOSTACK_SYMBOL_TYPE_DATA;

    d.data = packet[i];

    RIOSTACK_portAddSymbol(&stack, d);

  }

  RIOSTACK_portAddSymbol(&stack, CreateControlSymbol(STYPE0_STATUS, 0, 8, STYPE1_END_OF_PACKET, 0));

  /* Check that the packet was ignored. */

  TESTEXPR(RIOSTACK_getInboundQueueLength(&stack), 0);

  /******************************************************************************/

  TESTEND;

  /******************************************************************************/

  PrintS("----------------------------------------------------------------------");

  PrintS("Step 6:");

  PrintS("Action: Add six more status-control-symbols. Then send a packet.");

  PrintS("Result: The receiver should enter link initialized and the packet should ");

  PrintS("        be received.");

  PrintS("----------------------------------------------------------------------");

  /******************************************************************************/

  TESTSTART("TG_riostack-TC1-Step6");

  /*****************************************************************************/

  /* Send 6 more status-control-symbols. */

  for(i = 0; i < 6; i++)

  {

    RIOSTACK_portAddSymbol(&stack, CreateControlSymbol(STYPE0_STATUS, 0, 1, STYPE1_NOP, 0));

  }

  /* Send a packet and check that it is accepted. */

  /* The ackId on receiver in testobject is updated when this has been transmitted. */

  packetLength = createDoorbell(packet, 0, 0, 0, 0, 0);

  RIOSTACK_portAddSymbol(&stack, CreateControlSymbol(STYPE0_STATUS, 0, 8, STYPE1_START_OF_PACKET, 0));

  for(i = 0; i < packetLength; i++)

  {

    d.type = RIOSTACK_SYMBOL_TYPE_DATA;

    d.data = packet[i];

    RIOSTACK_portAddSymbol(&stack, d);

  }

  RIOSTACK_portAddSymbol(&stack, CreateControlSymbol(STYPE0_STATUS, 0, 8, STYPE1_END_OF_PACKET, 0));

  /* Check that the packet is received. */

  TESTEXPR(RIOSTACK_getInboundQueueLength(&stack), 1);

  /******************************************************************************/

  TESTEND;

  /******************************************************************************/

  PrintS("----------------------------------------------------------------------");

  PrintS("Step 7:");

  PrintS("Action: Get symbols from transmitter.");

  PrintS("Result: Status-control-symbols should still be generated each 15 symbol ");

  PrintS("until a total of 15 status-control-symbols has been transmitted. Once these ");

  PrintS("has been transmitted, the transmitter will be link initialized.");

  PrintS("----------------------------------------------------------------------");

  /******************************************************************************/

  TESTSTART("TG_riostack-TC1-Step7");

  /*****************************************************************************/

  /* Note that the available buffers in the receiver should have decremented once

     since the previously received packet has not been read from the application

     side of the stack yet. */

  for(j = 0; j < 14; j++)

  {

    for(i = 0; i < 15; i++)

    {

      s = RIOSTACK_portGetSymbol(&stack);

      TESTEXPR(s.type, RIOSTACK_SYMBOL_TYPE_IDLE);

    }

    s = RIOSTACK_portGetSymbol(&stack);

    c = CreateControlSymbol(STYPE0_STATUS, 1, 7, STYPE1_NOP, 0);

    TESTEXPR(s.type, c.type);

    TESTEXPR(s.data, c.data);

  }

  /******************************************************************************/

  TESTEND;

  /******************************************************************************/

  PrintS("----------------------------------------------------------------------");

  PrintS("Step 8:");

  PrintS("Action: Get the first symbol from the transmitter once the link-intialized ");

  PrintS("        state has been entered.");

  PrintS("Result: A packet-accepted-symbol should be received for the newly received ");

  PrintS("        packet.");

  PrintS("----------------------------------------------------------------------");

  /******************************************************************************/

  TESTSTART("TG_riostack-TC1-Step8");

  /*****************************************************************************/

  c = CreateControlSymbol(STYPE0_PACKET_ACCEPTED, 0, 7, STYPE1_NOP, 0);

  s = RIOSTACK_portGetSymbol(&stack);

  TESTEXPR(s.type, c.type);

  TESTEXPR(s.data, c.data);

  /******************************************************************************/

  TESTEND;

  /******************************************************************************/

  PrintS("----------------------------------------------------------------------");

  PrintS("Step 9:");

  PrintS("Action: Get the next symbols from the transmitter.");

  PrintS("Result: The packet placed in the outbound queue at startup should be ");

  PrintS("        received. Dont acknowledge the packet yet.");

  PrintS("----------------------------------------------------------------------");

  /******************************************************************************/

  TESTSTART("TG_riostack-TC1-Step9");

  /*****************************************************************************/

  /* Create a packet. */

  packetLength = createDoorbell(packet, 0, 1, 0xffff, 0, 0xdeaf);

  /* Receive the start of the frame. */

  c = CreateControlSymbol(STYPE0_STATUS, 1, 7, STYPE1_START_OF_PACKET, 0);

  s = RIOSTACK_portGetSymbol(&stack);

  TESTEXPR(s.type, c.type);

  TESTEXPR(s.data, c.data);

  /* Receive the data of the frame. */

  for(i = 0; i < packetLength; i++)

  {

    s = RIOSTACK_portGetSymbol(&stack);

    d.type = RIOSTACK_SYMBOL_TYPE_DATA;

    d.data = packet[i];

    TESTEXPR(s.type, d.type);

    TESTEXPR(s.data, d.data);

  }

  /* Receive the end of the frame. */

  c = CreateControlSymbol(STYPE0_STATUS, 1, 7, STYPE1_END_OF_PACKET, 0);

  s = RIOSTACK_portGetSymbol(&stack);

  TESTSYMBOL(s, c);

  /******************************************************************************/

  TESTEND;

  /******************************************************************************/

  PrintS("----------------------------------------------------------------------");

  PrintS("Step 10:");

  PrintS("Action: Remove the packet from the inbound queue. Dont acknowledge the");

  PrintS("        transmitted packet yet.");

  PrintS("Result: Check that status-control-symbols are sent each 256 symbol and that ");

  PrintS("        the buffer count is updated when the inbound packet has been read.");

  PrintS("----------------------------------------------------------------------");

  /******************************************************************************/

  TESTSTART("TG_riostack-TC1-Step10");

  /*****************************************************************************/

  /* Simulate the application reading the received packet to free one reception

     buffer. */

  RIOSTACK_getInboundPacket(&stack, &rioPacket);

  /* Check that the status-control-symbols are generated each 256 symbol. */

  for(i = 0; i < 255; i++)

  {

    s = RIOSTACK_portGetSymbol(&stack);

    TESTEXPR(s.type, RIOSTACK_SYMBOL_TYPE_IDLE);

  }

  /* Check that the buffer status has been updated. */

  s = RIOSTACK_portGetSymbol(&stack);

  c = CreateControlSymbol(STYPE0_STATUS, 1, 8, STYPE1_NOP, 0);

  TESTEXPR(s.type, c.type);

  TESTEXPR(s.data, c.data);

  /******************************************************************************/

  TESTEND;

  /******************************************************************************/

  PrintS("----------------------------------------------------------------------");

  PrintS("Step 11:");

  PrintS("Action: Send a packet when an acknowledge has not been received.");

  PrintS("Result: Only idle and status control symbols should be transmitted until ");

  PrintS("        the packet-accepted symbol has been received.");

  PrintS("----------------------------------------------------------------------");

  /******************************************************************************/

  TESTSTART("TG_riostack-TC1-Step11");

  /*****************************************************************************/

  /* Place a packet in the outbound queue. */

  RIOPACKET_setDoorbell(&rioPacket, 2, 0xffff, 1, 0xc0de);

  RIOSTACK_setOutboundPacket(&stack, &rioPacket);

  packetLength = createDoorbell(packet, 1, 2, 0xffff, 1, 0xc0de);

  /* Receive the start of the frame. */

  c = CreateControlSymbol(STYPE0_STATUS, 1, 8, STYPE1_START_OF_PACKET, 0);

  s = RIOSTACK_portGetSymbol(&stack);

  TESTEXPR(s.type, c.type);

  TESTEXPR(s.data, c.data);

  /* Receive the data of the frame. */

  for(i = 0; i < packetLength; i++)

  {

    s = RIOSTACK_portGetSymbol(&stack);

    d.type = RIOSTACK_SYMBOL_TYPE_DATA;

    d.data = packet[i];

    TESTEXPR(s.type, d.type);

    TESTEXPR(s.data, d.data);

  }

  /* Receive the end of the frame. */

  c = CreateControlSymbol(STYPE0_STATUS, 1, 8, STYPE1_END_OF_PACKET, 0);

  s = RIOSTACK_portGetSymbol(&stack);

  TESTSYMBOL(s, c);

  /******************************************************************************/

  TESTEND;

  /******************************************************************************/

  PrintS("----------------------------------------------------------------------");

  PrintS("Step 12:");

  PrintS("Action: Send a packet-accepted symbol.");

  PrintS("Result: Check that the new packet is transmitted.");

  PrintS("----------------------------------------------------------------------");

  /******************************************************************************/

  TESTSTART("TG_riostack-TC1-Step12");

  /*****************************************************************************/

  /* Send acknowledge for the first frame. */

  RIOSTACK_portAddSymbol(&stack, CreateControlSymbol(STYPE0_PACKET_ACCEPTED, 0, 1, STYPE1_NOP, 0));

  /* Check that status-control-symbols are transmitted once every 256 symbol with

     updated ackId. */

  for(i = 0; i < 255; i++)

  {

    s = RIOSTACK_portGetSymbol(&stack);

    TESTEXPR(s.type, RIOSTACK_SYMBOL_TYPE_IDLE);

  }

  s = RIOSTACK_portGetSymbol(&stack);

  c = CreateControlSymbol(STYPE0_STATUS, 1, 8, STYPE1_NOP, 0);

  TESTEXPR(s.type, c.type);

  TESTEXPR(s.data, c.data);

  /******************************************************************************/

  TESTEND;

  /******************************************************************************/

  PrintS("----------------------------------------------------------------------");

  PrintS("Step 13:");

  PrintS("Action: Send a packet-accepted symbol.");

  PrintS("Result: Check that only idle and status-control-symbols are transmitted ");

  PrintS("----------------------------------------------------------------------");

  /******************************************************************************/

  TESTSTART("TG_riostack-TC1-Step13");

  /*****************************************************************************/

  /* Acknowledge the second frame. */

  RIOSTACK_portAddSymbol(&stack, CreateControlSymbol(STYPE0_PACKET_ACCEPTED, 1, 1, STYPE1_NOP, 0));

  /* Check that status-control-symbols are transmitted once every 256 symbol with

     updated ackId. */

  for(i = 0; i < 255; i++)

  {

    s = RIOSTACK_portGetSymbol(&stack);

    TESTEXPR(s.type, RIOSTACK_SYMBOL_TYPE_IDLE);

  }

  s = RIOSTACK_portGetSymbol(&stack);

  c = CreateControlSymbol(STYPE0_STATUS, 1, 8, STYPE1_NOP, 0);

  TESTEXPR(s.type, c.type);

  TESTEXPR(s.data, c.data);

  /******************************************************************************/

  TESTEND;

  /******************************************************************************/

  PrintS("----------------------------------------------------------------------");

  PrintS("TG_riostack-TC2");

  PrintS("Description: Test flow control.");

  PrintS("Requirement: XXXXX");

  PrintS("----------------------------------------------------------------------");

  PrintS("Step 1:");

  PrintS("Action: Send packets to receiver but don't acknowledge them.");

  PrintS("Result: The reception queue of the stack is full.");

  PrintS("----------------------------------------------------------------------");

  /******************************************************************************/

  TESTSTART("TG_riostack-TC2-Step1");

  /******************************************************************************/

  /* Fill input queue in receiver. */

  for(j = 0; j < 8; j++)

  {

    packetLength = createDoorbell(packet, 1+j, 0, 0, 1+j, 0);

    RIOSTACK_portAddSymbol(&stack, CreateControlSymbol(STYPE0_STATUS, 2, 1, STYPE1_START_OF_PACKET, 0));