OBS Framework: TestCasePUSMemoryLoadAbsolute

00001 // 00002 // Copyright 2004 P&P Software GmbH - All Rights Reserved 00003 // 00004 // TestCasePUSMemoryLoadAbsolute_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_PUSMemoryLoadAbsolute.h" 00015 #include "../Utilities/TestCaseWithEvtCheck.h" 00016 #include "TestCasePUSMemoryLoadAbsolute_1.h" 00017 00018 #include <assert.h> 00019 #include <string.h> 00020 00021 TestCasePUSMemoryLoadAbsolute_1::TestCasePUSMemoryLoadAbsolute_1(void) : 00022 TestCaseWithEvtCheck(ID_PUSMEMORYLOADABSOLUTE*10+1,"TestCasePUSMemoryLoadAbsolute_1") { 00023 return; 00024 } 00025 00026 void TestCasePUSMemoryLoadAbsolute_1::runTestCase(void) { 00027 00028 DC_PUSMemoryLoadAbsolute* pML = new DC_PUSMemoryLoadAbsolute(); 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_PUSMEMORYLOADABSOLUTE) ) 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 memcpy(packet+offset,&id,sizeof(TD_PUSMemId)); 00082 offset += sizeof(TD_PUSMemId); 00083 00084 // Define the first load packet (one block with two data) 00085 unsigned int os1 = 2; 00086 TD_PUSMemData* sa1 = pa+os1; 00087 TD_PUSMemLength len1 = 2; 00088 TD_PUSMemData d1 = 1; 00089 TD_PUSMemData d2 = 2; 00090 TD_PUSNumberMemBlocks nmb = 1; 00091 unsigned short checkSum = 0; 00092 00093 memcpy(packet+offset,&nmb,sizeof(TD_PUSNumberMemBlocks)); 00094 offset += sizeof(TD_PUSNumberMemBlocks); 00095 memcpy(packet+offset,&sa1,sizeof(TD_PUSMemData*)); 00096 offset += sizeof(TD_PUSMemData*); 00097 memcpy(packet+offset,&len1,sizeof(TD_PUSMemLength)); 00098 offset += sizeof(TD_PUSMemLength); 00099 memcpy(packet+offset,&d1,sizeof(TD_PUSMemData)); 00100 offset += sizeof(TD_PUSMemData); 00101 memcpy(packet+offset,&d2,sizeof(TD_PUSMemData)); 00102 offset += sizeof(TD_PUSMemData); 00103 memcpy(packet+offset,&checkSum,2); 00104 offset += sizeof(unsigned short); 00105 00106 // Load packet and check validity 00107 if ( pML->getValidityCheckCode()!=0 ) 00108 { setTestResult(TEST_FAILURE,"Wrong validity code"); 00109 return; 00110 } 00111 pML->setRawData(packet,offset); 00112 if ( pML->getValidityCheckCode()!=0 ) 00113 { setTestResult(TEST_FAILURE,"Wrong validity code"); 00114 return; 00115 } 00116 00117 // Execute TC and check correctness 00118 if ( pML->execute()!=ACTION_SUCCESS ) 00119 { setTestResult(TEST_FAILURE,"Wrong execution outcome"); 00120 return; 00121 } 00122 if ( (pa[os1]!=d1) || (pa[os1+1]!=d2) ) 00123 { setTestResult(TEST_FAILURE,"Wrong loaded data"); 00124 return; 00125 } 00126 00127 // Define the second load packet (three blocks with three data each) 00128 offset = sizeof(TD_PUSMemId); 00129 os1 = 2; 00130 sa1 = pa+os1; 00131 unsigned int os2 = 20; 00132 TD_PUSMemData* sa2 = pa+os2; 00133 unsigned int os3 = 30; 00134 TD_PUSMemData* sa3 = pa+os3; 00135 TD_PUSMemLength len = 3; 00136 d1 = 3; 00137 d2 = 4; 00138 TD_PUSMemData d3 = 5; 00139 nmb = 3; 00140 checkSum = 0; 00141 00142 memcpy(packet+offset,&nmb,sizeof(TD_PUSNumberMemBlocks)); 00143 offset += sizeof(TD_PUSNumberMemBlocks); 00144 memcpy(packet+offset,&sa1,sizeof(TD_PUSMemData*)); 00145 offset += sizeof(TD_PUSMemData*); 00146 memcpy(packet+offset,&len,sizeof(TD_PUSMemLength)); 00147 offset += sizeof(TD_PUSMemLength); 00148 memcpy(packet+offset,&d1,sizeof(TD_PUSMemData)); 00149 offset += sizeof(TD_PUSMemData); 00150 memcpy(packet+offset,&d2,sizeof(TD_PUSMemData)); 00151 offset += sizeof(TD_PUSMemData); 00152 memcpy(packet+offset,&d3,sizeof(TD_PUSMemData)); 00153 offset += sizeof(TD_PUSMemData); 00154 memcpy(packet+offset,&checkSum,2); 00155 offset += sizeof(unsigned short); 00156 00157 d1 = d1*2; 00158 d2 = d2*2; 00159 d3 = d3*2; 00160 memcpy(packet+offset,&sa2,sizeof(TD_PUSMemData*)); 00161 offset += sizeof(TD_PUSMemData*); 00162 memcpy(packet+offset,&len,sizeof(TD_PUSMemLength)); 00163 offset += sizeof(TD_PUSMemLength); 00164 memcpy(packet+offset,&d1,sizeof(TD_PUSMemData)); 00165 offset += sizeof(TD_PUSMemData); 00166 memcpy(packet+offset,&d2,sizeof(TD_PUSMemData)); 00167 offset += sizeof(TD_PUSMemData); 00168 memcpy(packet+offset,&d3,sizeof(TD_PUSMemData)); 00169 offset += sizeof(TD_PUSMemData); 00170 memcpy(packet+offset,&checkSum,2); 00171 offset += sizeof(unsigned short); 00172 00173 d1 = d1*3; 00174 d2 = d2*3; 00175 d3 = d3*3; 00176 memcpy(packet+offset,&sa3,sizeof(TD_PUSMemData*)); 00177 offset += sizeof(TD_PUSMemData*); 00178 memcpy(packet+offset,&len,sizeof(TD_PUSMemLength)); 00179 offset += sizeof(TD_PUSMemLength); 00180 memcpy(packet+offset,&d1,sizeof(TD_PUSMemData)); 00181 offset += sizeof(TD_PUSMemData); 00182 memcpy(packet+offset,&d2,sizeof(TD_PUSMemData)); 00183 offset += sizeof(TD_PUSMemData); 00184 memcpy(packet+offset,&d3,sizeof(TD_PUSMemData)); 00185 offset += sizeof(TD_PUSMemData); 00186 memcpy(packet+offset,&checkSum,2); 00187 offset += sizeof(unsigned short); 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); 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); 00234 os1 = 2; 00235 sa1 = pa+os1; 00236 os2 = 10; 00237 sa2 = pa+os2; 00238 len1 = 2; 00239 TD_PUSMemLength len2 = 9; 00240 nmb = 2; 00241 checkSum = 0; 00242 00243 d1 = 0; 00244 d2 = 0; 00245 memcpy(packet+offset,&nmb,sizeof(TD_PUSNumberMemBlocks)); 00246 offset += sizeof(TD_PUSNumberMemBlocks); 00247 memcpy(packet+offset,&sa1,sizeof(TD_PUSMemData*)); 00248 offset += sizeof(TD_PUSMemData*); 00249 memcpy(packet+offset,&len1,sizeof(TD_PUSMemLength)); 00250 offset += sizeof(TD_PUSMemLength); 00251 memcpy(packet+offset,&d1,sizeof(TD_PUSMemData)); 00252 offset += sizeof(TD_PUSMemData); 00253 memcpy(packet+offset,&d2,sizeof(TD_PUSMemData)); 00254 offset += sizeof(TD_PUSMemData); 00255 memcpy(packet+offset,&checkSum,2); 00256 offset += sizeof(unsigned short); 00257 memcpy(packet+offset,&sa2,sizeof(TD_PUSMemData*)); 00258 offset += sizeof(TD_PUSMemData*); 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); 00278 os1 = 2; 00279 sa1 = pa+os1; 00280 len1 = 2; 00281 d1 = 1; 00282 d2 = 2; 00283 nmb = 1; 00284 checkSum = 0; 00285 00286 memcpy(packet+offset,&nmb,sizeof(TD_PUSNumberMemBlocks)); 00287 offset += sizeof(TD_PUSNumberMemBlocks); 00288 memcpy(packet+offset,&sa1,sizeof(TD_PUSMemData*)); 00289 offset += sizeof(TD_PUSMemData*); 00290 memcpy(packet+offset,&len1,sizeof(TD_PUSMemLength)); 00291 offset += sizeof(TD_PUSMemLength); 00292 memcpy(packet+offset,&d1,sizeof(TD_PUSMemData)); 00293 offset += sizeof(TD_PUSMemData); 00294 memcpy(packet+offset,&d2,sizeof(TD_PUSMemData)); 00295 offset += sizeof(TD_PUSMemData); 00296 memcpy(packet+offset,&checkSum,2); 00297 offset += sizeof(unsigned short); 00298 00299 // Load packet with wrong number of bytes and check validity 00300 pML->setRawData(packet,offset+1); 00301 if ( pML->getValidityCheckCode()!=VC_INCONSISTENT_RAW_DATA ) 00302 { setTestResult(TEST_FAILURE,"Wrong validity code"); 00303 return; 00304 } 00305 00306 setTestResult(TEST_SUCCESS,"Test Successful"); 00307 return; 00308 }