Main Page | Modules | Class Hierarchy | Alphabetical List | Class List | File List | Class Members | File Members | Related Pages

TestCasePUSDataReportingPacket_3.cpp

00001 //
00002 // Copyright 2004 P&P Software GmbH - All Rights Reserved
00003 //
00004 // TestCasePUSDataReportingPacket_3.cpp
00005 //
00006 // Version      1.0
00007 // Date         04.12.03
00008 // Author       A. Pasetti (P&P Software)
00009 
00010 #include "../GeneralInclude/CompilerSwitches.h"
00011 #include "../GeneralInclude/ClassId.h"
00012 #include "../GeneralInclude/BasicTypes.h"
00013 #include "../GeneralInclude/Constants.h"
00014 #include "../Telemetry/DC_PUSDataReportingPacket.h"
00015 #include "../Data/DC_SampleFullDataPool.h"
00016 #include "../Utilities/TestCaseWithEvtCheck.h"
00017 #include "TestCasePUSDataReportingPacket_3.h"
00018 
00019 #include <math.h>
00020 #include <float.h>
00021 #include <assert.h>
00022 #include <string.h>
00023 
00024 TestCasePUSDataReportingPacket_3::TestCasePUSDataReportingPacket_3(void) :
00025         TestCaseWithEvtCheck(ID_PUSDATAREPORTINGPACKET*10+3,"TestCasePUSDataReportingPacket_3") {
00026                 return;
00027 }
00028 
00029 void TestCasePUSDataReportingPacket_3::runTestCase(void) {
00030 
00031    DC_SampleFullDataPool* pDP = new DC_SampleFullDataPool();
00032    unsigned int nEvt = getNumberOfEvents();
00033    DC_PUSDataReportingPacket* pTMP = new DC_PUSDataReportingPacket();
00034 
00035    // Configure and load the data pool
00036    pDP->setObsClock(DC_PUSDataReportingPacket::getObsClock());
00037    DataPool* pOldDP = CC_RootObject::getDataPool();
00038    CC_RootObject::setDataPool(pDP);
00039 
00040    // Define the PUS packet
00041    TD_SID sid = 12;
00042    TD_PUSCollectionInterval collectionInterval = 6;
00043    TD_PUSNumberOfParameters NPAR1 = 1;
00044    unsigned char NFA = 2;
00045    unsigned char NREP2 = 2;
00046    TD_PUSNumberOfParameters NPAR2 = 2;
00047    unsigned char NREP3 = 3;
00048    TD_PUSNumberOfParameters NPAR3 = 1;
00049    TD_DataPoolId par1 = 1;
00050    TD_Integer val1 = 11;
00051    TD_DataPoolId par2 = 2;
00052    TD_Float val2 = 12.0;
00053    TD_DataPoolId par3 = 4;
00054    TD_Integer val3 = 14;
00055    TD_DataPoolId par4 = 5;
00056    TD_Float val4 = 15.0;
00057 
00058    // Construct the packet
00059    unsigned short defPacketSize = 300;
00060    unsigned char* packet = new unsigned char[defPacketSize];
00061    unsigned int offset = 0;
00062 
00063    memcpy(packet+offset,&sid,sizeof(TD_SID));
00064    offset += sizeof(TD_SID);
00065    memcpy(packet+offset,&collectionInterval,sizeof(TD_PUSCollectionInterval));
00066    offset += sizeof(TD_PUSCollectionInterval);
00067    memcpy(packet+offset,&NPAR1,sizeof(TD_PUSNumberOfParameters));
00068    offset += sizeof(TD_PUSNumberOfParameters);
00069    memcpy(packet+offset,&par1,sizeof(TD_DataPoolId));
00070    offset += sizeof(TD_DataPoolId);
00071    memcpy(packet+offset,&NFA,1);
00072    offset += 1;
00073    memcpy(packet+offset,&NREP2,1);
00074    offset += 1;
00075    memcpy(packet+offset,&NPAR2,sizeof(TD_PUSNumberOfParameters));
00076    offset += sizeof(TD_PUSNumberOfParameters);
00077    memcpy(packet+offset,&par2,sizeof(TD_DataPoolId));
00078    offset += sizeof(TD_DataPoolId);
00079    memcpy(packet+offset,&par3,sizeof(TD_DataPoolId));
00080    offset += sizeof(TD_DataPoolId);
00081    memcpy(packet+offset,&NREP3,1);
00082    offset += 1;
00083    memcpy(packet+offset,&NPAR3,sizeof(TD_PUSNumberOfParameters));
00084    offset += sizeof(TD_PUSNumberOfParameters);
00085    memcpy(packet+offset,&par4,sizeof(TD_DataPoolId));
00086    offset += sizeof(TD_DataPoolId);
00087 
00088    assert(offset<defPacketSize);
00089 
00090    // Configure the data reporting packet and check configuration status
00091    pTMP->setMaxNumberFA(2);
00092    pTMP->setDefinitionBufferSize(defPacketSize);
00093    unsigned int valBufferSize = 75;
00094    pTMP->setValueBufferSize(valBufferSize);
00095    pTMP->setSubType(PUS_ST_DATA_REP_PAR_HK_REP);
00096    pTMP->setTimeTag(0);
00097    pTMP->setEnabled(ENABLED);
00098    if ( !pTMP->isObjectConfigured() )
00099    {    setTestResult(TEST_FAILURE,"Wrong configuration status");
00100         return;
00101    }
00102 
00103    // Load the packet definition
00104    for (unsigned short i=0; i<offset; i++)
00105         pTMP->setDefinitionBuffer(i,packet[i]);
00106 
00107    if (pTMP->getDefinitionBufferLength()!=offset)
00108    {    setTestResult(TEST_FAILURE,"Wrong definition buffer length");
00109         return;
00110    }
00111 
00112    // Set the values of the data pool items
00113    pDP->setValue(par1,val1);
00114    pDP->setValue(par2,val2);
00115    pDP->setValue(par3,val3);
00116    pDP->setValue(par4,val4);
00117 
00118    // Send five update requests and check that there are no data to be acquired
00119    // The data pool item values are updated after each update request
00120    pTMP->update();
00121    if (pTMP->getNumberOfBytes()!=0)
00122    {    setTestResult(TEST_FAILURE,"Wrong number of bytes");
00123         return;
00124    }
00125    pDP->setValue(par1,(TD_Integer)(2*val1));
00126    pDP->setValue(par2,(TD_Float)(2*val2));
00127    pDP->setValue(par3,(TD_Integer)(2*val3));
00128    pDP->setValue(par4,(TD_Float)(2*val4));
00129 
00130    pTMP->update();
00131    if (pTMP->getNumberOfBytes()!=0)
00132    {    setTestResult(TEST_FAILURE,"Wrong number of bytes");
00133         return;
00134    }
00135    pDP->setValue(par1,(TD_Integer)(3*val1));
00136    pDP->setValue(par2,(TD_Float)(3*val2));
00137    pDP->setValue(par3,(TD_Integer)(3*val3));
00138    pDP->setValue(par4,(TD_Float)(3*val4));
00139 
00140    pTMP->update();
00141    if (pTMP->getNumberOfBytes()!=0)
00142    {    setTestResult(TEST_FAILURE,"Wrong number of bytes");
00143         return;
00144    }
00145    pDP->setValue(par1,(TD_Integer)(4*val1));
00146    pDP->setValue(par2,(TD_Float)(4*val2));
00147    pDP->setValue(par3,(TD_Integer)(4*val3));
00148    pDP->setValue(par4,(TD_Float)(4*val4));
00149 
00150    pTMP->update();
00151    if (pTMP->getNumberOfBytes()!=0)
00152    {    setTestResult(TEST_FAILURE,"Wrong number of bytes");
00153         return;
00154    }
00155    pDP->setValue(par1,(TD_Integer)(5*val1));
00156    pDP->setValue(par2,(TD_Float)(5*val2));
00157    pDP->setValue(par3,(TD_Integer)(5*val3));
00158    pDP->setValue(par4,(TD_Float)(5*val4));
00159 
00160    pTMP->update();
00161    if (pTMP->getNumberOfBytes()!=0)
00162    {    setTestResult(TEST_FAILURE,"Wrong number of bytes");
00163         return;
00164    }
00165    pDP->setValue(par1,(TD_Integer)(6*val1));
00166    pDP->setValue(par2,(TD_Float)(6*val2));
00167    pDP->setValue(par3,(TD_Integer)(6*val3));
00168    pDP->setValue(par4,(TD_Float)(6*val4));
00169 
00170    // Send the sixth update request and check data acquisition service
00171    pTMP->update();
00172    pDP->setValue(par1,(TD_Integer)(7*val1));
00173    pDP->setValue(par2,(TD_Float)(7*val2));
00174    pDP->setValue(par3,(TD_Integer)(7*val3));
00175    pDP->setValue(par4,(TD_Float)(7*val4));
00176 
00177    unsigned int n1, n2, n3;
00178    n1 = sizeof(TD_SID);
00179    n2 = (PUS_DATA_REP_MODE?1:0);
00180    n3 = 1*sizeof(TD_Integer)+2*sizeof(TD_Float)+2*sizeof(TD_Integer)+3*sizeof(TD_Float);
00181    unsigned int expNumberOfBytes = n1+n2+n3;
00182    if (pTMP->getNumberOfBytes()!=expNumberOfBytes)
00183    {    setTestResult(TEST_FAILURE,"Wrong number of bytes");
00184         return;
00185    }
00186 
00187    // Collect the packet data and check their values
00188    unsigned char* valBuffer = new unsigned char[valBufferSize];
00189    for (unsigned int i=0; i<pTMP->getNumberOfBytes(); i++) {
00190        valBuffer[i] = pTMP->getUnsignedByte(i);
00191        assert(i<valBufferSize);
00192    }
00193 
00194    unsigned int valOffset = 0;
00195    TD_SID sidTemp = 0;
00196    TD_Integer intTemp = 0;
00197    TD_Float flTemp = 0;
00198 
00199    memcpy(&sidTemp,valBuffer+valOffset,sizeof(TD_SID));
00200    if ( sidTemp != sid )
00201    {    setTestResult(TEST_FAILURE,"Wrong sid field");
00202         return;
00203    }
00204    valOffset += sizeof(TD_SID);
00205 
00206    if ( PUS_DATA_REP_MODE?valBuffer[valOffset]!=0:false )
00207    {    setTestResult(TEST_FAILURE,"Wrong mode field");
00208         return;
00209    }
00210    valOffset += (PUS_DATA_REP_MODE?1:0);
00211 
00212    memcpy(&intTemp,valBuffer+valOffset,sizeof(TD_Integer));
00213    if ( intTemp != (TD_Integer)6*val1 )
00214    {    setTestResult(TEST_FAILURE,"Wrong parameter 1 field");
00215         return;
00216    }
00217    valOffset += sizeof(TD_Integer);
00218 
00219    memcpy(&flTemp,valBuffer+valOffset,sizeof(TD_Float));
00220    if ( fabs((float)(flTemp - (TD_Float)3*val2)) > FLT_EPSILON )
00221    {    setTestResult(TEST_FAILURE,"Wrong parameter 2 field");
00222         return;
00223    }
00224    valOffset += sizeof(TD_Float);
00225 
00226    memcpy(&intTemp,valBuffer+valOffset,sizeof(TD_Integer));
00227    if ( intTemp != (TD_Integer)3*val3 )
00228    {    setTestResult(TEST_FAILURE,"Wrong parameter 3 field");
00229         return;
00230    }
00231    valOffset += sizeof(TD_Integer);
00232 
00233    memcpy(&flTemp,valBuffer+valOffset,sizeof(TD_Float));
00234    if ( fabs((float)(flTemp - (TD_Float)6*val2)) > FLT_EPSILON )
00235    {    setTestResult(TEST_FAILURE,"Wrong parameter 2 field");
00236         return;
00237    }
00238    valOffset += sizeof(TD_Float);
00239 
00240    memcpy(&intTemp,valBuffer+valOffset,sizeof(TD_Integer));
00241    if ( intTemp  != (TD_Integer)6*val3 )
00242    {    setTestResult(TEST_FAILURE,"Wrong parameter 3 field");
00243         return;
00244    }
00245    valOffset += sizeof(TD_Integer);
00246 
00247    memcpy(&flTemp,valBuffer+valOffset,sizeof(TD_Float));
00248    if ( fabs((float)(flTemp  - (TD_Float)2*val4)) > FLT_EPSILON )
00249    {    setTestResult(TEST_FAILURE,"Wrong parameter 4 field");
00250         return;
00251    }
00252    valOffset += sizeof(TD_Float);
00253 
00254    memcpy(&flTemp,valBuffer+valOffset,sizeof(TD_Float));
00255    if ( fabs((float)(flTemp  - (TD_Float)4*val4)) > FLT_EPSILON )
00256    {    setTestResult(TEST_FAILURE,"Wrong parameter 4 field");
00257         return;
00258    }
00259    valOffset += sizeof(TD_Float);
00260 
00261    memcpy(&flTemp,valBuffer+valOffset,sizeof(TD_Float));
00262    if ( fabs((float)(flTemp  - (TD_Float)6*val4)) > FLT_EPSILON )
00263    {    setTestResult(TEST_FAILURE,"Wrong parameter 4 field");
00264         return;
00265    }
00266 
00267    assert(valOffset<valBufferSize);
00268 
00269    // Send five update requests and check that there are no data to be acquired
00270    // The data pool item values are updated after each update request
00271    pTMP->update();
00272    if (pTMP->getNumberOfBytes()!=0)
00273    {    setTestResult(TEST_FAILURE,"Wrong number of bytes");
00274         return;
00275    }
00276    pDP->setValue(par1,(TD_Integer)(8*val1));
00277    pDP->setValue(par2,(TD_Float)(8*val2));
00278    pDP->setValue(par3,(TD_Integer)(8*val3));
00279    pDP->setValue(par4,(TD_Float)(8*val4));
00280 
00281    pTMP->update();
00282    if (pTMP->getNumberOfBytes()!=0)
00283    {    setTestResult(TEST_FAILURE,"Wrong number of bytes");
00284         return;
00285    }
00286    pDP->setValue(par1,(TD_Integer)(9*val1));
00287    pDP->setValue(par2,(TD_Float)(9*val2));
00288    pDP->setValue(par3,(TD_Integer)(9*val3));
00289    pDP->setValue(par4,(TD_Float)(9*val4));
00290 
00291    pTMP->update();
00292    if (pTMP->getNumberOfBytes()!=0)
00293    {    setTestResult(TEST_FAILURE,"Wrong number of bytes");
00294         return;
00295    }
00296    pDP->setValue(par1,(TD_Integer)(10*val1));
00297    pDP->setValue(par2,(TD_Float)(10*val2));
00298    pDP->setValue(par3,(TD_Integer)(10*val3));
00299    pDP->setValue(par4,(TD_Float)(10*val4));
00300 
00301    pTMP->update();
00302    if (pTMP->getNumberOfBytes()!=0)
00303    {    setTestResult(TEST_FAILURE,"Wrong number of bytes");
00304         return;
00305    }
00306    pDP->setValue(par1,(TD_Integer)(11*val1));
00307    pDP->setValue(par2,(TD_Float)(11*val2));
00308    pDP->setValue(par3,(TD_Integer)(11*val3));
00309    pDP->setValue(par4,(TD_Float)(11*val4));
00310 
00311    pTMP->update();
00312    if (pTMP->getNumberOfBytes()!=0)
00313    {    setTestResult(TEST_FAILURE,"Wrong number of bytes");
00314         return;
00315    }
00316    pDP->setValue(par1,(TD_Integer)(12*val1));
00317    pDP->setValue(par2,(TD_Float)(12*val2));
00318    pDP->setValue(par3,(TD_Integer)(12*val3));
00319    pDP->setValue(par4,(TD_Float)(12*val4));
00320 
00321    // Send the sixth update request and check data acquisition service
00322    pTMP->update();
00323 
00324    n1, n2, n3;
00325    n1 = sizeof(TD_SID);
00326    n2 = (PUS_DATA_REP_MODE?1:0);
00327    n3 = 1*sizeof(TD_Integer)+2*sizeof(TD_Float)+2*sizeof(TD_Integer)+3*sizeof(TD_Float);
00328    expNumberOfBytes = n1+n2+n3;
00329    if (pTMP->getNumberOfBytes()!=expNumberOfBytes)
00330    {    setTestResult(TEST_FAILURE,"Wrong number of bytes");
00331         return;
00332    }
00333 
00334    // Collect the packet data and check their values
00335    for (unsigned int i=0; i<pTMP->getNumberOfBytes(); i++) {
00336        valBuffer[i] = pTMP->getUnsignedByte(i);
00337        assert(i<valBufferSize);
00338    }
00339 
00340    valOffset = 0;
00341    memcpy(&sidTemp,valBuffer+valOffset,sizeof(TD_SID));
00342    if ( memcmp(valBuffer+valOffset,&sid,sizeof(TD_SID))!=0 )
00343    {    setTestResult(TEST_FAILURE,"Wrong sid field");
00344         return;
00345    }
00346    valOffset += sizeof(TD_SID);
00347 
00348    if ( PUS_DATA_REP_MODE?valBuffer[valOffset]!=0:false )
00349    {    setTestResult(TEST_FAILURE,"Wrong mode field");
00350         return;
00351    }
00352    valOffset += (PUS_DATA_REP_MODE?1:0);
00353 
00354    memcpy(&intTemp,valBuffer+valOffset,sizeof(TD_Integer));
00355    if ( intTemp != (TD_Integer)12*val1 )
00356    {    setTestResult(TEST_FAILURE,"Wrong parameter 1 field");
00357         return;
00358    }
00359    valOffset += sizeof(TD_Integer);
00360 
00361    memcpy(&flTemp,valBuffer+valOffset,sizeof(TD_Float));
00362    if ( fabs((float)(flTemp  - (TD_Float)9*val2)) > FLT_EPSILON )
00363    {    setTestResult(TEST_FAILURE,"Wrong parameter 2 field");
00364         return;
00365    }
00366    valOffset += sizeof(TD_Float);
00367 
00368    memcpy(&intTemp,valBuffer+valOffset,sizeof(TD_Integer));
00369    if ( intTemp != (TD_Integer)9*val3 )
00370    {    setTestResult(TEST_FAILURE,"Wrong parameter 3 field");
00371         return;
00372    }
00373    valOffset += sizeof(TD_Integer);
00374 
00375    memcpy(&flTemp,valBuffer+valOffset,sizeof(TD_Float));
00376    if ( fabs((float)(flTemp  - (TD_Float)12*val2)) > FLT_EPSILON )
00377    {    setTestResult(TEST_FAILURE,"Wrong parameter 2 field");
00378         return;
00379    }
00380    valOffset += sizeof(TD_Float);
00381 
00382    memcpy(&intTemp,valBuffer+valOffset,sizeof(TD_Integer));
00383    if ( intTemp != (TD_Integer)12*val3 )
00384    {    setTestResult(TEST_FAILURE,"Wrong parameter 3 field");
00385         return;
00386    }
00387    valOffset += sizeof(TD_Integer);
00388 
00389    memcpy(&flTemp,valBuffer+valOffset,sizeof(TD_Float));
00390    if ( fabs((float)(flTemp  - (TD_Float)8*val4)) > FLT_EPSILON )
00391    {    setTestResult(TEST_FAILURE,"Wrong parameter 4 field");
00392         return;
00393    }
00394    valOffset += sizeof(TD_Float);
00395 
00396    memcpy(&flTemp,valBuffer+valOffset,sizeof(TD_Float));
00397    if ( fabs((float)(flTemp  - (TD_Float)10*val4)) > FLT_EPSILON )
00398    {    setTestResult(TEST_FAILURE,"Wrong parameter 4 field");
00399         return;
00400    }
00401    valOffset += sizeof(TD_Float);
00402 
00403    memcpy(&flTemp,valBuffer+valOffset,sizeof(TD_Float));
00404    if ( fabs((float)(flTemp  - (TD_Float)12*val4)) > FLT_EPSILON )
00405    {    setTestResult(TEST_FAILURE,"Wrong parameter 4 field");
00406         return;
00407    }
00408    valOffset += sizeof(TD_Float);
00409    assert(valOffset<valBufferSize);
00410 
00411    // Construct a packet that will cause the packet value buffer to overflow
00412    if (isNonNominalCheckAllowed()) {
00413        unsigned int nIntPar = (unsigned int)(valBufferSize - sizeof(TD_SID) -
00414                                                 (PUS_DATA_REP_MODE?1:0))/sizeof(TD_Integer)+1;
00415        sid = 13;
00416        collectionInterval = 1;
00417        NPAR1 = (TD_PUSNumberOfParameters)nIntPar;
00418        NFA = 0;
00419        par1 = 1;
00420 
00421        offset = 0;                                  // the new packet is defined
00422        memcpy(packet+offset,&sid,sizeof(TD_SID));
00423        offset += sizeof(TD_SID);
00424        memcpy(packet+offset,&collectionInterval,sizeof(TD_PUSCollectionInterval));
00425        offset += sizeof(TD_PUSCollectionInterval);
00426        memcpy(packet+offset,&NPAR1,sizeof(TD_PUSNumberOfParameters));
00427        offset += sizeof(TD_PUSNumberOfParameters);
00428 
00429        for (unsigned int i=0; i<NPAR1; i++) {
00430             memcpy(packet+offset,&par1,sizeof(TD_DataPoolId));
00431             offset += sizeof(TD_DataPoolId);
00432        }
00433        assert(offset<defPacketSize);
00434 
00435        for (unsigned short i=0; i<offset; i++)      // the new packet definition is loaded
00436             pTMP->setDefinitionBuffer(i,packet[i]);
00437 
00438        pTMP->update();
00439 
00440        if ( !verifyLatestEvent(nEvt+1,EVT_PUS_DATA_REP_PACKET_TOO_LARGE) )
00441             return;
00442        nEvt = nEvt+1;
00443    }
00444 
00445    // Restore the original data pool
00446    CC_RootObject::setDataPool(pOldDP);
00447 
00448    setTestResult(TEST_SUCCESS,"Test Successful");
00449    return;
00450 }
Copyright 2003 P&P Software GmbH - All Rights Reserved