Binex_ReadWrite_T.cpp

Go to the documentation of this file.

//==============================================================================
//
//  This file is part of GNSSTk, the ARL:UT GNSS Toolkit.
//
//  The GNSSTk is free software; you can redistribute it and/or modify
//  it under the terms of the GNU Lesser General Public License as published
//  by the Free Software Foundation; either version 3.0 of the License, or
//  any later version.
//
//  The GNSSTk is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU Lesser General Public License for more details.
//
//  You should have received a copy of the GNU Lesser General Public
//  License along with GNSSTk; if not, write to the Free Software Foundation,
//  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
//
//  This software was developed by Applied Research Laboratories at the
//  University of Texas at Austin.
//  Copyright 2004-2022, The Board of Regents of The University of Texas System
//
//==============================================================================
 
//==============================================================================
//
//  This software was developed by Applied Research Laboratories at the
//  University of Texas at Austin, under contract to an agency or agencies
//  within the U.S. Department of Defense. The U.S. Government retains all
//  rights to use, duplicate, distribute, disclose, or release this software.
//
//  Pursuant to DoD Directive 523024
//
//  DISTRIBUTION STATEMENT A: This software has been approved for public
//                            release, distribution is unlimited.
//
//==============================================================================
 
#include "BinexData.hpp"
#include "BinexStream.hpp"
#include "TestUtil.hpp"
 
using namespace std;
using namespace gnsstk;
 
//=============================================================================
// Class declarations
//=============================================================================
class BinexReadWrite_T
{
public:
 
      // constructor
   BinexReadWrite_T(int v = 0) : verboseLevel(v)
   {
      init();
   };
 
      // destructor
   virtual ~BinexReadWrite_T() {};
 
      // initialize tests
   void init();
 
      // test methods
      // @return  number of failures, i.e., 0=PASS, !0=FAIL
   int doForwardTests();
   int doReverseTests();
 
   unsigned  verboseLevel;  // amount to display during tests, 0 = least
 
private:
 
   enum TestDataType
   {
      CharType  = 'c',
      ShortType = 's',
      LongType  = 'l',
      UbnxiType = 'U',
      MgfziType = 'M'
   };
 
   struct TestData
   {
      TestDataType  dtype;
      long long     value;
   };
 
   typedef vector<TestData>      TestDataList;
   typedef vector<TestDataList>  TestDataListList;
   typedef vector<BinexData>     RecordList;
 
      // @param[in] c character to convert
      // @param[in/out] dtype data type derived from c
      // @return true if the character is a valid data type,
      //         false otherwise
   bool charToType(char c, TestDataType& t);
 
      // read a list of numbers (one per line) from the specified file
      // @return true on success, false on failure
   bool readNums(const string& filename);
 
      // generate BINEX records from the contents of numList
      // @return true if successful, false otherwise
   bool createRecs();
 
   void dumpBuffer(const unsigned char* buffer, size_t size);
 
   TestDataList  numList;
 
   TestDataListList  testData;
 
   RecordList  testRecords;
 
}; // class BinexReadWrite_T
 
 
//============================================================
// Initialize Test Data Filenames and Values
//============================================================
 
