]> Creatis software - gdcm.git/blob - Testing/TestAllEntryVerify.cxx
Ooops...
[gdcm.git] / Testing / TestAllEntryVerify.cxx
1 #include "gdcmHeader.h"
2
3 #include <map>
4 #include <list>
5 #include <fstream>
6 #include <iostream>
7
8 //Generated file:
9 #include "gdcmDataImages.h"
10
11 typedef std::string EntryValueType;   // same type as ValEntry::value
12 typedef std::map< TagKey, EntryValueType > MapEntryValues;
13 typedef MapEntryValues* MapEntryValuesPtr;
14 typedef std::string FileNameType;
15 typedef std::map< FileNameType, MapEntryValuesPtr > MapFileValuesType;
16
17 struct ParserException
18 {
19    std::string error;
20    static std::string Indent;
21
22    static std::string GetIndent() { return ParserException::Indent; }
23    ParserException( std::string ErrorMessage )
24    {
25       error = ErrorMessage;
26       Indent = "      ";
27    }
28    void Print() { std::cerr << Indent << error << std::endl; }
29 };
30
31 std::string ParserException::Indent = "      ";
32
33 class ReferenceFileParser
34 {
35    bool AddKeyValuePairToMap( std::string& key, std::string& value );
36
37    std::istream& eatwhite(std::istream& is);
38    void eatwhite(std::string& toClean);
39    std::string ExtractFirstString(std::string& toSplit);
40    void CleanUpLine( std::string& line );
41
42    std::string ExtractValue(std::string& toSplit)  throw ( ParserException );
43    void ParseRegularLine( std::string& line ) throw ( ParserException );
44    void FirstPassReferenceFile()         throw ( ParserException );
45    bool SecondPassReferenceFile()        throw ( ParserException );
46    void HandleFileName( std::string& line )   throw ( ParserException );
47    void HandleKey( std::string& line )        throw ( ParserException );
48    bool HandleValue( std::string& line )      throw ( ParserException );
49    static uint16_t axtoi( char* );
50 public:
51    ReferenceFileParser();
52    bool Open( std::string& referenceFileName );
53    void Print();
54    void SetDataPath(std::string&);
55    bool Check();
56 private:
57    /// The directory containing the images to check:
58    std::string DataPath;
59
60    /// The product of the parser:
61    MapFileValuesType ProducedMap;
62
63    /// The ifstream attached to the file we parse:
64    std::ifstream from;
65
66    /// String prefixing every output
67    std::string Indent;
68
69    /// The current line position within the stream:
70    int lineNumber;
71
72    /// The currently parsed filename:
73    std::string CurrentFileName;
74
75    /// The currently parsed key:
76    std::string CurrentKey;
77
78    /// The currently parsed value:
79    std::string CurrentValue;
80
81    /// The current MapEntryValues pointer:
82    MapEntryValues* CurrentMapEntryValuesPtr;
83 };
84
85 /// As gotten from:
86 /// http://community.borland.com/article/0,1410,17203,0.html
87 uint16_t ReferenceFileParser::axtoi(char *hexStg) {
88   int n = 0;         // position in string
89   int m = 0;         // position in digit[] to shift
90   int count;         // loop index
91   int intValue = 0;  // integer value of hex string
92   int digit[5];      // hold values to convert
93   while (n < 4) {
94      if (hexStg[n]=='\0')
95         break;
96      if (hexStg[n] > 0x29 && hexStg[n] < 0x40 ) //if 0 to 9
97         digit[n] = hexStg[n] & 0x0f;            //convert to int
98      else if (hexStg[n] >='a' && hexStg[n] <= 'f') //if a to f
99         digit[n] = (hexStg[n] & 0x0f) + 9;      //convert to int
100      else if (hexStg[n] >='A' && hexStg[n] <= 'F') //if A to F
101         digit[n] = (hexStg[n] & 0x0f) + 9;      //convert to int
102      else break;
103     n++;
104   }
105   count = n;
106   m = n - 1;
107   n = 0;
108   while(n < count) {
109      // digit[n] is value of hex digit at position n
110      // (m << 2) is the number of positions to shift
111      // OR the bits into return value
112      intValue = intValue | (digit[n] << (m << 2));
113      m--;   // adjust the position to set
114      n++;   // next digit to process
115   }
116   return intValue;
117 }
118
119 void ReferenceFileParser::SetDataPath( std::string& inDataPath )
120 {
121    DataPath = inDataPath;
122 }
123
124 bool ReferenceFileParser::AddKeyValuePairToMap( std::string& key, std::string& value )
125 {
126    if ( !CurrentMapEntryValuesPtr )
127       return false;
128    if ( CurrentMapEntryValuesPtr->count(key) != 0 )
129       return false;
130    (*CurrentMapEntryValuesPtr)[key] = value;
131    
132    return true; //??
133 }
134
135 void ReferenceFileParser::Print()
136 {
137    for (MapFileValuesType::iterator i  = ProducedMap.begin();
138                                     i != ProducedMap.end();
139                                     ++i)
140    {
141       std::cout << Indent << "FileName: " << i->first << std::endl;
142       MapEntryValuesPtr KeyValues = i->second;
143       for (MapEntryValues::iterator j  = KeyValues->begin();
144                                     j != KeyValues->end();
145                                     ++j)
146       {
147          std::cout << Indent
148               << "  Key: " << j->first
149               << "  Value: " << j->second
150               << std::endl;
151       }
152       std::cout << Indent << std::endl;
153    }
154    std::cout << Indent << std::endl;
155 }
156
157 bool ReferenceFileParser::Check()
158 {
159    for (MapFileValuesType::iterator i  = ProducedMap.begin();
160                                     i != ProducedMap.end();
161                                     ++i)
162    {
163       std::string fileName = DataPath + i->first;
164       std::cout << Indent << "FileName: " << fileName << std::endl;
165       gdcm::Header* tested = new gdcm::Header( fileName.c_str() );
166       if( !tested->IsReadable() )
167       {
168         std::cerr << Indent << "Image not gdcm compatible:"
169              << fileName << std::endl;
170         delete tested;
171         return false;
172       }
173
174       MapEntryValuesPtr KeyValues = i->second;
175       for (MapEntryValues::iterator j  = KeyValues->begin();
176                                     j != KeyValues->end();
177                                     ++j)
178       {
179          std::string key = j->first;
180
181          std::string groupString  = key.substr( 0, 4 );
182          char* groupCharPtr;
183          groupCharPtr = new char(groupString.length() + 1);
184          strcpy( groupCharPtr, groupString.c_str() ); 
185
186          std::string groupElement = key.substr( key.find_first_of( "|" ) + 1, 4 );
187          char* groupElementPtr;
188          groupElementPtr = new char(groupElement.length() + 1);
189          strcpy( groupElementPtr, groupElement.c_str() ); 
190
191          uint16_t group   = axtoi( groupCharPtr );
192          uint16_t element = axtoi( groupElementPtr );
193
194          std::string testedValue = tested->GetEntryByNumber(group, element);
195          if ( testedValue != j->second )
196          {
197             std::cout << Indent << "Uncorrect value for key " << key << std::endl
198                  << Indent << "   read value [" << testedValue << "]" << std::endl
199                  << Indent << "   reference value [" << j->second << "]"
200                            << std::endl;
201             return false;
202          }
203       }
204       delete tested;
205       std::cout << Indent << "  OK" << std::endl;
206    }
207    std::cout << Indent << std::endl;
208    return true;
209 }
210
211 std::istream& ReferenceFileParser::eatwhite( std::istream& is )
212 {
213    char c;
214    while (is.get(c)) {
215       if (!isspace(c)) {
216          is.putback(c);
217          break;
218       }
219    }
220    return is;
221 }
222
223 void ReferenceFileParser::eatwhite( std::string& toClean )
224 {
225    while( toClean.find_first_of( " " ) == 0  )
226       toClean.erase( 0, toClean.find_first_of( " " ) + 1 );
227 }
228
229 std::string ReferenceFileParser::ExtractFirstString( std::string& toSplit )
230 {
231    std::string firstString;
232    eatwhite( toSplit );
233    if ( toSplit.find( " " ) == std::string::npos ) {
234       firstString = toSplit;
235       toSplit.erase();
236       return firstString;
237    }
238    firstString = toSplit.substr( 0, toSplit.find(" ") );
239    toSplit.erase( 0, toSplit.find(" ") + 1);
240    eatwhite( toSplit );
241    return firstString;
242 }
243
244 std::string ReferenceFileParser::ExtractValue( std::string& toSplit )
245    throw ( ParserException )
246 {
247    eatwhite( toSplit );
248    std::string::size_type beginPos = toSplit.find_first_of( '"' );
249    std::string::size_type   endPos = toSplit.find_last_of( '"' );
250
251    // Make sure we have at most two " in toSplit:
252    std::string noQuotes = toSplit.substr( beginPos + 1, endPos - beginPos - 1);
253    if ( noQuotes.find_first_of( '"' ) != std::string::npos )
254       throw ParserException( "more than two quote character" );
255
256    // No leading quote means this is not a value:
257    if ( beginPos == std::string::npos )
258    {
259       return std::string();
260    }
261
262    if ( ( endPos == std::string::npos ) || ( beginPos == endPos ) )
263       throw ParserException( "unmatched \" (quote character)" );
264
265    if ( beginPos != 0 )
266    {
267       std::ostringstream error;
268       error  << "leading character ["
269              << toSplit.substr(beginPos -1, 1)
270              << "] before opening \" ";
271       throw ParserException( error.str() );
272    }
273
274    // When they are some extra characters at end of value, it must
275    // be a space:
276    if (   ( endPos != toSplit.length() - 1 )
277        && ( toSplit.substr(endPos + 1, 1) != " " ) )
278    {
279       std::ostringstream error;
280       error  << "trailing character ["
281              << toSplit.substr(endPos + 1, 1)
282              << "] after value closing \" ";
283       throw ParserException( error.str() );
284    }
285
286    std::string value = toSplit.substr( beginPos + 1, endPos - beginPos - 1 );
287    toSplit.erase(  beginPos, endPos - beginPos + 1);
288    eatwhite( toSplit );
289    return value;
290 }
291
292 /// \brief   Checks the block syntax of the incoming ifstream. Checks that
293 ///          - no nested blocks are present
294 ///          - we encounter a matching succesion of "[" and "]"
295 ///          - when ifstream terminates the last block is closed.
296 ///          - a block is not opened and close on the same line
297 /// @param   from The incoming ifstream to be checked.
298 /// @return  True when incoming ifstream has a correct syntax, false otherwise.
299 /// \warning The underlying file pointer is not preseved.
300 void ReferenceFileParser::FirstPassReferenceFile() throw ( ParserException )
301 {
302    std::string line;
303    lineNumber = 1;
304    bool inBlock = false;
305    from.seekg( 0, std::ios::beg );
306
307    while ( ! from.eof() )
308    {
309       std::getline( from, line );
310
311       /// This is how we usually end the parsing because we hit EOF:
312       if ( ! from.good() )
313       {
314          if ( ! inBlock )
315             break;
316          else
317             throw ParserException( "Syntax error: EOF reached when in block.");
318       }
319
320       // Don't try to parse comments (weed out anything after first "#"):
321       if ( line.find_first_of( "#" ) != std::string::npos )
322       {
323          line.erase( line.find_first_of( "#" ) );
324       }
325
326       // Two occurences of opening blocks on a single line implies nested
327       // blocks which is illegal:
328       if ( line.find_first_of( "[" ) != line.find_last_of( "[" ) )
329       {
330          std::ostringstream error;
331          error << "Syntax error: nested block (open) in reference file"
332                << std::endl
333                << ParserException::GetIndent()
334                << "   at line " << lineNumber << std::endl;
335          throw ParserException( error.str() );
336       }
337
338       // Two occurences of closing blocks on a single line implies nested
339       // blocks which is illegal:
340       if ( line.find_first_of( "]" ) != line.find_last_of( "]" ) )
341       {
342          std::ostringstream error;
343          error << "Syntax error: nested block (close) in reference file"
344                << std::endl
345                << ParserException::GetIndent()
346                << "   at line " << lineNumber << std::endl;
347          throw ParserException( error.str() );
348       }
349
350       bool beginBlock ( line.find_first_of("[") != std::string::npos );
351       bool endBlock   ( line.find_last_of("]")  != std::string::npos );
352
353       // Opening and closing of block on same line:
354       if ( beginBlock && endBlock )
355       {
356          std::ostringstream error;
357          error << "Syntax error: opening and closing on block on same line "
358                << lineNumber++ << std::endl;
359          throw ParserException( error.str() );
360       }
361
362       // Illegal closing block when block not open:
363       if ( !inBlock && endBlock )
364       {
365          std::ostringstream error;
366          error << "Syntax error: unexpected end of block at line "
367                << lineNumber++ << std::endl;
368          throw ParserException( error.str() );
369       }
370   
371       // Uncommented line outside of block is not clean:
372       if ( !inBlock && !beginBlock )
373       {
374          continue;
375       }
376
377       if ( inBlock && beginBlock )
378       {
379          std::ostringstream error;
380          error << "   Syntax error: illegal opening of nested block at line "
381                << lineNumber++ << std::endl;
382          throw ParserException( error.str() );
383       }
384
385       // Normal situation of opening block:
386       if ( beginBlock )
387       {
388          inBlock = true;
389          lineNumber++;
390          continue;
391       }
392
393       // Normal situation of closing block:
394       if ( endBlock )
395       {
396          inBlock = false;
397          lineNumber++;
398          continue;
399       }
400       // This line had no block delimiter
401       lineNumber++;
402    }
403
404    // We need rewinding:
405    from.clear();
406    from.seekg( 0, std::ios::beg );
407 }
408
409 ReferenceFileParser::ReferenceFileParser()
410 {
411    lineNumber = 1;
412    Indent = "      ";
413 }
414
415 bool ReferenceFileParser::Open( std::string& referenceFileName )
416 {
417    from.open( referenceFileName.c_str(), std::ios::in );
418    if ( !from.is_open() )
419    {
420       std::cerr << Indent << "Can't open reference file." << std::endl;
421    }
422    
423    try
424    {
425       FirstPassReferenceFile();
426       SecondPassReferenceFile();
427    }
428    catch ( ParserException except )
429    {
430       except.Print();
431       return false;
432    }
433
434    from.close();
435    return true; //??
436 }
437
438 void ReferenceFileParser::CleanUpLine( std::string& line )
439 {
440    // Cleanup from comments:
441    if ( line.find_first_of( "#" ) != std::string::npos )
442       line.erase( line.find_first_of( "#" ) );
443
444    // Cleanup everything after end block delimiter:
445    if ( line.find_last_of( "]" ) != std::string::npos )
446       line.erase( line.find_last_of( "]" ) + 1 );
447
448    // Cleanup leading whites and skip empty lines:
449    eatwhite( line );
450 }
451
452 void ReferenceFileParser::HandleFileName( std::string& line )
453    throw ( ParserException )
454 {
455    if ( line.length() == 0 )
456       throw ParserException( "empty line on call of HandleFileName" );
457
458    if ( CurrentFileName.length() != 0 )
459       return;
460
461    CurrentFileName = ExtractFirstString(line);
462 }
463
464 void ReferenceFileParser::HandleKey( std::string& line )
465    throw ( ParserException )
466 {
467    if ( CurrentKey.length() != 0 )
468       return;
469
470    CurrentKey = ExtractFirstString(line);
471    if ( CurrentKey.find_first_of( "|" ) == std::string::npos )
472    {
473       std::ostringstream error;
474       error  << "uncorrect key:" << CurrentKey;
475       throw ParserException( error.str() );
476    }
477 }
478
479 bool ReferenceFileParser::HandleValue( std::string& line )
480    throw ( ParserException )
481 {
482    if ( line.length() == 0 )
483       throw ParserException( "empty line in HandleValue" );
484
485    if ( CurrentKey.length() == 0 )
486    {
487       std::cout << Indent << "No key present:" << CurrentKey << std::endl;
488       return false;
489    }
490    
491    std::string newCurrentValue = ExtractValue(line);
492    if ( newCurrentValue.length() == 0 )
493    {
494       std::cout << Indent << "Warning: empty value for key:"
495                      << CurrentKey << std::endl;
496    }
497
498    CurrentValue += newCurrentValue;
499    return true;
500 }
501
502 void ReferenceFileParser::ParseRegularLine( std::string& line)
503    throw ( ParserException )
504 {
505    if ( line.length() == 0 )
506       return;
507
508    // First thing is to get a filename:
509    HandleFileName( line );
510
511    if ( line.length() == 0 )
512       return;
513
514    // Second thing is to get a key:
515    HandleKey( line );
516        
517    if ( line.length() == 0 )
518       return;
519
520    // Third thing is to get a value:
521    if ( ! HandleValue( line ) )
522       return;
523
524    if ( CurrentKey.length() && CurrentValue.length() )
525    {
526       if ( ! AddKeyValuePairToMap( CurrentKey, CurrentValue ) )
527          throw ParserException( "adding to map of (key, value) failed" );
528       CurrentKey.erase();
529       CurrentValue.erase();
530    }
531 }
532
533 bool ReferenceFileParser::SecondPassReferenceFile()
534    throw ( ParserException )
535 {
536    TagKey key;
537    EntryValueType value;
538    std::string line;
539    bool inBlock = false;
540    lineNumber = 0;
541
542    while ( !from.eof() )
543    {
544       std::getline( from, line );
545       lineNumber++;
546
547       CleanUpLine( line );
548
549       // Empty lines don't require any treatement:
550       if ( line.length() == 0 )
551          continue;
552
553       bool beginBlock ( line.find_first_of("[") != std::string::npos );
554       bool endBlock   ( line.find_last_of("]")  != std::string::npos );
555
556       // Waiting for a block to be opened. Meanwhile, drop everything:
557       if ( !inBlock && !beginBlock )
558          continue;
559
560       if ( beginBlock )
561       {
562          inBlock = true;
563          line.erase( 0, line.find_first_of( "[" ) + 1 );
564          eatwhite( line );
565          CurrentMapEntryValuesPtr = new MapEntryValues();
566       }
567       else if ( endBlock )
568       {
569          line.erase( line.find_last_of( "]" ) );
570          eatwhite( line );
571          ParseRegularLine( line );
572          ProducedMap[CurrentFileName] = CurrentMapEntryValuesPtr;
573          inBlock = false;
574          CurrentFileName.erase();
575       }
576    
577       // Outside block lines are dropped:
578       if ( ! inBlock )
579          continue;
580
581       ParseRegularLine( line );
582    }
583    return true; //??
584 }
585
586 int TestAllEntryVerify(int argc, char* argv[]) 
587 {
588    if ( argc > 1 )
589    {
590       std::cerr << "   Usage: " << argv[0]
591                 << " (no arguments needed)." << std::endl;
592       return 1;
593    }
594
595    std::string referenceDir = GDCM_DATA_ROOT;
596    referenceDir       += "/";
597    std::string referenceFilename = referenceDir + "TestAllEntryVerifyReference.txt";
598    
599    std::cout << "   Description (Test::TestAllEntryVerify): "
600         << std::endl;
601    std::cout << "   For all images (not blacklisted in gdcm/Test/CMakeLists.txt)"
602         << std::endl;
603    std::cout << "   encountered in directory: " << GDCM_DATA_ROOT << std::endl;
604    std::cout << "   apply the following tests : "<< std::endl;
605    std::cout << "   step 1: parse the image and call IsReadable(). "  << std::endl;
606    std::cout << "   step 2: look for the entry corresponding to the image" << std::endl;
607    std::cout << "           in the reference file: " << referenceFilename << std::endl;
608    std::cout << "   step 3: check that each reference tag value listed for this"
609         << std::endl;
610    std::cout << "           entry matches the tag encountered at parsing step 1."
611         << std::endl << std::endl;
612
613    ReferenceFileParser Parser;
614    if ( !Parser.Open(referenceFilename) )
615    {
616       std::cout << "   Corrupted reference file name: "
617            << referenceFilename << std::endl;
618       return 1;
619    }
620    Parser.SetDataPath(referenceDir);
621    // Parser.Print();
622    if ( Parser.Check() )
623       return 0;
624    return 1;
625 }