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 testriopacket test_riopacket.c -fprofile-arcs -ftest-coverage

 * ./testriopacket

 * gcov test_riopacket.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 "riopacket.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 TESTPACKET(got, expected) testSymbol(__LINE__, #got, (got), (expected))

void testPacket(uint32_t line, char *expression, RioPacket_t got, RioPacket_t expected)

{

  int i;

  if ((got).size==(expected).size)

  {

    for(i = 0; i < got.size; i++)

    {

      if(got.payload[i] != expected.payload[i])

      {

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

               line, expression, i, (got).payload[i], (got).payload[i], (expected).payload[i], (expected).payload[i]);

        exit(1);

      }

    }

  }

  else

  {

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

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

    exit(1);

  }

}

void packetClear(RioPacket_t *packet)

{

  uint32_t i;

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

  {

    packet->payload[i] = 0xdeadbeef;

  }

}

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

 * Module test for this file.

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

int32_t main(void)

{

  RioPacket_t packet;

  int i, j, k;

  uint16_t length;

  uint16_t dstidExpected, dstid;

  uint16_t srcidExpected, srcid;

  uint8_t tidExpected, tid;

  uint8_t hopExpected, hop;

  uint8_t mailboxExpected, mailbox;

  uint16_t infoExpected, info;

  uint32_t addressExpected, address;

  uint32_t dataExpected, data;

  uint16_t payloadSizeExpected, payloadSize;

  uint8_t payloadExpected[256], payload[256];

  uint8_t buffer[512];

  uint16_t bufferSize;

  srand(0);

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

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

  PrintS("TG_riopacket-TC1");

  PrintS("Description: Test packet initialization, validation and appending.");

  PrintS("Requirement: XXXXX");

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

  PrintS("Step 1:");

  PrintS("Action: ");

  PrintS("Result: ");

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

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

  TESTSTART("TG_riostack-TC1-Step1");

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

  RIOPACKET_init(&packet);

  TESTEXPR(RIOPACKET_size(&packet), 0);

  TESTCOND(!RIOPACKET_valid(&packet));

  RIOPACKET_append(&packet, 0x001a0001);

  TESTEXPR(RIOPACKET_size(&packet), 1);

  TESTCOND(!RIOPACKET_valid(&packet));

  RIOPACKET_append(&packet, 0xffff0000);

  TESTEXPR(RIOPACKET_size(&packet), 2);

  TESTCOND(!RIOPACKET_valid(&packet));

  RIOPACKET_append(&packet, 0xdeaf9903);

  TESTEXPR(RIOPACKET_size(&packet), 3);

  TESTCOND(RIOPACKET_valid(&packet));

  /* Check that altering the ackid does not affect the validity of the packet. */

  packet.payload[0] |= 0xfc000000;

  TESTCOND(RIOPACKET_valid(&packet));

  /* Access the packet and check its content. */

  TESTEXPR(RIOPACKET_getFtype(&packet), RIOPACKET_FTYPE_DOORBELL);

  TESTEXPR(RIOPACKET_getDestination(&packet), 0x0001);

  TESTEXPR(RIOPACKET_getSource(&packet), 0xffff);

  TESTEXPR(RIOPACKET_getTid(&packet), 0x00);

  RIOPACKET_getDoorbell(&packet, &dstid, &srcid, &tid, &info);

  TESTEXPR(dstid, 0x0001);

  TESTEXPR(srcid, 0xffff);

  TESTEXPR(tid, 0x00);

  TESTEXPR(info, 0xdeaf);

  bufferSize = RIOPACKET_serialize(&packet, sizeof(buffer), buffer);

  TESTEXPR(bufferSize, 13);

  TESTEXPR(buffer[0], 0x03);

  TESTEXPR(buffer[1], 0xfc);

  TESTEXPR(buffer[2], 0x1a);

  TESTEXPR(buffer[3], 0x00);

  TESTEXPR(buffer[4], 0x01);

  TESTEXPR(buffer[5], 0xff);

  TESTEXPR(buffer[6], 0xff);

  TESTEXPR(buffer[7], 0x00);

  TESTEXPR(buffer[8], 0x00);

  TESTEXPR(buffer[9], 0xde);

  TESTEXPR(buffer[10], 0xaf);

  TESTEXPR(buffer[11], 0x99);

  TESTEXPR(buffer[12], 0x03);

  RIOPACKET_init(&packet);

  RIOPACKET_deserialize(&packet, bufferSize, buffer);

  TESTCOND(RIOPACKET_valid(&packet));

  TESTEXPR(RIOPACKET_getFtype(&packet), RIOPACKET_FTYPE_DOORBELL);

  TESTEXPR(RIOPACKET_getDestination(&packet), 0x0001);

  TESTEXPR(RIOPACKET_getSource(&packet), 0xffff);

  TESTEXPR(RIOPACKET_getTid(&packet), 0x00);

  RIOPACKET_getDoorbell(&packet, &dstid, &srcid, &tid, &info);

  TESTEXPR(dstid, 0x0001);

  TESTEXPR(srcid, 0xffff);

  TESTEXPR(tid, 0x00);

  TESTEXPR(info, 0xdeaf);

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

  TESTEND;

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

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

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

  PrintS("TG_riopacket-TC2");

  PrintS("Description: Test maintenance packets.");

  PrintS("Requirement: XXXXX");

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

  PrintS("Step 1:");

  PrintS("Action: ");

  PrintS("Result: ");

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

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

  TESTSTART("TG_riostack-TC2-Step1");

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

  RIOPACKET_init(&packet);

  RIOPACKET_setMaintReadRequest(&packet, 0xc0de, 0xbabe, 0x13, 0x41, 0xffffffff);

  RIOPACKET_getMaintReadRequest(&packet, &dstid, &srcid, &hop, &tid, &address);

  TESTCOND(RIOPACKET_valid(&packet));

  TESTEXPR(dstid, 0xc0de);

  TESTEXPR(srcid, 0xbabe);

  TESTEXPR(hop, 0x13);

  TESTEXPR(tid, 0x41);

  TESTEXPR(address, 0x00fffffc);

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

  TESTEND;

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

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

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

  PrintS("TG_riopacket-TC3");

  PrintS("Description: Test input/output packets.");

  PrintS("Requirement: XXXXX");

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

  PrintS("Step 1:");

  PrintS("Action: ");

  PrintS("Result: ");

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

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

  TESTSTART("TG_riostack-TC3-Step1");

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

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

  TESTEND;

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

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

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

  PrintS("TG_riopacket-TC4");

  PrintS("Description: Test message passing packets.");

  PrintS("Requirement: XXXXX");

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

  PrintS("Step 1:");

  PrintS("Action: Send a message with invalid payload length.");

  PrintS("Result: No packet should be generated.");

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

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

  TESTSTART("TG_riostack-TC4-Step1");

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

  RIOPACKET_setMessage(&packet, 0xdead, 0xbeef, 0xc0, 0, &payloadExpected[0]);

  TESTEXPR(packet.size, 0);

  TESTCOND(!RIOPACKET_valid(&packet));

  RIOPACKET_setMessage(&packet, 0xdead, 0xbeef, 0xc0, 257, &payloadExpected[0]);

  TESTEXPR(packet.size, 0);

  TESTCOND(!RIOPACKET_valid(&packet));

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

  TESTEND;

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

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

  PrintS("Step 2:");

  PrintS("Action: Test sending all possible payload sizes on random deviceIds ");

  PrintS("        and mailboxes.");

  PrintS("Result: The content of the packet should be equal to what was entered.");

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

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

  TESTSTART("TG_riostack-TC4-Step2");

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

  for(i = 1; i <= 256; i++)

  {

    dstidExpected = rand();

    srcidExpected = rand();

    mailboxExpected = rand();

    if((i%8) == 0)

    {

      payloadSizeExpected = 8*(i/8);

    }

    else

    {

      payloadSizeExpected = 8*(i/8+1);

    }

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

    {

      payloadExpected[j] = rand();

    }

    RIOPACKET_setMessage(&packet, dstidExpected, srcidExpected, mailboxExpected,

                         i, &payloadExpected[0]);

    TESTCOND(RIOPACKET_valid(&packet));

    RIOPACKET_getMessage(&packet, &dstid, &srcid, &mailbox, &payloadSize, &(payload[0]));

    TESTEXPR(dstid, dstidExpected);

    TESTEXPR(srcid, srcidExpected);

    TESTEXPR(mailbox, mailboxExpected);

    TESTEXPR(payloadSize, payloadSizeExpected);

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

    {

      TESTEXPR(payload[j], payloadExpected[j]);

    }

  }

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

  TESTEND;

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

  return 0;

}

/*************************** end of file **************************************/