OBS Framework: TestCasePUSMemoryLoadOffset

00001 // 00002 // Copyright 2004 P&P Software GmbH - All Rights Reserved 00003 // 00004 // TestCasePUSMemoryLoadOffset_1.cpp 00005 // 00006 // Version 1.0 00007 // Date 04.02.04 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 "../Telecommand/DC_PUSMemoryLoadOffset.h" 00015 #include "../Utilities/TestCaseWithEvtCheck.h" 00016 #include "TestCasePUSMemoryLoadOffset_1.h" 00017 00018 #include <assert.h> 00019 #include <string.h> 00020 00021 TestCasePUSMemoryLoadOffset_1::TestCasePUSMemoryLoadOffset_1(void) : 00022 TestCaseWithEvtCheck(ID_PUSMEMORYLOADOFFSET*10+1,"TestCasePUSMemoryLoadOffset_1") { 00023 return; 00024 } 00025 00026 void TestCasePUSMemoryLoadOffset_1::runTestCase(void) { 00027 00028 DC_PUSMemoryLoadOffset* pML = new DC_PUSMemoryLoadOffset(); 00029 00030 // Set dummy values for the configuration parameters defined at 00031 // the level of Telecommand and PUSTelecommand superclasses 00032 pML->setTimeTag(0); 00033 pML->setSource(1); 00034 pML->setTelecommandId(2); 00035 00036 // Memory area where telecommand data will be loaded 00037 const unsigned int paSize =100; 00038 TD_PUSMemData pa[paSize]; 00039 for (unsigned int i=0; i<paSize; i++) 00040 pa[i]=0; 00041 00042 // Data area for the telecommand packet 00043 const unsigned short defPacketSize = 100; 00044 unsigned char packet[defPacketSize]; 00045 00046 // Check the correctness of the class identifier 00047 if ( (pML->getClassId() != ID_PUSMEMORYLOADOFFSET) ) 00048 { setTestResult(TEST_FAILURE,"Wrong class identifier"); 00049 return; 00050 } 00051 00052 // Check configuration status 00053 if ( pML->isObjectConfigured() ) 00054 { setTestResult(TEST_FAILURE,"Wrong configuration status at initialization"); 00055 return; 00056 } 00057 00058 // Set maximum number of blocks 00059 pML->setMaxNumberBlocks(3); 00060 if ( pML->getMaxNumberBlocks()!=3 ) 00061 { setTestResult(TEST_FAILURE,"Wrong configuration parameter"); 00062 return; 00063 } 00064 00065 // Set maximum number of data 00066 pML->setMaxNumberData(10); 00067 if ( pML->getMaxNumberData()!=10 ) 00068 { setTestResult(TEST_FAILURE,"Wrong configuration parameter"); 00069 return; 00070 } 00071 00072 // Check configuration status 00073 if ( !pML->isObjectConfigured() ) 00074 { setTestResult(TEST_FAILURE,"Wrong configuration status after initialization"); 00075 return; 00076 } 00077 00078 // Define fixed part of the memory load PUS packet 00079 unsigned int offset = 0; 00080 TD_PUSMemId id = 12; 00081 TD_PUSMemData* base = pa; 00082 memcpy(packet+offset,&id,sizeof(TD_PUSMemId)); 00083 offset += sizeof(TD_PUSMemId); 00084 memcpy(packet+offset,&base,sizeof(TD_PUSMemData*)); 00085 offset += sizeof(TD_PUSMemData*); 00086 00087 // Define the first load packet (one block with two data) 00088 TD_PUSMemOffset os1 = 2; 00089 TD_PUSMemLength len1 = 2; 00090 TD_PUSMemData d1 = 1; 00091 TD_PUSMemData d2 = 2; 00092 TD_PUSNumberMemBlocks nmb = 1; 00093 unsigned short checkSum = 0; 00094 00095 memcpy(packet+offset,&nmb,sizeof(TD_PUSNumberMemBlocks)); 00096 offset += sizeof(TD_PUSNumberMemBlocks); 00097 memcpy(packet+offset,&os1,sizeof(TD_PUSMemLength)); 00098 offset += sizeof(TD_PUSMemLength); 00099 memcpy(packet+offset,&len1,sizeof(TD_PUSMemLength)); 00100 offset += sizeof(TD_PUSMemLength); 00101 memcpy(packet+offset,&d1,sizeof(TD_PUSMemData)); 00102 offset += sizeof(TD_PUSMemData); 00103 memcpy(packet+offset,&d2,sizeof(TD_PUSMemData)); 00104 offset += sizeof(TD_PUSMemData); 00105 memcpy(packet+offset,&checkSum,2); 00106 offset += sizeof(unsigned short); 00107 00108 // Load packet and check validity 00109 if ( pML->getValidityCheckCode()!=0 ) 00110 { setTestResult(TEST_FAILURE,"Wrong validity code"); 00111 return; 00112 } 00113 pML->setRawData(packet,offset); 00114 if ( pML->getValidityCheckCode()!=0 ) 00115 { setTestResult(TEST_FAILURE,"Wrong validity code"); 00116 return; 00117 } 00118 00119 // Execute TC and check correctness 00120 if ( pML->execute()!=ACTION_SUCCESS ) 00121 { setTestResult(TEST_FAILURE,"Wrong execution outcome"); 00122 return; 00123 } 00124 if ( (pa[os1]!=d1) || (pa[os1+1]!=d2) ) 00125 { setTestResult(TEST_FAILURE,"Wrong loaded data"); 00126 return; 00127 } 00128 00129 // Define the second load packet (three blocks with three data each) 00130 offset = sizeof(TD_PUSMemId)+sizeof(unsigned char*); 00131 os1 = 2; 00132 TD_PUSMemOffset os2 = 20; 00133 TD_PUSMemOffset os3 = 30; 00134 TD_PUSMemLength len = 3; 00135 d1 = 3; 00136 d2 = 4; 00137 TD_PUSMemData d3 = 5; 00138 nmb = 3; 00139 checkSum = 0; 00140 00141 memcpy(packet+offset,&nmb,sizeof(TD_PUSNumberMemBlocks)); 00142 offset += sizeof(TD_PUSNumberMemBlocks); 00143 memcpy(packet+offset,&os1,sizeof(TD_PUSMemLength)); 00144 offset += sizeof(TD_PUSMemLength); 00145 memcpy(packet+offset,&len,sizeof(TD_PUSMemLength)); 00146 offset += sizeof(TD_PUSMemLength); 00147 memcpy(packet+offset,&d1,sizeof(TD_PUSMemData)); 00148 offset += sizeof(TD_PUSMemData); 00149 memcpy(packet+offset,&d2,sizeof(TD_PUSMemData)); 00150 offset += sizeof(TD_PUSMemData); 00151 memcpy(packet+offset,&d3,sizeof(TD_PUSMemData)); 00152 offset += sizeof(TD_PUSMemData); 00153 memcpy(packet+offset,&checkSum,2); 00154 offset += sizeof(unsigned short); 00155 00156 d1 = d1*2; 00157 d2 = d2*2; 00158 d3 = d3*2; 00159 memcpy(packet+offset,&os2,sizeof(TD_PUSMemLength)); 00160 offset += sizeof(TD_PUSMemLength); 00161 memcpy(packet+offset,&len,sizeof(TD_PUSMemLength)); 00162 offset += sizeof(TD_PUSMemLength); 00163 memcpy(packet+offset,&d1,sizeof(TD_PUSMemData)); 00164 offset += sizeof(TD_PUSMemData); 00165 memcpy(packet+offset,&d2,sizeof(TD_PUSMemData)); 00166 offset += sizeof(TD_PUSMemData); 00167 memcpy(packet+offset,&d3,sizeof(TD_PUSMemData)); 00168 offset += sizeof(TD_PUSMemData); 00169 memcpy(packet+offset,&checkSum,2); 00170 offset += sizeof(unsigned short); 00171 00172 d1 = d1*3; 00173 d2 = d2*3; 00174 d3 = d3*3; 00175 memcpy(packet+offset,&os3,sizeof(TD_PUSMemLength)); 00176 offset += sizeof(TD_PUSMemLength); 00177 memcpy(packet+offset,&len,sizeof(TD_PUSMemLength)); 00178 offset += sizeof(TD_PUSMemLength); 00179 memcpy(packet+offset,&d1,sizeof(TD_PUSMemData)); 00180 offset += sizeof(TD_PUSMemData); 00181 memcpy(packet+offset,&d2,sizeof(TD_PUSMemData)); 00182 offset += sizeof(TD_PUSMemData); 00183 memcpy(packet+offset,&d3,sizeof(TD_PUSMemData)); 00184 offset += sizeof(TD_PUSMemData); 00185 memcpy(packet+offset,&checkSum,2); 00186 offset += sizeof(unsigned short); 00187 00188 00189 // Load packet and check validity 00190 if ( pML->getValidityCheckCode()!=0 ) 00191 { setTestResult(TEST_FAILURE,"Wrong validity code"); 00192 return; 00193 } 00194 pML->setRawData(packet,offset); 00195 if ( pML->getValidityCheckCode()!=0 ) 00196 { setTestResult(TEST_FAILURE,"Wrong validity code"); 00197 return; 00198 } 00199 00200 // Execute TC and check correctness 00201 if ( pML->execute()!=ACTION_SUCCESS ) 00202 { setTestResult(TEST_FAILURE,"Wrong execution outcome"); 00203 return; 00204 } 00205 if ( (pa[os1]!=d1/6) || (pa[os1+1]!=d2/6) || (pa[os1+2]!=d3/6) ) 00206 { setTestResult(TEST_FAILURE,"Wrong loaded data"); 00207 return; 00208 } 00209 if ( (pa[os2]!=d1/3) || (pa[os2+1]!=d2/3) || (pa[os2+2]!=d3/3) ) 00210 { setTestResult(TEST_FAILURE,"Wrong loaded data"); 00211 return; 00212 } 00213 if ( (pa[os3]!=d1) || (pa[os3+1]!=d2) || (pa[os3+2]!=d3) ) 00214 { setTestResult(TEST_FAILURE,"Wrong loaded data"); 00215 return; 00216 } 00217 00218 // Define the third load packet (four blocks) 00219 offset = sizeof(TD_PUSMemId)+sizeof(unsigned char*); 00220 nmb = 4; 00221 memcpy(packet+offset,&nmb,sizeof(TD_PUSNumberMemBlocks)); 00222 offset += sizeof(TD_PUSNumberMemBlocks); 00223 offset += 10; // dummy: just to simulate presence of memory load data 00224 00225 // Load packet and check validity 00226 pML->setRawData(packet,offset); 00227 if ( pML->getValidityCheckCode()!=VC_TOO_MANY_MEM_BLOCK ) 00228 { setTestResult(TEST_FAILURE,"Wrong validity code"); 00229 return; 00230 } 00231 00232 // Define the fourth load packet (one block with 2 data, one block with nine data) 00233 offset = sizeof(TD_PUSMemId)+sizeof(unsigned char*); 00234 os1 = 2; 00235 os2 = 10; 00236 len1 = 2; 00237 TD_PUSMemLength len2 = 9; 00238 nmb = 2; 00239 checkSum = 0; 00240 00241 d1 = 0; 00242 d2 = 0; 00243 memcpy(packet+offset,&nmb,sizeof(TD_PUSNumberMemBlocks)); 00244 offset += sizeof(TD_PUSNumberMemBlocks); 00245 memcpy(packet+offset,&os1,sizeof(TD_PUSMemLength)); 00246 offset += sizeof(TD_PUSMemLength); 00247 memcpy(packet+offset,&len1,sizeof(TD_PUSMemLength)); 00248 offset += sizeof(TD_PUSMemLength); 00249 memcpy(packet+offset,&d1,sizeof(TD_PUSMemData)); 00250 offset += sizeof(TD_PUSMemData); 00251 memcpy(packet+offset,&d2,sizeof(TD_PUSMemData)); 00252 offset += sizeof(TD_PUSMemData); 00253 memcpy(packet+offset,&d3,sizeof(TD_PUSMemData)); 00254 offset += sizeof(TD_PUSMemData); 00255 memcpy(packet+offset,&checkSum,2); 00256 offset += sizeof(unsigned short); 00257 memcpy(packet+offset,&os2,sizeof(TD_PUSMemLength)); 00258 offset += sizeof(TD_PUSMemLength); 00259 memcpy(packet+offset,&len2,sizeof(TD_PUSMemLength)); 00260 offset += sizeof(TD_PUSMemLength); 00261 00262 // Load packet and check validity 00263 pML->setRawData(packet,offset); 00264 if ( pML->getValidityCheckCode()!=VC_TOO_MANY_MEM_DATA ) 00265 { setTestResult(TEST_FAILURE,"Wrong validity code"); 00266 return; 00267 } 00268 00269 // Load packet with invalid number of bytes and check validity 00270 pML->setRawData(packet,1); 00271 if ( pML->getValidityCheckCode()!=VC_INCONSISTENT_RAW_DATA ) 00272 { setTestResult(TEST_FAILURE,"Wrong validity code"); 00273 return; 00274 } 00275 00276 // Define the first load packet again (one block with two data) 00277 offset = sizeof(TD_PUSMemId)+sizeof(unsigned char*); 00278 os1 = 2; 00279 len1 = 2; 00280 d1 = 1; 00281 d2 = 2; 00282 nmb = 1; 00283 checkSum = 0; 00284 00285 memcpy(packet+offset,&nmb,sizeof(TD_PUSNumberMemBlocks)); 00286 offset += sizeof(TD_PUSNumberMemBlocks); 00287 memcpy(packet+offset,&os1,sizeof(TD_PUSMemLength)); 00288 offset += sizeof(TD_PUSMemLength); 00289 memcpy(packet+offset,&len1,sizeof(TD_PUSMemLength)); 00290 offset += sizeof(TD_PUSMemLength); 00291 memcpy(packet+offset,&d1,sizeof(TD_PUSMemData)); 00292 offset += sizeof(TD_PUSMemData); 00293 memcpy(packet+offset,&d2,sizeof(TD_PUSMemData)); 00294 offset += sizeof(TD_PUSMemData); 00295 memcpy(packet+offset,&checkSum,2); 00296 offset += sizeof(unsigned short); 00297 00298 // Load packet with wrong number of bytes and check validity 00299 pML->setRawData(packet,offset+1); 00300 if ( pML->getValidityCheckCode()!=VC_INCONSISTENT_RAW_DATA ) 00301 { setTestResult(TEST_FAILURE,"Wrong validity code"); 00302 return; 00303 } 00304 00305 00306 setTestResult(TEST_SUCCESS,"Test Successful"); 00307 return; 00308 }