general test macro for RawReaders; check for AliRawReaderMemory multiple equipment...
[u/mrichter/AliRoot.git] / HLT / rec / test / testAliRawReader.C
1 // $Id$
2
3 /**************************************************************************
4  * This file is property of and copyright by the ALICE HLT Project        * 
5  * ALICE Experiment at CERN, All rights reserved.                         *
6  *                                                                        *
7  * Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *
8  *                  for The ALICE HLT Project.                            *
9  *                                                                        *
10  * Permission to use, copy, modify and distribute this software and its   *
11  * documentation strictly for non-commercial purposes is hereby granted   *
12  * without fee, provided that the above copyright notice appears in all   *
13  * copies and that both the copyright notice and this permission notice   *
14  * appear in the supporting documentation. The authors make no claims     *
15  * about the suitability of this software for any purpose. It is          *
16  * provided "as is" without express or implied warranty.                  *
17  **************************************************************************/
18
19 /** @file   testAliRawReaderMemory.C
20     @author Matthias Richter
21     @date   
22     @brief  Test macro/program for the AliRawReaderMemory
23  */
24
25 #ifndef __CINT__
26 #include "TFile.h"
27 #include "TDatime.h"
28 #include "TRandom.h"
29 #include "TArrayI.h"
30 #include "TArrayC.h"
31 #include "TSystem.h"
32 #include "AliRawDataHeader.h"
33 #include "AliRawReaderFile.h"
34 #include "AliRawReaderMemory.h"
35 #include "AliRawHLTManager.h"
36 #include "AliDAQ.h"
37 #include "AliHLTSystem.h"
38 #include <ostream>
39 #endif //__CINT__
40
41 #ifndef __CINT__
42 const int sizeofAliRawDataHeader=sizeof(AliRawDataHeader);
43 #else
44 // cint does not handle sizeof correctly
45 const int sizeofAliRawDataHeader=32;
46 #endif
47
48 /////////////////////////////////////////////////////////////////
49 /////////////////////////////////////////////////////////////////
50 /////////////////////////////////////////////////////////////////
51 //
52 // configuration of the test program
53 //
54 const char* tmpdir="/tmp/testAliRawReaderMemory";
55 bool gbVerbose=false;
56
57 /////////////////////////////////////////////////////////////////
58 /////////////////////////////////////////////////////////////////
59 /////////////////////////////////////////////////////////////////
60 int GetRandom(int min, int max);
61 int FillRandomDDL(TArrayC& target);
62 int WriteDDL(TArrayC& ddl, int ddlid);
63 int CheckRawReader(AliRawReader* pRawReader, TArrayC* ddls, int* ddlids, int nofDDLs);
64 int CheckRawReaderMemory(TArrayC* ddlArray, int* ddlidArray, int nofDDLs);
65 int CheckRawReaderHLT(AliRawReader* pParent, TArrayC* ddls, int* ddlids, int nofDDLs);
66 int CheckDDL_ReadNext(AliRawReader* pRawReader, TArrayC& ddl, int ddlid);
67 int CheckDDL_ReadNextData(AliRawReader* pRawReader, TArrayC& ddl, int ddlid);
68 int CheckDDL_ReadNextChar(AliRawReader* pRawReader, TArrayC& ddl, int ddlid);
69 int CheckDDL_ReadMixed(AliRawReader* pRawReader, TArrayC& ddl, int ddlid);
70
71 int testAliRawReaderFile()
72 {
73   int iResult=0;
74
75   // cleanup old raw folders
76   TString command;
77   command.Form("rm -r %s 2> /dev/null", tmpdir);
78   gSystem->Exec(command);
79   gSystem->mkdir(tmpdir);
80
81   // variable number of DDLs
82   int nofDDLs=0;
83   do {
84     nofDDLs=GetRandom(2,10);
85   } while (nofDDLs<2);
86
87   // allocate buffers
88   TArrayC* ddlArray=new TArrayC[nofDDLs];
89   int* ddlidArray=new int[nofDDLs];
90
91   // create DDL ids and content
92   int i=0;
93   do {
94     int detectorId=GetRandom(0,5);
95     ddlidArray[i]=GetRandom(0,AliDAQ::NumberOfDdls(detectorId)-1)+AliDAQ::DdlIDOffset(detectorId);
96     
97     // check for duplicate id
98     int j=0;
99     for (; j<i; j++)
100       if (ddlidArray[i]==ddlidArray[j]) break;
101     
102     if (j!=i) continue; // try once again
103
104     FillRandomDDL(ddlArray[i]);
105     if (gbVerbose) cout << "simulating data for ddl " << ddlidArray[i] << " size " << ddlArray[i].GetSize() << endl;
106     WriteDDL(ddlArray[i], ddlidArray[i]);
107   } while (++i<nofDDLs);
108
109   if (gbVerbose) cout << "checking AliRawReaderFile ..." << endl;
110   TString rawdir=tmpdir;
111   if (!rawdir.EndsWith("/")) rawdir+="/";
112   AliRawReader* pRawReader=AliRawReader::Create(rawdir);
113   if (!pRawReader) {
114     cerr << "can not create RawReaderFile" << endl;
115     return -1;
116   }
117
118   if (!pRawReader->NextEvent()) {
119     cerr << "error: getting event from RawReaderFile failed" << endl;
120     return -1;
121   }
122
123   if ((iResult=CheckRawReader(pRawReader, ddlArray, ddlidArray, nofDDLs))<0) {
124     return iResult;
125   }
126
127   /////////////////////////////////////////////////////////////////////////////////////////
128   // check AliRawReaderMemory
129   if ((iResult=CheckRawReaderMemory(ddlArray, ddlidArray, nofDDLs))<0) {
130     return iResult;
131   }
132
133   /////////////////////////////////////////////////////////////////////////////////////////
134   if ((iResult=CheckRawReaderHLT(pRawReader, ddlArray, ddlidArray, nofDDLs))<0) {
135     return iResult;
136   }
137
138   delete pRawReader;
139
140   gSystem->Exec(command);
141   return 0;
142 }
143
144 Bool_t seedSet=kFALSE;
145
146 /**
147  * Get a random number in the given range.
148  */
149 int GetRandom(int min, int max)
150 {
151   if (max-min<2) return min;
152   static TRandom rand;
153   if (!seedSet) {
154     TDatime dt;
155     rand.SetSeed(dt.Get());
156     seedSet=kTRUE;
157   }
158   return rand.Integer(max-min);
159 }
160
161 /**
162  * Fill the array with random DDL data.
163  * The function leaves space for the CDH, sets the size member of the
164  * CDH either to the buffer size or 0xffffffff by a random decision.
165  */
166 int FillRandomDDL(TArrayC& target)
167 {
168   int size=0;
169   do size=GetRandom(100, 10000);
170   while (size<100);
171
172   target.Set(size);
173
174   // decide randomly whether to set size of 0xffffffff
175   if (GetRandom(0,40)%4) {
176     *((Int_t*)target.GetArray())=size;
177   } else {
178     *((UInt_t*)target.GetArray())=0xffffffff;    
179   }
180   for (int i=sizeofAliRawDataHeader; i<size; i++) {
181     Int_t data=GetRandom(0,255);
182     target.AddAt((UChar_t)data, i);
183   }
184   return size;
185 }
186
187 /**
188  * Write the simulated DDL data to file
189  * Creates the filename from the DDL naming convention using the
190  * AliDAQ conventions. The file is written to folder tmpdir/raw0
191  * whereas tmpdir can be adjusted above. 
192  */
193 int WriteDDL(TArrayC& ddl, int ddlid)
194 {
195   Int_t dummy=0;
196   TString filename;
197   filename.Form("%s/raw0", tmpdir);
198   gSystem->mkdir(filename);
199   filename.Form("%s/%s_%d.ddl", filename.Data(), AliDAQ::DetectorNameFromDdlID(ddlid, dummy), ddlid);
200   FILE* fp=fopen(filename.Data(), "w");
201   if (!fp) return -1;
202
203   fwrite(ddl.GetArray(), 1, ddl.GetSize(), fp);
204   fclose(fp);
205
206   return 0;
207 }
208
209 /**
210  * Check the AliRawReaderMemory
211  *
212  * Check consists of 3 steps:
213  * - check with one ddl per cycle: SetMemory/SetEquipmentID method
214  * - check with multiple buffers: AddBuffer method
215  * - check with one ddl as constructor parameter and AddBuffer for the
216  *   subsequent ddls
217  *
218  * @return -1 if check failed
219  */
220 int CheckRawReaderMemory(TArrayC* ddlArray, int* ddlidArray, int nofDDLs)
221 {
222   int iResult=0;
223   int i=0;
224   /////////////////////////////////////////////////////////////////////////////////////////
225   if (gbVerbose) cout << "checking AliRawReaderMemory ..." << endl;
226   AliRawReaderMemory* pRawReaderMemory=new AliRawReaderMemory;
227   for (i=0; i<nofDDLs; i++) {
228     if (!pRawReaderMemory->SetMemory((UChar_t*)ddlArray[i].GetArray(), ddlArray[i].GetSize())) {
229       cerr << "AliRawReaderMemory::SetMemory failed for block " << i << endl;
230       return -1;
231     }
232     pRawReaderMemory->SetEquipmentID(ddlidArray[i]);
233     if (i==0 && !pRawReaderMemory->NextEvent()) {
234       cerr << "error: getting event from RawReaderMemory failed" << endl;
235       return -1;
236     }
237
238     if ((iResult=CheckRawReader(pRawReaderMemory, ddlArray+i, ddlidArray+i, 1))<0) {
239       return iResult;
240     }
241   }
242   if (pRawReaderMemory->NextEvent()) {
243     cerr << "error: RawReaderMemory::NextEvent returns true, while no more events should be there" << endl;
244     return -1;
245   }
246
247 #ifndef HAVE_NOT_ALIRAWREADERMEMORY_ADDBUFFER
248   /////////////////////////////////////////////////////////////////////////////////////////
249   if (gbVerbose) cout << "checking AliRawReaderMemory with multiple buffers ..." << endl;
250   pRawReaderMemory->RewindEvents();
251   pRawReaderMemory->ClearBuffers();
252   for (i=0; i<nofDDLs; i++) {
253     if (!pRawReaderMemory->AddBuffer((UChar_t*)ddlArray[i].GetArray(), ddlArray[i].GetSize(), ddlidArray[i])) {
254       cerr << "AliRawReaderMemory::AddBuffer failed for block " << i << endl;
255       return -1;
256     }
257   }
258   if (!pRawReaderMemory->NextEvent()) {
259     cerr << "error: getting event from RawReaderMemory failed" << endl;
260     return -1;
261   }
262
263   if ((iResult=CheckRawReader(pRawReaderMemory, ddlArray, ddlidArray, nofDDLs))<0) {
264     return iResult;
265   }
266   
267   if (pRawReaderMemory->NextEvent()) {
268     cerr << "error: RawReaderMemory::NextEvent returns true, while no more events should be there" << endl;
269     return -1;
270   }
271   delete pRawReaderMemory;
272   pRawReaderMemory=NULL;
273
274   /////////////////////////////////////////////////////////////////////////////////////////
275   if (gbVerbose) cout << "checking AliRawReaderMemory constructor ..." << endl;
276   for (i=0; i<nofDDLs; i++) {
277     if (!pRawReaderMemory) {
278       pRawReaderMemory=new AliRawReaderMemory((UChar_t*)ddlArray[i].GetArray(), ddlArray[i].GetSize());
279       if (pRawReaderMemory) {
280         pRawReaderMemory->SetEquipmentID(ddlidArray[i]);
281       } else {
282         cerr << "can not create AliRawReaderMemory with parameters" << endl;
283         return -1;
284       }
285     }else if (!pRawReaderMemory->AddBuffer((UChar_t*)ddlArray[i].GetArray(), ddlArray[i].GetSize(), ddlidArray[i])) {
286       cerr << "AliRawReaderMemory::AddBuffer failed for block " << i << endl;
287       return -1;
288     }
289   }
290   if (!pRawReaderMemory->NextEvent()) {
291     cerr << "error: getting event from RawReaderMemory failed" << endl;
292     return -1;
293   }
294
295   if ((iResult=CheckRawReader(pRawReaderMemory, ddlArray, ddlidArray, nofDDLs))<0) {
296     return iResult;
297   }
298   
299   if (pRawReaderMemory->NextEvent()) {
300     cerr << "error: RawReaderMemory::NextEvent returns true, while no more events should be there" << endl;
301     return -1;
302   }
303 #endif //HAVE_NOT_ALIRAWREADERMEMORY_ADDBUFFER
304
305   delete pRawReaderMemory;
306   pRawReaderMemory=NULL;
307
308   return iResult;
309 }
310
311 /**
312  * Check the AliRawReaderHLT
313  *
314  * Open the AliRawReaderHLT from the parent reader without any HLTOUT
315  * options, i.e. all requests are just forwarded.
316  *
317  * @return -1 if check failed
318  */
319 int CheckRawReaderHLT(AliRawReader* pParent, TArrayC* ddls, int* ddlids, int nofDDLs)
320 {
321   if (gbVerbose) cout << "checking AliRawReaderHLT ..." << endl;
322
323   int iResult=0;
324   pParent->RewindEvents();
325   pParent->Reset();
326   TString arg;
327 //   Int_t dummy=0;
328 //   for (i=0; i<nofDDLs; i++) {
329 //     if (!arg.Contains(AliDAQ::DetectorNameFromDdlID(ddlidArray[i], dummy))) {
330 //       arg+=" "; arg+=AliDAQ::DetectorNameFromDdlID(ddlidArray[i], dummy);
331 //     }
332 //   }
333
334   AliRawReader* pRawReaderHLT=AliRawHLTManager::CreateRawReaderHLT(pParent, arg.Data());
335   if (!pRawReaderHLT) {
336     cerr << "can not create HLT RawReader" << endl;
337     return -1;
338   }
339
340   if (!pRawReaderHLT->NextEvent()) {
341     cerr << "error: getting event from HLT RawReader failed" << endl;
342     return -1;
343   }
344
345   if ((iResult=CheckRawReader(pRawReaderHLT, ddls, ddlids, nofDDLs))<0) {
346     return iResult;
347   }
348
349   delete pRawReaderHLT;
350   return iResult;
351 }
352
353 /**
354  * Check a RawReader, compare with the corresponding simulated data.
355  * The corresponding simulated data is searched from the array via the current
356  * equipment id. The check consists of 4 steps:
357  * - data comparison by ReadNext
358  * - data comparison by ReadNextData
359  * - data comparison by ReadNextChar
360  * - data comparison by mixed reading: ReadNextInt/Short/Char/Data
361  * 
362  * @return -1 if failed
363  */
364 int CheckRawReader(AliRawReader* pRawReader, TArrayC* ddls, int* ddlids, int nofDDLs)
365 {
366   int iResult=0;
367   int count=0;
368   // 1st pass: check AliRawReader::ReadNext()
369   while (pRawReader->ReadHeader()) {
370     int id=pRawReader->GetEquipmentId();
371     int i=0;
372     for (i=0; i<nofDDLs; i++) {
373       if (ddlids[i]==id) break;
374     }
375     if (i==nofDDLs) {
376       cerr << "error: can not find ddl id " << id << endl;
377       return -1;
378     }
379
380     if ((iResult=CheckDDL_ReadNext(pRawReader, ddls[i], ddlids[i]))<0) return iResult;
381     count++;
382   }
383   if (count<nofDDLs) {
384     cerr << "less than the available blocks found from RawReader" << endl;
385     return -1;
386   }
387   
388   // 2nd pass: check AliRawReader::ReadNextData()
389   count=0;
390   pRawReader->Reset();
391   while (pRawReader->ReadHeader()) {
392     int id=pRawReader->GetEquipmentId();
393     int i=0;
394     for (i=0; i<nofDDLs; i++) {
395       if (ddlids[i]==id) break;
396     }
397     if (i==nofDDLs) {
398       cerr << "error: can not find ddl id " << id << endl;
399       return -1;
400     }
401
402     if ((iResult=CheckDDL_ReadNextData(pRawReader, ddls[i], ddlids[i]))<0) return iResult;
403     count++;
404   }
405   if (count<nofDDLs) {
406     cerr << "less than the available blocks found from RawReader" << endl;
407     return -1;
408   }
409
410   // 3rd pass: check AliRawReader::ReadNextData()
411   count=0;
412   pRawReader->Reset();
413   while (pRawReader->ReadHeader()) {
414     int i=0;
415     do {
416       int id=pRawReader->GetEquipmentId();
417       for (i=0; i<nofDDLs; i++) {
418         if (ddlids[i]==id) break;
419       }
420       if (i==nofDDLs) {
421         cerr << "error: can not find ddl id " << id << endl;
422         return -1;
423       }
424       count++;
425
426       if ((iResult=CheckDDL_ReadNextChar(pRawReader, ddls[i], ddlids[i]))<0) return iResult;
427     }
428     // note: the ReadHeader is hidden in the ReadNextChar
429     while (iResult!=ddlids[i]);
430   }
431   if (count<nofDDLs) {
432     cerr << "less than the available blocks found from RawReader" << endl;
433     return -1;
434   }
435
436   // 4th pass: check mixed AliRawReader::ReadNext*()
437   count=0;
438   pRawReader->Reset();
439   while (pRawReader->ReadHeader()) {
440     int id=pRawReader->GetEquipmentId();
441     int i=0;
442     for (i=0; i<nofDDLs; i++) {
443       if (ddlids[i]==id) break;
444     }
445     if (i==nofDDLs) {
446       cerr << "error: can not find ddl id " << id << endl;
447       return -1;
448     }
449
450     if ((iResult=CheckDDL_ReadMixed(pRawReader, ddls[i], ddlids[i]))<0) return iResult;
451     count++;
452   }
453   if (count<nofDDLs) {
454     cerr << "less than the available blocks found from RawReader" << endl;
455     return -1;
456   }
457
458   return iResult;
459 }
460
461 /**
462  * Check RawReaders ReadNext function and compare data with simulated data
463  * of the provided buffer.
464  */
465 int CheckDDL_ReadNext(AliRawReader* pRawReader, TArrayC& ddl, int ddlid)
466 {
467   int dataSize=pRawReader->GetDataSize();
468   if (ddl.GetSize()!=dataSize+sizeofAliRawDataHeader) {
469     cerr << "error: size mismatch in ddl " << ddlid << ": " << dataSize+sizeofAliRawDataHeader << " required " << ddl.GetSize() << endl;
470     return -1;
471   }
472   TArrayC buffer(dataSize);
473   UChar_t* pTgt=(UChar_t*)buffer.GetArray();
474   
475   if (!pRawReader->ReadNext(pTgt, buffer.GetSize())) {
476     cerr << "error: reading " << buffer.GetSize() << " byte(s) from ReadNext (ddl " << ddlid << ")" << endl;
477     return -1;
478   }
479
480   if (ddlid!=pRawReader->GetEquipmentId()) {
481     cerr << "error: ReadMixed ddl id missmatch after ReadNext: reqired id " << ddlid << " got " << pRawReader->GetEquipmentId() << endl;
482     return -1;
483   }
484
485   TString sizeStr;
486   if (*((UInt_t*)ddl.GetArray())==0xffffffff) {
487     sizeStr=" (0xffffffff)";
488   } else {
489     sizeStr.Form(" (%d)", ddl.GetSize());
490   }
491   if (gbVerbose) cout << "verify ReadNext: ddl " << ddlid << sizeStr << endl;
492   if (memcmp(ddl.GetArray()+sizeofAliRawDataHeader, buffer.GetArray(), buffer.GetSize())!=0) {
493     cerr << "error: verification of ddl " << ddlid << ")" << endl;
494     return -1;
495   }
496   return 0;
497 }
498
499 /**
500  * Check RawReaders ReadNextData function and compare data with simulated data
501  * of the provided buffer.
502  */
503 int CheckDDL_ReadNextData(AliRawReader* pRawReader, TArrayC& ddl, int ddlid)
504 {
505   int dataSize=pRawReader->GetDataSize();
506   if (ddl.GetSize()!=dataSize+sizeofAliRawDataHeader) {
507     cerr << "error: size mismatch in ddl " << ddlid << ": " << dataSize+sizeofAliRawDataHeader << " required " << ddl.GetSize() << endl;
508     return -1;
509   }
510
511   UChar_t* pTgt=NULL;  
512   if (!pRawReader->ReadNextData(pTgt) || pTgt==NULL) {
513     cerr << "error: reading " << dataSize << " byte(s) from ReadNextData (ddl " << ddlid << ")" << endl;
514     return -1;
515   }
516
517   if (gbVerbose) cout << "verify ReadNextData: ddl " << ddlid << endl;
518   if (memcmp(ddl.GetArray()+sizeofAliRawDataHeader, pTgt, dataSize)!=0) {
519     cerr << "error: verification of ddl " << ddlid << endl;
520     return -1;
521   }
522   return 0;
523 }
524
525 /**
526  * Check RawReaders ReadNextChar function and compare data with simulated data
527  * of the provided buffer.
528  */
529 int CheckDDL_ReadNextChar(AliRawReader* pRawReader, TArrayC& ddl, int ddlid)
530 {
531   int iResult=ddlid;
532   int dataSize=pRawReader->GetDataSize();
533   if (ddl.GetSize()!=dataSize+sizeofAliRawDataHeader) {
534     cerr << "error: size mismatch in ddl " << ddlid << ": " << dataSize+sizeofAliRawDataHeader << " required " << ddl.GetSize() << endl;
535     return -1;
536   }
537
538   if (gbVerbose) cout << "verify ReadNextChar: ddl " << ddlid << endl;
539   static int offset=0;
540   int i=sizeofAliRawDataHeader+offset;
541   UChar_t data=0;
542   Bool_t haveData=kFALSE;
543   for (; (haveData=pRawReader->ReadNextChar(data)) && i<ddl.GetSize(); i++) {
544     if (data!=(UChar_t)ddl.At(i)) {
545       cerr << "error: at position " << i << " of ddl " << ddlid << ": read " << (UShort_t)data << " required " << (UShort_t)(UChar_t)ddl.At(i) << endl;
546       return -1;
547     }
548   }
549
550   if (i<ddl.GetSize()) {
551     cerr << "error: reading data of ddl " << ddlid << ": " << i << " of " << ddl.GetSize() << endl;
552     return -1;
553   }
554   if (pRawReader->GetEquipmentId()>=0 && ddlid!=pRawReader->GetEquipmentId()) {
555     //cerr << "error: ddl id missmatch, expecting " << ddlid << " got " << pRawReader->GetEquipmentId() << endl;
556     // thats not an error condition, RawReader just changes silently to the next DDL
557     iResult=pRawReader->GetEquipmentId();
558     offset=1;
559   } else {
560     offset=0;
561   }
562   if (haveData && iResult==ddlid) {
563     cerr << "error: size missmatch in ddl " << ddlid << ": still data available after " << ddl.GetSize() << " byte(s)"<< endl;
564     return -1;
565   }
566   return iResult;
567 }
568
569 /**
570  * Check RawReaders ReadNextInt/Short/Char/Data functions and compare data with
571  * simulated data of the provided buffer.
572  */
573 int CheckDDL_ReadMixed(AliRawReader* pRawReader, TArrayC& ddl, int ddlid)
574 {
575   int dataSize=pRawReader->GetDataSize();
576   if (ddl.GetSize()!=dataSize+sizeofAliRawDataHeader) {
577     cerr << "error: size mismatch in ddl " << ddlid << ": " << dataSize+sizeofAliRawDataHeader << " required " << ddl.GetSize() << endl;
578     return -1;
579   }
580
581   TArrayC readBytes(7);
582
583   // we do not need to test if there is only one byte
584   if (dataSize<=readBytes.GetSize()) return 0;
585
586   UInt_t i=0;
587   for (; i<(readBytes.GetSize()/sizeof(UInt_t))*sizeof(UInt_t); i+=sizeof(UInt_t)) {
588     UInt_t data=0;
589     if (!pRawReader->ReadNextInt(data)) {
590       cerr << "error: reading 1 int from ReadNextInt position " << i << " (ddl " << ddlid << ")" << endl;
591       return -1;
592     }
593 #ifndef R__BYTESWAP
594    data = (((data & 0x000000ffU) << 24) | ((data & 0x0000ff00U) <<  8) |
595            ((data & 0x00ff0000U) >>  8) | ((data & 0xff000000U) >> 24));
596 #endif
597    *(reinterpret_cast<UInt_t*>(readBytes.GetArray()+i))=data;
598   }
599   for (; i<(readBytes.GetSize()/sizeof(UShort_t))*sizeof(UShort_t); i+=sizeof(UShort_t)) {
600     UShort_t data=0;
601     if (!pRawReader->ReadNextShort(data)) {
602       cerr << "error: reading 1 short from ReadNextShort position " << i << " (ddl " << ddlid << ")" << endl;
603       return -1;
604     }
605 #ifndef R__BYTESWAP
606     data = (((data & 0x00ffU) <<  8) | ((data & 0xff00U) >>  8)) ;
607 #endif
608     *(reinterpret_cast<UShort_t*>(readBytes.GetArray()+i))=data;
609   }
610   for (; i<(UInt_t)readBytes.GetSize(); i++) {
611     if (!pRawReader->ReadNextChar(*(reinterpret_cast<UChar_t*>(readBytes.GetArray()+i)))) {
612       cerr << "error: reading 1 byte from ReadNextChar position " << i << " (ddl " << ddlid << ")" << endl;
613       return -1;
614     }
615   }
616   UChar_t* pTgt=NULL;
617   // TODO: here we have a problem with the HLT Raw Reader, due to the
618   // behavior of ReadNextData. It returns the pointer to either
619   // - the remaining data within this block. Thogh, GetDataSize still
620   //   returns the full lenght
621   // - if no more data available switch to next equipment
622   // Currently, the RawReaderHLT switches immediately to the next
623   // equipment, considered the GetDataSize behavior this is correct, but
624   // different from the others
625   // 
626   // Use ReadNext for the moment in order to get the test scheme working.
627   //if (!pRawReader->ReadNextData(pTgt) || pTgt==NULL) {
628   TArrayC buffer(dataSize-readBytes.GetSize());
629   pTgt=(UChar_t*)buffer.GetArray();
630   if (!pRawReader->ReadNext(pTgt, buffer.GetSize())) {
631     cerr << "error: reading " << dataSize << " byte(s) from ReadNextData (ddl " << ddlid << ")" << endl;
632     return -1;
633   }
634   if (ddlid!=pRawReader->GetEquipmentId()) {
635     cerr << "error: ReadMixed ddl id missmatch after ReadNextData: reqired id " << ddlid << " got " << pRawReader->GetEquipmentId() << endl;
636     return -1;
637   }
638
639   if (gbVerbose) cout << "verify ReadNextInt/Short/Char/Data: ddl " << ddlid << endl;
640   if (memcmp((ddl.GetArray())+sizeofAliRawDataHeader, readBytes.GetArray(), readBytes.GetSize())!=0) {
641     cerr << "error: verification of mixed ReadNextInt/Short/Char failed in ddl " << ddlid << endl;
642     return -1;
643   }
644   if (memcmp((ddl.GetArray())+readBytes.GetSize()+sizeofAliRawDataHeader, pTgt, dataSize-readBytes.GetSize())!=0) {
645     cerr << "error: verification of mixed ReadNext ddl " << ddlid << endl;
646     return -1;
647   }
648   return 0;
649 }
650
651 int main(int /*argc*/, const char** /*argv*/)
652 {
653   int iResult=testAliRawReaderFile();
654   if (iResult<0) {
655     cerr << "check failed, repeat in verbose mode ..." << endl;
656     gbVerbose=true;
657     iResult=testAliRawReaderFile();
658   }
659   return iResult;
660 }