Testing/TestAllEntryVerify.cxx

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