Init of dlt daemon

1 files changed, 2004 insertions, 0 deletions

diff --git a/src/tests/dlt-test-client.c b/src/tests/dlt-test-client.c
new file mode 100755
index 0000000..180badf
--- /dev/null
+++ b/src/tests/dlt-test-client.c
@@ -0,0 +1,2004 @@
+/*
+ * Dlt Test Client - Diagnostic Log and Trace
+ * @licence app begin@
+ *
+ * Copyright (C) 2011, BMW AG - Alexander Wenzel <alexander.wenzel@bmw.de>
+ * 
+ * This program is free software; you can redistribute it and/or modify it under the terms of the 
+ * GNU Lesser General Public License, version 2.1, as published by the Free Software Foundation.
+ * This program 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, version 2.1, for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License, version 2.1, along 
+ * with this program; if not, see <http://www.gnu.org/licenses/lgpl-2.1.html>.
+ * 
+ * Note that the copyright holders assume that the GNU Lesser General Public License, version 2.1, may 
+ * also be applicable to programs even in cases in which the program is not a library in the technical sense.
+ * 
+ * Linking DLT statically or dynamically with other modules is making a combined work based on DLT. You may 
+ * license such other modules under the GNU Lesser General Public License, version 2.1. If you do not want to 
+ * license your linked modules under the GNU Lesser General Public License, version 2.1, you 
+ * may use the program under the following exception.
+ * 
+ * As a special exception, the copyright holders of DLT give you permission to combine DLT 
+ * with software programs or libraries that are released under any license unless such a combination is not
+ * permitted by the license of such a software program or library. You may copy and distribute such a 
+ * system following the terms of the GNU Lesser General Public License, version 2.1, including this
+ * special exception, for DLT and the licenses of the other code concerned.
+ * 
+ * Note that people who make modified versions of DLT are not obligated to grant this special exception 
+ * for their modified versions; it is their choice whether to do so. The GNU Lesser General Public License, 
+ * version 2.1, gives permission to release a modified version without this exception; this exception 
+ * also makes it possible to release a modified version which carries forward this exception.
+ *
+ * @licence end@
+ */
+
+
+/*******************************************************************************
+**                                                                            **
+**  SRC-MODULE: dlt-test-client.c                                             **
+**                                                                            **
+**  TARGET    : linux                                                         **
+**                                                                            **
+**  PROJECT   : DLT                                                           **
+**                                                                            **
+**  AUTHOR    : Alexander Wenzel Alexander.AW.Wenzel@bmw.de                   **
+**              Markus Klein                                                  **
+**                                                                            **
+**  PURPOSE   :                                                               **
+**                                                                            **
+**  REMARKS   :                                                               **
+**                                                                            **
+**  PLATFORM DEPENDANT [yes/no]: yes                                          **
+**                                                                            **
+**  TO BE CHANGED BY USER [yes/no]: no                                        **
+**                                                                            **
+*******************************************************************************/
+
+/*******************************************************************************
+**                      Author Identity                                       **
+********************************************************************************
+**                                                                            **
+** Initials     Name                       Company                            **
+** --------     -------------------------  ---------------------------------- **
+**  aw          Alexander Wenzel           BMW                                **
+**  mk          Markus Klein               Fraunhofer ESK                     **
+*******************************************************************************/
+
+/*******************************************************************************
+**                      Revision Control History                              **
+*******************************************************************************/
+
+/*
+ * $LastChangedRevision: 1670 $
+ * $LastChangedDate: 2011-04-08 15:12:06 +0200 (Fr, 08. Apr 2011) $
+ * $LastChangedBy$
+ Initials    Date         Comment
+ aw          13.01.2010   initial
+ */
+
+#include <ctype.h>      /* for isprint() */
+#include <stdlib.h>     /* for atoi() */
+#include <sys/stat.h>   /* for S_IRUSR, S_IWUSR, S_IRGRP, S_IROTH */
+#include <fcntl.h>      /* for open() */
+#include <string.h>     /* for strcmp() */
+#include <sys/uio.h>    /* for writev() */
+
+#include "dlt_client.h"
+#include "dlt_protocol.h"
+#include "dlt_user.h"
+
+#define DLT_TESTCLIENT_TEXTBUFSIZE 10024  /* Size of buffer for text output */
+#define DLT_TESTCLIENT_ECU_ID     "ECU1"
+
+#define DLT_TESTCLIENT_NUM_TESTS 	  7
+
+/* Function prototypes */
+int dlt_testclient_message_callback(DltMessage *message, void *data);
+
+typedef struct
+{
+    int aflag;
+    int sflag;
+    int xflag;
+    int mflag;
+    int vflag;
+    int yflag;
+    char *ovalue;
+    char *fvalue;
+    char *tvalue;
+    char *evalue;
+    int bvalue;
+
+    char ecuid[4];
+    int ohandle;
+
+    DltFile file;
+    DltFilter filter;
+
+    int running_test;
+
+    int test_counter_macro[DLT_TESTCLIENT_NUM_TESTS];
+    int test_counter_function[DLT_TESTCLIENT_NUM_TESTS];
+
+    int tests_passed;
+    int tests_failed;
+
+    int sock;
+} DltTestclientData;
+
+/**
+ * Print usage information of tool.
+ */
+void usage()
+{
+    char version[255];
+
+    dlt_get_version(version);
+
+    printf("Usage: dlt-test-client [options] hostname/serial_device_name\n");
+    printf("Test against received data from dlt-test-user.\n");
+    printf("%s \n", version);
+    printf("Options:\n");
+    printf("  -a            Print DLT messages; payload as ASCII\n");
+    printf("  -x            Print DLT messages; payload as hex\n");
+    printf("  -m            Print DLT messages; payload as hex and ASCII\n");
+    printf("  -s            Print DLT messages; only headers\n");
+    printf("  -v            Verbose mode\n");
+    printf("  -h            Usage\n");
+    printf("  -y            Serial device mode\n");
+    printf("  -b baudrate   Serial device baudrate (Default: 115200)\n");
+    printf("  -e ecuid      Set ECU ID (Default: ECU1)\n");
+    printf("  -o filename   Output messages in new DLT file\n");
+    printf("  -f filename   Enable filtering of messages\n");
+}
+
+/**
+ * Main function of tool.
+ */
+int main(int argc, char* argv[])
+{
+    DltClient       dltclient;
+    DltTestclientData dltdata;
+    int c,i;
+    int index;
+
+    /* Initialize dltdata */
+    dltdata.aflag = 0;
+    dltdata.sflag = 0;
+    dltdata.xflag = 0;
+    dltdata.mflag = 0;
+    dltdata.vflag = 0;
+    dltdata.yflag = 0;
+    dltdata.ovalue = 0;
+    dltdata.fvalue = 0;
+    dltdata.evalue = 0;
+    dltdata.bvalue = 0;
+    dltdata.ohandle=-1;
+
+    dltdata.running_test = 0;
+
+    for (i=0;i<DLT_TESTCLIENT_NUM_TESTS;i++)
+    {
+        dltdata.test_counter_macro[i]=0;
+        dltdata.test_counter_function[i]=0;
+    }
+
+    dltdata.tests_passed = 0;
+    dltdata.tests_failed = 0;
+
+    dltdata.sock = -1;
+
+    /* Fetch command line arguments */
+    opterr = 0;
+
+    while ((c = getopt (argc, argv, "vashyxmf:o:e:b:")) != -1)
+    {
+        switch (c)
+        {
+        case 'v':
+        {
+            dltdata.vflag = 1;
+            break;
+        }
+        case 'a':
+        {
+            dltdata.aflag = 1;
+            break;
+        }
+        case 's':
+        {
+            dltdata.sflag = 1;
+            break;
+        }
+        case 'x':
+        {
+            dltdata.xflag = 1;
+            break;
+        }
+        case 'm':
+        {
+            dltdata.mflag = 1;
+            break;
+        }
+        case 'h':
+        {
+            usage();
+            return -1;
+        }
+        case 'y':
+        {
+            dltdata.yflag = 1;
+            break;
+        }
+        case 'f':
+        {
+            dltdata.fvalue = optarg;
+            break;
+        }
+        case 'o':
+        {
+            dltdata.ovalue = optarg;
+            break;
+        }
+        case 'e':
+        {
+            dltdata.evalue = optarg;
+            break;
+        }
+        case 'b':
+        {
+            dltdata.bvalue = atoi(optarg);
+            break;
+        }
+        case '?':
+        {
+            if (optopt == 'o' || optopt == 'f' || optopt == 't')
+            {
+                fprintf (stderr, "Option -%c requires an argument.\n", optopt);
+            }
+            else if (isprint (optopt))
+            {
+                fprintf (stderr, "Unknown option `-%c'.\n", optopt);
+            }
+            else
+            {
+                fprintf (stderr, "Unknown option character `\\x%x'.\n",optopt);
+            }
+            /* unknown or wrong option used, show usage information and terminate */
+            usage();
+            return -1;
+        }
+        default:
+        {
+            abort ();
+        }
+        }
+    }
+
+    /* Initialize DLT Client */
+    dlt_client_init(&dltclient, dltdata.vflag);
+
+    /* Register callback to be called when message was received */
+    dlt_client_register_message_callback(dlt_testclient_message_callback);
+
+    /* Setup DLT Client structure */
+    dltclient.serial_mode = dltdata.yflag;
+
+    if (dltclient.serial_mode==0)
+    {
+        for (index = optind; index < argc; index++)
+        {
+            dltclient.servIP = argv[index];
+        }
+
+        if (dltclient.servIP == 0)
+        {
+            /* no hostname selected, show usage and terminate */
+            fprintf(stderr,"ERROR: No hostname selected\n");
+            usage();
+            dlt_client_cleanup(&dltclient,dltdata.vflag);
+            return -1;
+        }
+    }
+    else
+    {
+        for (index = optind; index < argc; index++)
+        {
+            dltclient.serialDevice = argv[index];
+        }
+
+        if (dltclient.serialDevice == 0)
+        {
+            /* no serial device name selected, show usage and terminate */
+            fprintf(stderr,"ERROR: No serial device name specified\n");
+            usage();
+            return -1;
+        }
+
+		dlt_client_setbaudrate(&dltclient,dltdata.bvalue);
+    }
+
+    /* initialise structure to use DLT file */
+    dlt_file_init(&(dltdata.file),dltdata.vflag);
+
+    /* first parse filter file if filter parameter is used */
+    dlt_filter_init(&(dltdata.filter),dltdata.vflag);
+
+    if (dltdata.fvalue)
+    {
+        if (dlt_filter_load(&(dltdata.filter),dltdata.fvalue,dltdata.vflag)<0)
+        {
+            dlt_file_free(&(dltdata.file),dltdata.vflag);
+            return -1;
+        }
+
+        dlt_file_set_filter(&(dltdata.file),&(dltdata.filter),dltdata.vflag);
+    }
+
+    /* open DLT output file */
+    if (dltdata.ovalue)
+    {
+        dltdata.ohandle = open(dltdata.ovalue,O_WRONLY|O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH); /* mode: wb */
+
+        if (dltdata.ohandle == -1)
+        {
+            dlt_file_free(&(dltdata.file),dltdata.vflag);
+            fprintf(stderr,"ERROR: Output file %s cannot be opened!\n",dltdata.ovalue);
+            return -1;
+        }
+    }
+
+    if (dltdata.evalue)
+    {
+        dlt_set_id(dltdata.ecuid,dltdata.evalue);
+    }
+    else
+    {
+        dlt_set_id(dltdata.ecuid,DLT_TESTCLIENT_ECU_ID);
+    }
+
+    /* Connect to TCP socket or open serial device */
+    if (dlt_client_connect(&dltclient, dltdata.vflag)!=-1)
+    {
+        dltdata.sock = dltclient.sock;
+
+        /* Dlt Client Main Loop */
+        dlt_client_main_loop(&dltclient, &dltdata, dltdata.vflag);
+
+        /* Dlt Client Cleanup */
+        dlt_client_cleanup(&dltclient,dltdata.vflag);
+    }
+
+    /* dlt-receive cleanup */
+    if (dltdata.ovalue)
+    {
+        close(dltdata.ohandle);
+    }
+
+    dlt_file_free(&(dltdata.file),dltdata.vflag);
+
+    dlt_filter_free(&(dltdata.filter),dltdata.vflag);
+
+    return 0;
+}
+
+int dlt_testclient_message_callback(DltMessage *message, void *data)
+{
+    static char text[DLT_TESTCLIENT_TEXTBUFSIZE];
+    int mtin;
+    DltTestclientData *dltdata;
+
+	uint32_t type_info, type_info_tmp;
+	int16_t length,length_tmp; /* the macro can set this variable to -1 */
+	uint8_t *ptr;
+	int32_t datalength;
+
+	uint32_t id,id_tmp;
+	int slen;
+	int tc_old;
+
+	struct iovec iov[2];
+	int bytes_written;
+
+    if ((message==0) || (data==0))
+    {
+        return -1;
+    }
+
+    dltdata = (DltTestclientData*)data;
+
+    /* prepare storage header */
+    if (DLT_IS_HTYP_WEID(message->standardheader->htyp))
+    {
+        dlt_set_storageheader(message->storageheader,message->headerextra.ecu);
+    }
+    else
+    {
+        dlt_set_storageheader(message->storageheader,dltdata->ecuid);
+    }
+
+    if ((dltdata->fvalue==0) || (dltdata->fvalue && dlt_message_filter_check(message,&(dltdata->filter),dltdata->vflag)==1))
+    {
+
+        dlt_message_header(message,text,sizeof(text),dltdata->vflag);
+        if (dltdata->aflag)
+        {
+            printf("%s ",text);
+        }
+        dlt_message_payload(message,text,sizeof(text),DLT_OUTPUT_ASCII,dltdata->vflag);
+        if (dltdata->aflag)
+        {
+            printf("[%s]\n",text);
+        }
+
+        if (strcmp(text,"Tests starting")==0)
+        {
+            printf("Tests starting\n");
+        }
+
+        /* check test 1m */
+        if (strcmp(text,"Test1: (Macro IF) Test all log levels")==0)
+        {
+            printf("Test1m: (Macro IF) Test all log levels\n");
+            dltdata->running_test = 1;
+            dltdata->test_counter_macro[0] = 0;
+        }
+        else if (strcmp(text,"Test1: (Macro IF) finished")==0)
+        {
+            /* >=4, as "info" is default log level */
+            if (dltdata->test_counter_macro[0]>=4)
+            {
+                printf("Test1m PASSED\n");
+                dltdata->tests_passed++;
+            }
+            else
+            {
+                printf("Test1m FAILED\n");
+                dltdata->tests_failed++;
+            }
+            dltdata->running_test = 0;
+        }
+        else if (dltdata->running_test==1)
+        {
+            if (DLT_IS_HTYP_UEH(message->standardheader->htyp))
+            {
+                if ((DLT_GET_MSIN_MSTP(message->extendedheader->msin))==DLT_TYPE_LOG)
+                {
+                    mtin=DLT_GET_MSIN_MTIN(message->extendedheader->msin);
+
+                    if (mtin==DLT_LOG_FATAL)
+                    {
+                        dltdata->test_counter_macro[0]++;
+                    }
+                    if (mtin==DLT_LOG_ERROR)
+                    {
+                        dltdata->test_counter_macro[0]++;
+                    }
+                    if (mtin==DLT_LOG_WARN)
+                    {
+                        dltdata->test_counter_macro[0]++;
+                    }
+                    if (mtin==DLT_LOG_INFO)
+                    {
+                        dltdata->test_counter_macro[0]++;
+                    }
+                    if (mtin==DLT_LOG_DEBUG)
+                    {
+                        dltdata->test_counter_macro[0]++;
+                    }
+                    if (mtin==DLT_LOG_VERBOSE)
+                    {
+                        dltdata->test_counter_macro[0]++;
+                    }
+                }
+            }
+        }
+
+        /* check test 2m */
+        if (strcmp(text,"Test2: (Macro IF) Test all variable types (verbose)")==0)
+        {
+            printf("Test2m: (Macro IF) Test all variable types (verbose)\n");
+            dltdata->running_test = 2;
+            dltdata->test_counter_macro[1] = 0;
+        }
+        else if (strcmp(text,"Test2: (Macro IF) finished")==0)
+        {
+            if (dltdata->test_counter_macro[1]==14)
+            {
+                printf("Test2m PASSED\n");
+                dltdata->tests_passed++;
+            }
+            else
+            {
+                printf("Test2m FAILED\n");
+                dltdata->tests_failed++;
+            }
+            dltdata->running_test = 0;
+        }
+        else if (dltdata->running_test==2)
+        {
+            /* Verbose */
+            if (!(DLT_MSG_IS_NONVERBOSE(message)))
+            {
+                type_info=0;
+                type_info_tmp=0;
+                length=0;  /* the macro can set this variable to -1 */
+                length_tmp=0;
+                ptr = message->databuffer;
+                datalength = message->datasize;
+
+                /* Log message */
+                if ((DLT_GET_MSIN_MSTP(message->extendedheader->msin))==DLT_TYPE_LOG)
+                {
+                    if (message->extendedheader->noar>=2)
+                    {
+                        /* get type of first argument: must be string */
+                        DLT_MSG_READ_VALUE(type_info_tmp,ptr,datalength,uint32_t);
+                        type_info=DLT_ENDIAN_GET_32(message->standardheader->htyp, type_info_tmp);
+
+                        if (type_info & DLT_TYPE_INFO_STRG)
+                        {
+                            /* skip string */
+                            DLT_MSG_READ_VALUE(length_tmp,ptr,datalength,uint16_t);
+                            length=DLT_ENDIAN_GET_16(message->standardheader->htyp, length_tmp);
+
+                            if (length>=0)
+                            {
+                                ptr+=length;
+                                datalength-=length;
+
+                                /* read type of second argument: must be raw */
+                                DLT_MSG_READ_VALUE(type_info_tmp,ptr,datalength,uint32_t);
+                                type_info=DLT_ENDIAN_GET_32(message->standardheader->htyp, type_info_tmp);
+
+                                if (type_info & DLT_TYPE_INFO_BOOL)
+                                {
+                                    if (datalength==sizeof(uint8_t))
+                                    {
+                                        dltdata->test_counter_macro[1]++;
+                                    }
+                                }
+                                else if (type_info & DLT_TYPE_INFO_SINT)
+                                {
+                                    switch (type_info & DLT_TYPE_INFO_TYLE)
+                                    {
+                                    case DLT_TYLE_8BIT:
+                                    {
+                                        if (datalength==sizeof(int8_t))
+                                        {
+                                            dltdata->test_counter_macro[1]++;
+                                        }
+                                        break;
+                                    }
+                                    case DLT_TYLE_16BIT:
+                                    {
+                                        if (datalength==sizeof(int16_t))
+                                        {
+                                            dltdata->test_counter_macro[1]++;
+                                        }
+                                        break;
+                                    }
+                                    case DLT_TYLE_32BIT:
+                                    {
+                                        if (datalength==sizeof(int32_t))
+                                        {
+                                            dltdata->test_counter_macro[1]++;
+                                        }
+                                        break;
+                                    }
+                                    case DLT_TYLE_64BIT:
+                                    {
+                                        if (datalength==sizeof(int64_t))
+                                        {
+                                            dltdata->test_counter_macro[1]++;
+                                        }
+                                        break;
+                                    }
+                                    case DLT_TYLE_128BIT:
+                                    {
+                                        /* Not tested here */
+                                        break;
+                                    }
+                                    }
+                                }
+                                else if (type_info & DLT_TYPE_INFO_UINT)
+                                {
+                                    switch (type_info & DLT_TYPE_INFO_TYLE)
+                                    {
+                                    case DLT_TYLE_8BIT:
+                                    {
+                                        if (datalength==sizeof(uint8_t))
+                                        {
+                                            dltdata->test_counter_macro[1]++;
+                                        }
+                                        break;
+                                    }
+                                    case DLT_TYLE_16BIT:
+                                    {
+                                        if (datalength==sizeof(uint16_t))
+                                        {
+                                            dltdata->test_counter_macro[1]++;
+                                        }
+                                        break;
+                                    }
+                                    case DLT_TYLE_32BIT:
+                                    {
+                                        if (datalength==sizeof(uint32_t))
+                                        {
+                                            dltdata->test_counter_macro[1]++;
+                                        }
+                                        break;
+                                    }
+                                    case DLT_TYLE_64BIT:
+                                    {
+                                        if (datalength==sizeof(uint64_t))
+                                        {
+                                            dltdata->test_counter_macro[1]++;
+                                        }
+                                        break;
+                                    }
+                                    case DLT_TYLE_128BIT:
+                                    {
+                                        /* Not tested here */
+                                        break;
+                                    }
+                                    }
+                                }
+                                else if (type_info & DLT_TYPE_INFO_FLOA)
+                                {
+                                    switch (type_info & DLT_TYPE_INFO_TYLE)
+                                    {
+                                    case DLT_TYLE_8BIT:
+                                    {
+                                        /* Not tested here */
+                                        break;
+                                    }
+                                    case DLT_TYLE_16BIT:
+                                    {
+                                        /* Not tested here */
+                                        break;
+                                    }
+                                    case DLT_TYLE_32BIT:
+                                    {
+                                        if (datalength==(2*sizeof(float)+sizeof(uint32_t)))
+                                        {
+                                            dltdata->test_counter_macro[1]++;
+                                        }
+                                        break;
+                                    }
+                                    case DLT_TYLE_64BIT:
+                                    {
+                                        if (datalength==(2*sizeof(double)+sizeof(uint32_t)))
+                                        {
+                                            dltdata->test_counter_macro[1]++;
+                                        }
+                                        break;
+                                    }
+                                    case DLT_TYLE_128BIT:
+                                        /* Not tested here */
+                                        break;
+                                    }
+                                }
+                                else if (type_info & DLT_TYPE_INFO_RAWD)
+                                {
+                                    /* Get length */
+                                    DLT_MSG_READ_VALUE(length_tmp,ptr,datalength,uint16_t);
+                                    length=DLT_ENDIAN_GET_16(message->standardheader->htyp, length_tmp);
+                                    if ((length==datalength) && (length=10))
+                                    {
+                                        dltdata->test_counter_macro[1]++;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        /* check test 3m */
+        if (strcmp(text,"Test3: (Macro IF) Test all variable types (non-verbose)")==0)
+        {
+            printf("Test3m: (Macro IF) Test all variable types (non-verbose)\n");
+            dltdata->running_test = 3;
+            dltdata->test_counter_macro[2]=0;
+        }
+        else if (strcmp(text,"Test3: (Macro IF) finished")==0)
+        {
+            if (dltdata->test_counter_macro[2]==14)
+            {
+                printf("Test3m PASSED\n");
+                dltdata->tests_passed++;
+            }
+            else
+            {
+                printf("Test3m FAILED\n");
+                dltdata->tests_failed++;
+            }
+            dltdata->running_test = 0;
+        }
+        else if (dltdata->running_test==3)
+        {
+            /* Nonverbose */
+            if (DLT_MSG_IS_NONVERBOSE(message))
+            {
+                id=0;
+                id_tmp=0;
+                ptr = message->databuffer;
+                datalength = message->datasize;
+                slen=-1;
+
+                tc_old=dltdata->test_counter_macro[2];
+
+                /* Get message id */
+                DLT_MSG_READ_VALUE(id_tmp,ptr,datalength,uint32_t);
+                id=DLT_ENDIAN_GET_32(message->standardheader->htyp, id_tmp);
+
+                /* Length of string */
+                datalength-=sizeof(uint16_t);
+                ptr+=sizeof(uint16_t);
+
+                switch (id)
+                {
+                case  1:
+                {
+                    slen=strlen("bool")+1;
+                    datalength-=slen;
+                    ptr+=slen;
+                    if (datalength==sizeof(uint8_t))
+                    {
+                        dltdata->test_counter_macro[2]++;
+                    }
+                    break;
+                }
+                case  2:
+                {
+                    slen=strlen("int")+1;
+                    datalength-=slen;
+                    ptr+=slen;
+                    if (datalength==sizeof(int))
+                    {
+                        dltdata->test_counter_macro[2]++;
+                    }
+                    break;
+                }
+                case  3:
+                {
+                    slen=strlen("int8")+1;
+                    datalength-=slen;
+                    ptr+=slen;
+                    if (datalength==sizeof(int8_t))
+                    {
+                        dltdata->test_counter_macro[2]++;
+                    }
+                    break;
+                }
+                case  4:
+                {
+                    slen=strlen("int16")+1;
+                    datalength-=slen;
+                    ptr+=slen;
+                    if (datalength==sizeof(int16_t))
+                    {
+                        dltdata->test_counter_macro[2]++;
+                    }
+                    break;
+                }
+                case  5:
+                {
+                    slen=strlen("int32")+1;
+                    datalength-=slen;
+                    ptr+=slen;
+                    if (datalength==sizeof(int32_t))
+                    {
+                        dltdata->test_counter_macro[2]++;
+                    }
+                    break;
+                }
+                case  6:
+                {
+                    slen=strlen("int64")+1;
+                    datalength-=slen;
+                    ptr+=slen;
+                    if (datalength==sizeof(int64_t))
+                    {
+                        dltdata->test_counter_macro[2]++;
+                    }
+                    break;
+                }
+                case  7:
+                {
+                    slen=strlen("uint")+1;
+                    datalength-=slen;
+                    ptr+=slen;
+                    if (datalength==sizeof(unsigned int))
+                    {
+                        dltdata->test_counter_macro[2]++;
+                    }
+                    break;
+                }
+                case  8:
+                {
+                    slen=strlen("uint8")+1;
+                    datalength-=slen;
+                    ptr+=slen;
+                    if (datalength==sizeof(uint8_t))
+                    {
+                        dltdata->test_counter_macro[2]++;
+                    }
+                    break;
+                }
+                case  9:
+                {
+                    slen=strlen("uint16")+1;
+                    datalength-=slen;
+                    ptr+=slen;
+                    if (datalength==sizeof(uint16_t))
+                    {
+                    	dltdata->test_counter_macro[2]++;
+                    }
+                    break;
+                }
+                case 10:
+                {
+                    slen=strlen("uint32")+1;
+                    datalength-=slen;
+                    ptr+=slen;
+                    if (datalength==sizeof(uint32_t))
+                    {
+                        dltdata->test_counter_macro[2]++;
+                    }
+                    break;
+                }
+                case 11:
+                {
+                    slen=strlen("uint64")+1;
+                    datalength-=slen;
+                    ptr+=slen;
+                    if (datalength==sizeof(uint64_t))
+                    {
+                        dltdata->test_counter_macro[2]++;
+                    }
+                    break;
+                }
+                case 12:
+                {
+                    slen=strlen("float32")+1;
+                    datalength-=slen;
+                    ptr+=slen;
+                    /* 2*, as the min and the max is transfered */
+                    if (datalength==2*sizeof(float))
+                    {
+                        dltdata->test_counter_macro[2]++;
+                    }
+                    break;
+                }
+                case 13:
+                {
+                    slen=strlen("float64")+1;
+                    datalength-=slen;
+                    ptr+=slen;
+                    /* 2*, as the min and the max is transfered */
+                    if (datalength==2*sizeof(double))
+                    {
+                        dltdata->test_counter_macro[2]++;
+                    }
+                    break;
+                }
+                case 14:
+                {
+                    slen=strlen("raw")+1;
+                    datalength-=slen;
+                    ptr+=slen;
+                    datalength-=sizeof(uint16_t);
+                    ptr+=sizeof(uint16_t);
+                    if (datalength==10)
+                    {
+                        dltdata->test_counter_macro[2]++;
+                    }
+                    break;
+                }
+                }
+
+                if ((slen>=0) && (tc_old==dltdata->test_counter_macro[2]))
+                {
+                    printf("ID=%d, Datalength=%d => Failed!",id,datalength);
+                }
+            }
+        }
+
+        /* check test 4m */
+        if (strcmp(text,"Test4: (Macro IF) Test different message sizes")==0)
+        {
+            printf("Test4m: (Macro IF) Test different message sizes\n");
+            dltdata->running_test = 4;
+            dltdata->test_counter_macro[3]=0;
+        }
+        else if (strcmp(text,"Test4: (Macro IF) finished")==0)
+        {
+            if (dltdata->test_counter_macro[3]==4)
+            {
+                printf("Test4m PASSED\n");
+                dltdata->tests_passed++;
+            }
+            else
+            {
+                printf("Test4m FAILED\n");
+                dltdata->tests_failed++;
+            }
+            dltdata->running_test = 0;
+        }
+        else if (dltdata->running_test==4)
+        {
+            /* Extended header */
+            if (DLT_IS_HTYP_UEH(message->standardheader->htyp))
+            {
+                /* Log message */
+                if ((DLT_GET_MSIN_MSTP(message->extendedheader->msin))==DLT_TYPE_LOG)
+                {
+                    /* Verbose */
+                    if (DLT_IS_MSIN_VERB(message->extendedheader->msin))
+                    {
+                        /* 2 arguments */
+                        if (message->extendedheader->noar==2)
+                        {
+                            /* verbose mode */
+                            type_info=0;
+                            type_info_tmp=0;
+                            length=0;
+                            length_tmp=0; /* the macro can set this variable to -1 */
+
+                            ptr = message->databuffer;
+                            datalength = message->datasize;
+
+                            /* first read the type info of the first argument: must be string */
+                            DLT_MSG_READ_VALUE(type_info_tmp,ptr,datalength,uint32_t);
+                            type_info=DLT_ENDIAN_GET_32(message->standardheader->htyp, type_info_tmp);
+
+                            if (type_info & DLT_TYPE_INFO_STRG)
+                            {
+                                /* skip string */
+                                DLT_MSG_READ_VALUE(length_tmp,ptr,datalength,uint16_t);
+                                length=DLT_ENDIAN_GET_16(message->standardheader->htyp, length_tmp);
+
+                                if (length>=0)
+                                {
+                                    ptr+=length;
+                                    datalength-=length;
+
+                                    /* read type of second argument: must be raw */
+                                    DLT_MSG_READ_VALUE(type_info_tmp,ptr,datalength,uint32_t);
+                                    type_info=DLT_ENDIAN_GET_32(message->standardheader->htyp, type_info_tmp);
+
+                                    if (type_info & DLT_TYPE_INFO_RAWD)
+                                    {
+                                        /* get length of raw data block */
+                                        DLT_MSG_READ_VALUE(length_tmp,ptr,datalength,uint16_t);
+                                        length=DLT_ENDIAN_GET_16(message->standardheader->htyp, length_tmp);
+
+                                        if ((length>=0) && (length==datalength))
+                                        {
+                                            //printf("Raw data found in payload, length=");
+                                            //printf("%d, datalength=%d \n", length, datalength);
+                                            dltdata->test_counter_macro[3]++;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        /* check test 5m */
+        if (strcmp(text,"Test5: (Macro IF) Test high-level API")==0)
+        {
+            printf("Test5m: (Macro IF) Test high-level API\n");
+            dltdata->running_test = 5;
+            dltdata->test_counter_macro[4]=0;
+        }
+        else if (strcmp(text,"Test5: (Macro IF) finished")==0)
+        {
+            if (dltdata->test_counter_macro[4]==12)
+            {
+                printf("Test5m PASSED\n");
+                dltdata->tests_passed++;
+            }
+            else
+            {
+                printf("Test5m FAILED\n");
+                dltdata->tests_failed++;
+            }
+            dltdata->running_test = 0;
+        }
+        else if (dltdata->running_test==5)
+        {
+            if (strcmp(text,"Next line: DLT_LOG_INT")==0)
+            {
+                dltdata->test_counter_macro[4]++;
+            }
+            if (strcmp(text,"-42")==0)
+            {
+                dltdata->test_counter_macro[4]++;
+            }
+
+            if (strcmp(text,"Next line: DLT_LOG_UINT")==0)
+            {
+                dltdata->test_counter_macro[4]++;
+            }
+            if (strcmp(text,"42")==0)
+            {
+                dltdata->test_counter_macro[4]++;
+            }
+
+            if (strcmp(text,"Next line: DLT_LOG_STRING")==0)
+            {
+                dltdata->test_counter_macro[4]++;
+            }
+            if (strcmp(text,"String output")==0)
+            {
+                dltdata->test_counter_macro[4]++;
+            }
+
+            if (strcmp(text,"Next line: DLT_LOG_RAW")==0)
+            {
+                dltdata->test_counter_macro[4]++;
+            }
+            if (strcmp(text,"00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f")==0)
+            {
+                dltdata->test_counter_macro[4]++;
+            }
+
+            if (strcmp(text,"Next line: DLT_LOG_STRING_INT")==0)
+            {
+                dltdata->test_counter_macro[4]++;
+            }
+            if (strcmp(text,"String output:  -42")==0)
+            {
+                dltdata->test_counter_macro[4]++;
+            }
+
+            if (strcmp(text,"Next line: DLT_LOG_STRING_UINT")==0)
+            {
+                dltdata->test_counter_macro[4]++;
+            }
+            if (strcmp(text,"String output:  42")==0)
+            {
+                dltdata->test_counter_macro[4]++;
+            }
+        }
+
+        /* check test 6m */
+        if (strcmp(text,"Test 6: (Macro IF) Test local printing")==0)
+        {
+            printf("Test6m: (Macro IF) Test local printing\n");
+            dltdata->running_test = 6;
+            dltdata->test_counter_macro[5]=0;
+        }
+        else if (strcmp(text,"Test6: (Macro IF) finished")==0)
+        {
+            if (dltdata->test_counter_macro[5]==2)
+            {
+                printf("Test6m PASSED\n");
+                dltdata->tests_passed++;
+            }
+            else
+            {
+                printf("Test6m FAILED\n");
+                dltdata->tests_failed++;
+            }
+            dltdata->running_test = 0;
+        }
+        else if (dltdata->running_test==6)
+        {
+            dltdata->test_counter_macro[5]++;
+        }
+
+        /* check test 7m */
+        if (strcmp(text,"Test 7: (Macro IF) Test network trace")==0)
+        {
+            printf("Test7m: (Macro IF) Test network trace\n");
+            dltdata->running_test = 7;
+            dltdata->test_counter_macro[6]=0;
+        }
+        else if (strcmp(text,"Test7: (Macro IF) finished")==0)
+        {
+            if (dltdata->test_counter_macro[6]==8)
+            {
+                printf("Test7m PASSED\n");
+                dltdata->tests_passed++;
+            }
+            else
+            {
+                printf("Test7m FAILED\n");
+                dltdata->tests_failed++;
+            }
+            dltdata->running_test = 0;
+        }
+        else if (dltdata->running_test==7)
+        {
+            if (DLT_IS_HTYP_UEH(message->standardheader->htyp))
+            {
+                if ((DLT_GET_MSIN_MSTP(message->extendedheader->msin))==DLT_TYPE_NW_TRACE)
+                {
+                    /* Check message type information*/
+                    /* Each correct message type increases the counter by 1 */
+                    mtin=DLT_GET_MSIN_MTIN(message->extendedheader->msin);
+
+                    if (mtin==DLT_NW_TRACE_IPC)
+                    {
+						dltdata->test_counter_macro[6]++;
+                    }
+                    if (mtin==DLT_NW_TRACE_CAN)
+                    {
+                    	dltdata->test_counter_macro[6]++;
+                    }
+                    if (mtin==DLT_NW_TRACE_FLEXRAY)
+                    {
+                    	dltdata->test_counter_macro[6]++;
+                    }
+                    if (mtin==DLT_NW_TRACE_MOST)
+                    {
+                    	dltdata->test_counter_macro[6]++;
+                    }
+
+                    /* Check payload, must be two arguments (2 raw data blocks) */
+                    /* If the payload is correct, the counter is increased by 1 */
+                    if (message->extendedheader->noar==2)
+                    {
+                        /* verbose mode */
+                        type_info=0;
+                        type_info_tmp=0;
+                        length=0,length_tmp=0; /* the macro can set this variable to -1 */
+
+                        ptr = message->databuffer;
+                        datalength = message->datasize;
+
+                        /* first read the type info of the first argument: must be string */
+                        DLT_MSG_READ_VALUE(type_info_tmp,ptr,datalength,uint32_t);
+                        type_info=DLT_ENDIAN_GET_32(message->standardheader->htyp, type_info_tmp);
+
+                        if (type_info & DLT_TYPE_INFO_RAWD)
+                        {
+                            /* skip string */
+                            DLT_MSG_READ_VALUE(length_tmp,ptr,datalength,uint16_t);
+                            length=DLT_ENDIAN_GET_16(message->standardheader->htyp, length_tmp);
+
+                            if (length>=0)
+                            {
+                                ptr+=length;
+                                datalength-=length;
+
+                                /* read type of second argument: must be raw */
+                                DLT_MSG_READ_VALUE(type_info_tmp,ptr,datalength,uint32_t);
+                                type_info=DLT_ENDIAN_GET_32(message->standardheader->htyp, type_info_tmp);
+
+                                if (type_info & DLT_TYPE_INFO_RAWD)
+                                {
+                                    /* get length of raw data block */
+                                    DLT_MSG_READ_VALUE(length_tmp,ptr,datalength,uint16_t);
+                                    length=DLT_ENDIAN_GET_16(message->standardheader->htyp, length_tmp);
+
+                                    if ((length>=0) && (length==datalength))
+                                    {
+                                        //printf("Raw data found in payload, length=");
+                                        //printf("%d, datalength=%d \n", length, datalength);
+                                        dltdata->test_counter_macro[6]++;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        /* check test 1f */
+        if (strcmp(text,"Test1: (Function IF) Test all log levels")==0)
+        {
+            printf("Test1f: (Function IF) Test all log levels\n");
+            dltdata->running_test = 8;
+            dltdata->test_counter_function[0] = 0;
+        }
+        else if (strcmp(text,"Test1: (Function IF) finished")==0)
+        {
+            /* >=4, as "info" is default log level */
+            if (dltdata->test_counter_function[0]>=4)
+            {
+                printf("Test1f PASSED\n");
+                dltdata->tests_passed++;
+            }
+            else
+            {
+                printf("Test1f FAILED\n");
+                dltdata->tests_failed++;
+            }
+            dltdata->running_test = 0;
+        }
+        else if (dltdata->running_test==8)
+        {
+            if (DLT_IS_HTYP_UEH(message->standardheader->htyp))
+            {
+                if ((DLT_GET_MSIN_MSTP(message->extendedheader->msin))==DLT_TYPE_LOG)
+                {
+                    mtin=DLT_GET_MSIN_MTIN(message->extendedheader->msin);
+
+                    if (mtin==DLT_LOG_FATAL)
+                    {
+                    	dltdata->test_counter_function[0]++;
+                    }
+                    if (mtin==DLT_LOG_ERROR)
+                    {
+                    	dltdata->test_counter_function[0]++;
+                    }
+                    if (mtin==DLT_LOG_WARN)
+                    {
+						dltdata->test_counter_function[0]++;
+                    }
+                    if (mtin==DLT_LOG_INFO)
+                    {
+                    	dltdata->test_counter_function[0]++;
+                    }
+                    if (mtin==DLT_LOG_DEBUG)
+                    {
+                    	dltdata->test_counter_function[0]++;
+                    }
+                    if (mtin==DLT_LOG_VERBOSE)
+                    {
+                    	dltdata->test_counter_function[0]++;
+                    }
+                }
+            }
+        }
+
+        /* check test 2f */
+        if (strcmp(text,"Test2: (Function IF) Test all variable types (verbose)")==0)
+        {
+            printf("Test2f: (Function IF) Test all variable types (verbose)\n");
+            dltdata->running_test = 9;
+            dltdata->test_counter_function[1] = 0;
+        }
+        else if (strcmp(text,"Test2: (Function IF) finished")==0)
+        {
+            if (dltdata->test_counter_function[1]==14)
+            {
+                printf("Test2f PASSED\n");
+                dltdata->tests_passed++;
+            }
+            else
+            {
+                printf("Test2f FAILED\n");
+                dltdata->tests_failed++;
+            }
+            dltdata->running_test = 0;
+        }
+        else if (dltdata->running_test==9)
+        {
+            /* Verbose */
+            if (!(DLT_MSG_IS_NONVERBOSE(message)))
+            {
+                type_info=0;
+                type_info_tmp=0;
+                length=0;
+                length_tmp=0; /* the macro can set this variable to -1 */
+                ptr = message->databuffer;
+                datalength = message->datasize;
+
+                /* Log message */
+                if ((DLT_GET_MSIN_MSTP(message->extendedheader->msin))==DLT_TYPE_LOG)
+                {
+                    if (message->extendedheader->noar>=2)
+                    {
+                        /* get type of first argument: must be string */
+                        DLT_MSG_READ_VALUE(type_info_tmp,ptr,datalength,uint32_t);
+                        type_info=DLT_ENDIAN_GET_32(message->standardheader->htyp, type_info_tmp);
+
+                        if (type_info & DLT_TYPE_INFO_STRG)
+                        {
+                            /* skip string */
+                            DLT_MSG_READ_VALUE(length_tmp,ptr,datalength,uint16_t);
+                            length=DLT_ENDIAN_GET_16(message->standardheader->htyp, length_tmp);
+
+                            if (length>=0)
+                            {
+                                ptr+=length;
+                                datalength-=length;
+
+                                /* read type of second argument: must be raw */
+                                DLT_MSG_READ_VALUE(type_info_tmp,ptr,datalength,uint32_t);
+                                type_info=DLT_ENDIAN_GET_32(message->standardheader->htyp, type_info_tmp);
+
+                                if (type_info & DLT_TYPE_INFO_BOOL)
+                                {
+                                    if (datalength==sizeof(uint8_t))
+                                    {
+                                        dltdata->test_counter_function[1]++;
+                                    }
+                                }
+                                else if (type_info & DLT_TYPE_INFO_SINT)
+                                {
+                                    switch (type_info & DLT_TYPE_INFO_TYLE)
+                                    {
+                                    case DLT_TYLE_8BIT:
+                                    {
+                                        if (datalength==sizeof(int8_t))
+                                        {
+                                            dltdata->test_counter_function[1]++;
+                                        }
+                                        break;
+                                    }
+                                    case DLT_TYLE_16BIT:
+                                    {
+                                        if (datalength==sizeof(int16_t))
+                                        {
+                                            dltdata->test_counter_function[1]++;
+                                        }
+                                        break;
+                                    }
+                                    case DLT_TYLE_32BIT:
+                                    {
+                                        if (datalength==sizeof(int32_t))
+                                        {
+                                            dltdata->test_counter_function[1]++;
+                                        }
+                                        break;
+                                    }
+                                    case DLT_TYLE_64BIT:
+                                    {
+                                        if (datalength==sizeof(int64_t))
+                                        {
+                                            dltdata->test_counter_function[1]++;
+                                        }
+                                        break;
+                                    }
+                                    case DLT_TYLE_128BIT:
+                                    {
+                                        /* Not tested here */
+                                        break;
+                                    }
+                                    }
+                                }
+                                else if (type_info & DLT_TYPE_INFO_UINT)
+                                {
+                                    switch (type_info & DLT_TYPE_INFO_TYLE)
+                                    {
+                                    case DLT_TYLE_8BIT:
+                                    {
+                                    	if (datalength==sizeof(uint8_t))
+                                        {
+                                            dltdata->test_counter_function[1]++;
+                                        }
+                                        break;
+                                    }
+                                    case DLT_TYLE_16BIT:
+                                    {
+                                        if (datalength==sizeof(uint16_t))
+                                        {
+                                            dltdata->test_counter_function[1]++;
+                                        }
+                                        break;
+                                    }
+                                    case DLT_TYLE_32BIT:
+                                    {
+                                        if (datalength==sizeof(uint32_t))
+                                        {
+                                            dltdata->test_counter_function[1]++;
+                                        }
+                                        break;
+                                    }
+                                    case DLT_TYLE_64BIT:
+                                    {
+                                        if (datalength==sizeof(uint64_t))
+                                        {
+                                            dltdata->test_counter_function[1]++;
+                                        }
+                                        break;
+                                    }
+                                    case DLT_TYLE_128BIT:
+                                    {
+                                        /* Not tested here */
+                                        break;
+                                    }
+                                    }
+                                }
+                                else if (type_info & DLT_TYPE_INFO_FLOA)
+                                {
+                                    switch (type_info & DLT_TYPE_INFO_TYLE)
+                                    {
+                                    case DLT_TYLE_8BIT:
+                                    {
+                                        /* Not tested here */
+                                        break;
+                                    }
+                                    case DLT_TYLE_16BIT:
+                                    {
+                                        /* Not tested here */
+                                        break;
+                                    }
+                                    case DLT_TYLE_32BIT:
+                                    {
+                                        if (datalength==(2*sizeof(float)+sizeof(uint32_t)))
+                                        {
+                                            dltdata->test_counter_function[1]++;
+                                        }
+                                        break;
+                                    }
+                                    case DLT_TYLE_64BIT:
+                                    {
+                                        if (datalength==(2*sizeof(double)+sizeof(uint32_t)))
+                                        {
+                                            dltdata->test_counter_function[1]++;
+                                        }
+                                        break;
+                                    }
+                                    case DLT_TYLE_128BIT:
+                                    {
+                                        /* Not tested here */
+                                        break;
+                                    }
+                                    }
+                                }
+                                else if (type_info & DLT_TYPE_INFO_RAWD)
+                                {
+                                    /* Get length */
+                                    DLT_MSG_READ_VALUE(length_tmp,ptr,datalength,uint16_t);
+                                    length=DLT_ENDIAN_GET_16(message->standardheader->htyp, length_tmp);
+                                    if ((length==datalength) && (length=10))
+                                    {
+                                        dltdata->test_counter_function[1]++;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        /* check test 3f */
+        if (strcmp(text,"Test3: (Function IF) Test all variable types (non-verbose)")==0)
+        {
+            printf("Test3f: (Function IF) Test all variable types (non-verbose)\n");
+            dltdata->running_test = 10;
+            dltdata->test_counter_function[2]=0;
+        }
+        else if (strcmp(text,"Test3: (Function IF) finished")==0)
+        {
+            if (dltdata->test_counter_function[2]==14)
+            {
+                printf("Test3f PASSED\n");
+                dltdata->tests_passed++;
+            }
+            else
+            {
+                printf("Test3f FAILED\n");
+                dltdata->tests_failed++;
+            }
+            dltdata->running_test = 0;
+        }
+        else if (dltdata->running_test==10)
+        {
+            /* Nonverbose */
+            if (DLT_MSG_IS_NONVERBOSE(message))
+            {
+                id=0;
+                id_tmp=0;
+                ptr = message->databuffer;
+                datalength = message->datasize;
+                slen=-1;
+
+                tc_old=dltdata->test_counter_function[2];
+
+                /* Get message id */
+                DLT_MSG_READ_VALUE(id_tmp,ptr,datalength,uint32_t);
+                id=DLT_ENDIAN_GET_32(message->standardheader->htyp, id_tmp);
+
+                /* Length of string */
+                datalength-=sizeof(uint16_t);
+                ptr+=sizeof(uint16_t);
+
+                switch (id)
+                {
+                case  1:
+                {
+                    slen=strlen("bool")+1;
+                    datalength-=slen;
+                    ptr+=slen;
+                    if (datalength==sizeof(uint8_t))
+                    {
+                        dltdata->test_counter_function[2]++;
+                    }
+                    break;
+                }
+                case  2:
+                {
+                    slen=strlen("int")+1;
+                    datalength-=slen;
+                    ptr+=slen;
+                    if (datalength==sizeof(int))
+                    {
+                        dltdata->test_counter_function[2]++;
+                    }
+                    break;
+                }
+                case  3:
+                {
+                    slen=strlen("int8")+1;
+                    datalength-=slen;
+                    ptr+=slen;
+                    if (datalength==sizeof(int8_t))
+                    {
+                        dltdata->test_counter_function[2]++;
+                    }
+                    break;
+                }
+                case  4:
+                {
+                    slen=strlen("int16")+1;
+                    datalength-=slen;
+                    ptr+=slen;
+                    if (datalength==sizeof(int16_t))
+                    {
+                        dltdata->test_counter_function[2]++;
+                    }
+                    break;
+                }
+                case  5:
+                {
+                    slen=strlen("int32")+1;
+                    datalength-=slen;
+                    ptr+=slen;
+                    if (datalength==sizeof(int32_t))
+                    {
+                        dltdata->test_counter_function[2]++;
+                    }
+                    break;
+                }
+                case  6:
+                {
+                    slen=strlen("int64")+1;
+                    datalength-=slen;
+                    ptr+=slen;
+                    if (datalength==sizeof(int64_t))
+                    {
+                        dltdata->test_counter_function[2]++;
+                    }
+                    break;
+                }
+                case  7:
+                {
+                    slen=strlen("uint")+1;
+                    datalength-=slen;
+                    ptr+=slen;
+                    if (datalength==sizeof(unsigned int))
+                    {
+                        dltdata->test_counter_function[2]++;
+                    }
+                    break;
+                }
+                case  8:
+                {
+                    slen=strlen("uint8")+1;
+                    datalength-=slen;
+                    ptr+=slen;
+                    if (datalength==sizeof(uint8_t))
+                    {
+                        dltdata->test_counter_function[2]++;
+                    }
+                    break;
+                }
+                case  9:
+                {
+                    slen=strlen("uint16")+1;
+                    datalength-=slen;
+                    ptr+=slen;
+                    if (datalength==sizeof(uint16_t))
+                    {
+                        dltdata->test_counter_function[2]++;
+                    }
+                    break;
+                }
+                case 10:
+                {
+                    slen=strlen("uint32")+1;
+                    datalength-=slen;
+                    ptr+=slen;
+                    if (datalength==sizeof(uint32_t))
+                    {
+                        dltdata->test_counter_function[2]++;
+                    }
+                    break;
+                }
+                case 11:
+                {
+                    slen=strlen("uint64")+1;
+                    datalength-=slen;
+                    ptr+=slen;
+                    if (datalength==sizeof(uint64_t))
+                    {
+                        dltdata->test_counter_function[2]++;
+                    }
+                    break;
+                }
+                case 12:
+                {
+                    slen=strlen("float32")+1;
+                    datalength-=slen;
+                    ptr+=slen;
+                    /* 2*, as the min and the max is transfered */
+                    if (datalength==2*sizeof(float))
+                    {
+                        dltdata->test_counter_function[2]++;
+                    }
+                    break;
+                }
+                case 13:
+                {
+                    slen=strlen("float64")+1;
+                    datalength-=slen;
+                    ptr+=slen;
+                    /* 2*, as the min and the max is transfered */
+                    if (datalength==2*sizeof(double))
+                    {
+                        dltdata->test_counter_function[2]++;
+                    }
+                    break;
+                }
+                case 14:
+                {
+                    slen=strlen("raw")+1;
+                    datalength-=slen;
+                    ptr+=slen;
+                    datalength-=sizeof(uint16_t);
+                    ptr+=sizeof(uint16_t);
+                    if (datalength==10)
+                    {
+                        dltdata->test_counter_function[2]++;
+                    }
+                    break;
+                }
+                }
+
+                if ((slen>=0) && (tc_old==dltdata->test_counter_function[2]))
+                {
+                    printf("ID=%d, Datalength=%d => Failed!",id,datalength);
+                }
+            }
+        }
+
+        /* check test 4f */
+        if (strcmp(text,"Test4: (Function IF) Test different message sizes")==0)
+        {
+            printf("Test4f: (Function IF) Test different message sizes\n");
+            dltdata->running_test = 11;
+            dltdata->test_counter_function[3]=0;
+        }
+        else if (strcmp(text,"Test4: (Function IF) finished")==0)
+        {
+            if (dltdata->test_counter_function[3]==4)
+            {
+                printf("Test4f PASSED\n");
+                dltdata->tests_passed++;
+            }
+            else
+            {
+                printf("Test4f FAILED\n");
+                dltdata->tests_failed++;
+            }
+            dltdata->running_test = 0;
+        }
+        else if (dltdata->running_test==11)
+        {
+            /* Extended header */
+            if (DLT_IS_HTYP_UEH(message->standardheader->htyp))
+            {
+                /* Log message */
+                if ((DLT_GET_MSIN_MSTP(message->extendedheader->msin))==DLT_TYPE_LOG)
+                {
+                    /* Verbose */
+                    if (DLT_IS_MSIN_VERB(message->extendedheader->msin))
+                    {
+                        /* 2 arguments */
+                        if (message->extendedheader->noar==2)
+                        {
+                            /* verbose mode */
+                            type_info=0;
+                            type_info_tmp=0;
+                            length=0;
+                            length_tmp=0; /* the macro can set this variable to -1 */
+
+                            ptr = message->databuffer;
+                            datalength = message->datasize;
+
+                            /* first read the type info of the first argument: should be string */
+                            DLT_MSG_READ_VALUE(type_info_tmp,ptr,datalength,uint32_t);
+                            type_info=DLT_ENDIAN_GET_32(message->standardheader->htyp, type_info_tmp);
+
+                            if (type_info & DLT_TYPE_INFO_STRG)
+                            {
+                                /* skip string */
+                                DLT_MSG_READ_VALUE(length_tmp,ptr,datalength,uint16_t);
+                                length=DLT_ENDIAN_GET_16(message->standardheader->htyp, length_tmp);
+
+                                if (length>=0)
+                                {
+                                    ptr+=length;
+                                    datalength-=length;
+
+                                    /* read type of second argument: should be raw */
+                                    DLT_MSG_READ_VALUE(type_info_tmp,ptr,datalength,uint32_t);
+                                    type_info=DLT_ENDIAN_GET_32(message->standardheader->htyp, type_info_tmp);
+
+                                    if (type_info & DLT_TYPE_INFO_RAWD)
+                                    {
+                                        /* get length of raw data block */
+                                        DLT_MSG_READ_VALUE(length_tmp,ptr,datalength,uint16_t);
+                                        length=DLT_ENDIAN_GET_16(message->standardheader->htyp, length_tmp);
+
+                                        if ((length>=0) && (length==datalength))
+                                        {
+                                            //printf("Raw data found in payload, length=");
+                                            //printf("%d, datalength=%d \n", length, datalength);
+                                            dltdata->test_counter_function[3]++;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        /* check test 5f */
+        if (strcmp(text,"Test5: (Function IF) Test high-level API")==0)
+        {
+            printf("Test5f: (Function IF) Test high-level API\n");
+            dltdata->running_test = 12;
+            dltdata->test_counter_function[4]=0;
+        }
+        else if (strcmp(text,"Test5: (Function IF) finished")==0)
+        {
+            if (dltdata->test_counter_function[4]==12)
+            {
+                printf("Test5f PASSED\n");
+                dltdata->tests_passed++;
+            }
+            else
+            {
+                printf("Test5f FAILED\n");
+                dltdata->tests_failed++;
+            }
+            dltdata->running_test = 0;
+        }
+        else if (dltdata->running_test==12)
+        {
+            if (strcmp(text,"Next line: dlt_log_int()")==0)
+            {
+                dltdata->test_counter_function[4]++;
+            }
+            if (strcmp(text,"-42")==0)
+            {
+                dltdata->test_counter_function[4]++;
+            }
+
+            if (strcmp(text,"Next line: dlt_log_uint()")==0)
+            {
+                dltdata->test_counter_function[4]++;
+            }
+            if (strcmp(text,"42")==0)
+            {
+                dltdata->test_counter_function[4]++;
+            }
+
+            if (strcmp(text,"Next line: dlt_log_string()")==0)
+            {
+                dltdata->test_counter_function[4]++;
+            }
+            if (strcmp(text,"String output")==0)
+            {
+                dltdata->test_counter_function[4]++;
+            }
+
+            if (strcmp(text,"Next line: dlt_log_raw()")==0)
+            {
+                dltdata->test_counter_function[4]++;
+            }
+            if (strcmp(text,"00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f")==0)
+            {
+                dltdata->test_counter_function[4]++;
+            }
+
+            if (strcmp(text,"Next line: dlt_log_string_int()")==0)
+            {
+                dltdata->test_counter_function[4]++;
+            }
+            if (strcmp(text,"String output:  -42")==0)
+            {
+                dltdata->test_counter_function[4]++;
+            }
+
+            if (strcmp(text,"Next line: dlt_log_string_uint()")==0)
+            {
+                dltdata->test_counter_function[4]++;
+            }
+            if (strcmp(text,"String output:  42")==0)
+            {
+                dltdata->test_counter_function[4]++;
+            }
+        }
+
+        /* check test 6f */
+        if (strcmp(text,"Test 6: (Function IF) Test local printing")==0)
+        {
+            printf("Test6f: (Function IF) Test local printing\n");
+            dltdata->running_test = 13;
+            dltdata->test_counter_function[5]=0;
+        }
+        else if (strcmp(text,"Test6: (Function IF) finished")==0)
+        {
+            if (dltdata->test_counter_function[5]==2)
+            {
+                printf("Test6f PASSED\n");
+                dltdata->tests_passed++;
+            }
+            else
+            {
+                printf("Test6f FAILED\n");
+                dltdata->tests_failed++;
+            }
+            dltdata->running_test = 0;
+        }
+        else if (dltdata->running_test==13)
+        {
+            dltdata->test_counter_function[5]++;
+        }
+
+        /* check test 7f */
+        if (strcmp(text,"Test 7: (Function IF) Test network trace")==0)
+        {
+            printf("Test7f: (Function IF) Test network trace\n");
+            dltdata->running_test = 14;
+            dltdata->test_counter_function[6]=0;
+        }
+        else if (strcmp(text,"Test7: (Function IF) finished")==0)
+        {
+            if (dltdata->test_counter_function[6]==8)
+            {
+                printf("Test7f PASSED\n");
+                dltdata->tests_passed++;
+            }
+            else
+            {
+                printf("Test7f FAILED\n");
+                dltdata->tests_failed++;
+            }
+            dltdata->running_test = 0;
+        }
+        else if (dltdata->running_test==14)
+        {
+            if (DLT_IS_HTYP_UEH(message->standardheader->htyp))
+            {
+                if ((DLT_GET_MSIN_MSTP(message->extendedheader->msin))==DLT_TYPE_NW_TRACE)
+                {
+                    /* Check message type information*/
+                    /* Each correct message type increases the counter by 1 */
+                    mtin=DLT_GET_MSIN_MTIN(message->extendedheader->msin);
+
+                    if (mtin==DLT_NW_TRACE_IPC)
+                    {
+						dltdata->test_counter_function[6]++;
+                    }
+                    if (mtin==DLT_NW_TRACE_CAN)
+                    {
+						dltdata->test_counter_function[6]++;
+                    }
+                    if (mtin==DLT_NW_TRACE_FLEXRAY)
+                    {
+                    	dltdata->test_counter_function[6]++;
+                    }
+                    if (mtin==DLT_NW_TRACE_MOST)
+                    {
+                    	dltdata->test_counter_function[6]++;
+                    }
+
+                    /* Check payload, must be two arguments (2 raw data blocks) */
+                    /* If the payload is correct, the counter is increased by 1 */
+                    if (message->extendedheader->noar==2)
+                    {
+                        /* verbose mode */
+                        type_info=0;
+                        type_info_tmp=0;
+                        length=0;
+                        length_tmp=0; /* the macro can set this variable to -1 */
+
+                        ptr = message->databuffer;
+                        datalength = message->datasize;
+
+                        /* first read the type info of the first argument: should be string */
+                        DLT_MSG_READ_VALUE(type_info_tmp,ptr,datalength,uint32_t);
+                        type_info=DLT_ENDIAN_GET_32(message->standardheader->htyp, type_info_tmp);
+
+                        if (type_info & DLT_TYPE_INFO_RAWD)
+                        {
+                            /* skip string */
+                            DLT_MSG_READ_VALUE(length_tmp,ptr,datalength,uint16_t);
+                            length=DLT_ENDIAN_GET_16(message->standardheader->htyp, length_tmp);
+
+                            if (length>=0)
+                            {
+                                ptr+=length;
+                                datalength-=length;
+
+                                /* read type of second argument: should be raw */
+                                DLT_MSG_READ_VALUE(type_info_tmp,ptr,datalength,uint32_t);
+                                type_info=DLT_ENDIAN_GET_32(message->standardheader->htyp, type_info_tmp);
+
+                                if (type_info & DLT_TYPE_INFO_RAWD)
+                                {
+                                    /* get length of raw data block */
+                                    DLT_MSG_READ_VALUE(length_tmp,ptr,datalength,uint16_t);
+                                    length=DLT_ENDIAN_GET_16(message->standardheader->htyp, length_tmp);
+
+                                    if ((length>=0) && (length==datalength))
+                                    {
+                                        //printf("Raw data found in payload, length=");
+                                        //printf("%d, datalength=%d \n", length, datalength);
+                                        dltdata->test_counter_function[6]++;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        if (strcmp(text,"Tests finished")==0)
+        {
+            printf("Tests finished\n");
+            dltdata->running_test = 1;
+
+            printf("%d tests passed\n",dltdata->tests_passed);
+            printf("%d tests failed\n",dltdata->tests_failed);
+
+            if (dltdata->sock!=-1)
+            {
+                close(dltdata->sock);
+            }
+
+            return 0;
+        }
+
+        /* if no filter set or filter is matching display message */
+        if (dltdata->xflag)
+        {
+            dlt_message_print_hex(message,text,DLT_TESTCLIENT_TEXTBUFSIZE,dltdata->vflag);
+        }
+        else if (dltdata->mflag)
+        {
+            dlt_message_print_mixed_plain(message,text,DLT_TESTCLIENT_TEXTBUFSIZE,dltdata->vflag);
+        }
+        else if (dltdata->sflag)
+        {
+            dlt_message_print_header(message,text,sizeof(text),dltdata->vflag);
+        }
+
+        /* if file output enabled write message */
+        if (dltdata->ovalue)
+        {
+            iov[0].iov_base = message->headerbuffer;
+            iov[0].iov_len = message->headersize;
+            iov[1].iov_base = message->databuffer;
+            iov[1].iov_len = message->datasize;
+
+            bytes_written = writev(dltdata->ohandle, iov, 2);
+        }
+    }
+
+    return 0;
+}