void BinexReadWrite_T :: init( void )
{
 
   TestUtil  testUtil;
   string  dataFilePath = gnsstk::getPathData();
 
      //----------------------------------------
      // Full file paths
      //----------------------------------------
   string  inputFile = dataFilePath + gnsstk::getFileSep()
                       + "test_input_binex_readwrite.txt";
 
   if (verboseLevel > 0)
   {
      cout << "  Reading test input . . ." << endl;
   }
   readNums(inputFile);
 
   if (verboseLevel > 0)
   {
      cout << "    " << numList.size() << " numbers" << endl;
      cout << "  Creating BINEX records . . ." << endl;
   }
   createRecs();
   if (verboseLevel > 0)
   {
      cout << "    " << testRecords.size() << " records" << endl;
   }
}
 
 
bool BinexReadWrite_T :: charToType(char c, TestDataType& t)
{
   switch (c)
   {
      case CharType:
         t = CharType;
         break;
      case ShortType:
         t = ShortType;
         break;
      case LongType:
         t = LongType;
         break;
      case UbnxiType:
         t = UbnxiType;
         break;
      case MgfziType:
         t = MgfziType;
         break;
 
      default:
         return false;
   }
   return true;
}
 
 
//---------------------------------------------------------------------------
bool BinexReadWrite_T :: readNums(const string& filename)
{
   ifstream  ifs(filename.c_str());
 
   if (!ifs.good())
      return false;
 
   while (ifs.good())
   {
      string  line;
      getline(ifs, line);
 
         // ignore comments
      string::size_type  hashPos = line.find('#');
      if (hashPos != string::npos)
      {
         line.erase(hashPos);
      }
         // ignore empty lines
      string::size_type  nonWhitePos = line.find_first_not_of(" \t");
      if (nonWhitePos != string::npos)
      {
         istringstream  iss(line);
         TestData  num;
         char  c;
         iss >> c;
 
            // make sure the type is valid
         if (charToType(c, num.dtype))
         {
            iss >> num.value;
            numList.push_back(num);
         }
         else
         {
            if (verboseLevel > 0)
            {
               cout << "  Warning: Unrecognized data type: " << c << endl;
            }
         }
      }
   }
   return (numList.size() > 0);
}
 
 
bool BinexReadWrite_T :: createRecs()
{
   TestDataList::const_iterator  tdIter = numList.begin();
   while (tdIter != numList.end() )
   {
      BinexData     record(1);
      TestDataList  recordData;
      size_t        offset = 0;
 
         // create multiple records with 9 fields each
      short  dataNum = 0;
      for ( ; (dataNum < 9) && (tdIter != numList.end()); ++dataNum, ++tdIter)
      {
         switch (tdIter->dtype)
         {
            case CharType:
            {
               char  c = tdIter->value;
               record.updateMessageData(offset, c, sizeof(c) );
               break;
            }
            case ShortType:
            {
               short  s = tdIter->value;
               record.updateMessageData(offset, s, sizeof(s) );
               break;
            }
            case LongType:
            {
               long  l = tdIter->value;
               record.updateMessageData(offset, l, sizeof(l) );
               break;
            }
            case UbnxiType:
            {
               BinexData::UBNXI  u(tdIter->value);
               record.updateMessageData(offset, u);
               break;
            }
            case MgfziType:
            {
               BinexData::MGFZI  m(tdIter->value);
               record.updateMessageData(offset, m);
               break;
            }
            default:
                  // Internal error
               cout << "  Internal error during record creation" << std::endl;
               return false;
         }
         recordData.push_back(*tdIter);
      }
      testData.push_back(recordData);
      testRecords.push_back(record);
   }
   return true;
}
 
 
int BinexReadWrite_T :: doForwardTests()
{
   TUDEF("BinexData", "Read/Write (Fwd)");
 
   string  tempFilePath = gnsstk::getPathTestTemp();
   string  tempFileName = tempFilePath + gnsstk::getFileSep() +
                          "test_output_binex_readwrite.binex";
   BinexStream  outStream(tempFileName.c_str(),
                          std::ios::out | std::ios::binary);
 
   TUASSERT(outStream.good());
 
   outStream.exceptions(ios_base::failbit | ios_base::badbit);
   RecordList::iterator  recordIter = testRecords.begin();
   for ( ; recordIter != testRecords.end(); ++recordIter)
   {
      try
      {
         std::streampos posBefore = outStream.tellp();
         (*recordIter).putRecord(outStream);
         std::streampos posAfter = outStream.tellp();
         TUASSERTE(long long, (*recordIter).getRecordSize(), (posAfter - posBefore));
      }
      catch (Exception& e)
      {
         ostringstream  oss;
         oss << "exception writing record: " << e;
         TUFAIL(oss.str());
      }
      catch (...)
      {
         TUFAIL("unknown exception writing record");
      }
   }
   outStream.close();
 
   BinexStream  inStream(tempFileName.c_str(),
                         std::ios::in | std::ios::binary);
   inStream.exceptions(ios_base::failbit);
 
   TUASSERT(inStream.good());
 
   recordIter = testRecords.begin();
   while (inStream.good() && (EOF != inStream.peek() ) )
   {
      if (recordIter == testRecords.end() )
      {
         TUFAIL("stored records exhausted before file records");
         break;
      }
      BinexData record;
      try
      {
         record.getRecord(inStream);
         if (record == *recordIter)
         {
            TUPASS("gotten record matches");
         }
         else
         {
            ostringstream  oss;
            oss << "Actual record:" << endl;
            (*recordIter).dump(oss);
            oss << "Expected record:" << endl;
            record.dump(oss);
 
            TUFAIL(oss.str());
         }
      }
      catch (Exception& e)
      {
         ostringstream  oss;
         oss << "stream exception reading record: " << e;
         TUFAIL(oss.str());
      }
      catch (...)
      {
         TUFAIL("unknown exception reading record");
      }
 
      recordIter++;
   }
   inStream.close();
 
   TURETURN();
}
 
 
int BinexReadWrite_T :: doReverseTests()
{
   TUDEF("BinexData", "Read/Write (Rev)");
 
      // @todo
 
   TURETURN();
}
 
 
int main(int argc, char *argv[])
{
   int  errorTotal = 0;
 
   BinexReadWrite_T  testClass;  // test data is loaded here
 
   errorTotal += testClass.doForwardTests();
 
      //errorTotal += testClass.doReverseTests();
 
   return( errorTotal );
 
} // main()