main()

int main	(	int	iargc,
		char *	argv[]
	)

Examples:

libdatrwxxtests.cc.

Definition at line 113 of file libdatrwxxtests.cc.

References datrw::Subformat::allarechecked(), checkkey(), datrw::util::clipstring(), DATRW_abort, DATRW_assert, DATRW_assert_modifiers_are_recognized, DATRW_illegal, DATRW_nonfatal_assert, DATRW_report_assert, DATRW_value, DATRW_warning, Options::debug, Options::formatstring, LIBDATRWXXTESTS_VERSION, Options::nerrortest, Options::readint, Options::readsingle, Options::readtest, Options::readtype, reportkey(), reportprovides(), Options::skipsamples, Options::testerror, Options::testformat, and Options::verbose.

{

  // define usage information
  char usage_text[]=
  {
    LIBDATRWXXTESTS_VERSION "\n"
    "usage: libdatrwxxtests [-format s] [-rtest type] [-int] [-single]\n"
    "                       [-error[=n]]" "\n"
    "                       [-v] [-skip] [-DEBUG] file [file ...]" "\n"
    "   or: libdatrwxxtests --help|-h" "\n"
  };

  // define full help text
  char help_text[]=
  {
    "\n"
    "-v           verbose mode\n"
    "-DEBUG       activate debugging output\n"
    "-format s    test datrwxx::Subformat by passing format string s\n"
    "-rtest type  read files of type \"type\" and report content\n"
    "-int         use integer reading\n"
    "-single      use float reading\n"
    "-skip        skip traces\n"
    "-error[=n]   test error report mechanism (n=0: prints available tests)\n"
    "file         file to be read\n"
  };

  // define commandline options
  using namespace tfxx::cmdline;
  static Declare options[]= 
  {
    // 0: print help
    {"help",arg_no,"-"},
    // 1: verbose mode
    {"v",arg_no,"-"},
    // 2: verbose mode
    {"format",arg_yes,"-"},
    // 3: perform a read test
    {"rtest",arg_yes,"-"},
    // 4: use integer samples
    {"int",arg_no,"-"},
    // 5: use single precision samples
    {"single",arg_no,"-"},
    // 6: skip samples
    {"skip",arg_no,"-"},
    // 7: debug output
    {"DEBUG",arg_no,"-"},
    // 8: skip samples
    {"error",arg_opt,"0"},
    {NULL}
  };

  // no arguments? print usage...
  if (iargc<2) 
  {
    cerr << usage_text << endl;
    exit(0);
  }

  // collect options from commandline
  Commandline cmdline(iargc, argv, options);

  // help requested? print full help text...
  if (cmdline.optset(0))
  {
    cerr << usage_text << endl;
    cerr << help_text << endl;
    exit(0);
  }

  Options opt;
  opt.verbose=cmdline.optset(1);
  opt.testformat=cmdline.optset(2);
  opt.formatstring=cmdline.string_arg(2);
  opt.readtest=cmdline.optset(3);
  opt.readtype=cmdline.string_arg(3);
  opt.readint=cmdline.optset(4);
  opt.readsingle=cmdline.optset(5);
  opt.skipsamples=cmdline.optset(6);
  opt.debug=cmdline.optset(7);
  opt.testerror=cmdline.optset(8);
  opt.nerrortest=cmdline.int_arg(8);

  /*======================================================================*/

  if (opt.testformat)
  {
    cout << "Test format modifiers" << endl;
    cout << "=====================" << endl;
    std::string format=datrw::util::clipstring(opt.formatstring);
    datrw::Subformat subformat(opt.formatstring);
    cout << "data format ID: " << format << endl;
    reportkey(subformat, "key1", "default1");
    reportkey(subformat, "key2", "18.,23.6");
    checkkey(subformat, "key3");
    checkkey(subformat, "key4");
    if (subformat.allarechecked())
    {
      cout << "All keys have been checked by the program." << endl;
    }
    else
    {
      DATRW_assert_modifiers_are_recognized(subformat, "libdatrwxxtests");
    }
    cout << endl;
  } // if (opt.testformat)

  /*======================================================================*/

  if (opt.readtest)
  {
    sff::FREE free;
    sff::INFO info;
    sff::SRCE srce;
    sff::WID2 wid2;
    cout << "Read input files of type: " << opt.readtype << endl;
    cout << "=========================" << endl;
    while (cmdline.extra())
    {
      std::string filename=cmdline.next();
      cout << endl;
      cout << "read file " << filename << endl;

      std::ifstream ifs(filename.c_str());
      datrw::ianystream is(ifs, opt.readtype, opt.debug);
      if (opt.verbose)
      {
        reportprovides("double", is.providesd());
        reportprovides("float", is.providesf());
        reportprovides("int", is.providesi());
      }
      if (is.hasfree())
      {
        if (opt.verbose)
        {
          cout << "file FREE block:" << endl;
          is >> free;
          ::sff::verbose(std::cout, free);
        }
        else
        {
          cout << "file has FREE block" << endl;
        }
      }
      else
      {
        cout << "file has no FREE block" << endl;
      }
      if (is.hassrce())
      {
        if (opt.verbose)
        {
          cout << "file SRCE line:" << endl;
          is >> srce;
          ::sff::verbose(std::cout, srce);
        }
        else
        {
          cout << "file has SRCE line" << endl;
        }
      }
      else
      {
        cout << "file has no SRCE line" << endl;
      }

      while (!is.last())
      {
        datrw::Tdseries dseries;
        datrw::Tfseries fseries;
        datrw::Tiseries iseries;

        if (opt.skipsamples)
        {
          is.skipseries();
        }
        else
        {
          if (opt.readint)
          {
            if (is.providesi())
            {
              is >> iseries;
            }
            else
            {
              cout << "stream does not provide integer data" << endl;
              is.skipseries();
            }
          }
          else if (opt.readsingle)
          {
            if (is.providesf())
            {
              is >> fseries;
            }
            else
            {
              cout << "stream does not provide single data" << endl;
              is.skipseries();
            }
          }
          else
          {
            if (is.providesd())
            {
              is >> dseries;
            }
            else
            {
              cout << "stream does not provide double data" << endl;
              is.skipseries();
            }
          }
        }
        if (is.hasfree())
        {
          if (opt.verbose)
          {
            cout << "trace FREE block:" << endl;
            is >> free;
            ::sff::verbose(std::cout, free);
          }
          else
          {
            cout << "trace has FREE block" << endl;
          }
        }
        else
        {
          cout << "trace has no FREE block" << endl;
        }
        if (is.hasinfo())
        {
          if (opt.verbose)
          {
            cout << "trace INFO line:" << endl;
            is >> info;
            ::sff::verbose(std::cout, info);
          }
          else
          {
            cout << "trace has INFO line" << endl;
          }
        }
        else
        {
          cout << "trace has no INFO line" << endl;
        }
        is >> wid2;
        ::sff::verbose(std::cout, wid2);
        if (opt.readint)
        {
          if (is.providesi())
          {
            if (opt.verbose)
            {
              DUMP( iseries );
            }
            else
            {
              cout << "read " << iseries.size() << " integer samples" << endl;
            }
          }
          else
          {
            cout << "stream does not provide integer data" << endl;
          }
        }
        else if (opt.readsingle)
        {
          if (is.providesf())
          {
            if (opt.verbose)
            {
              DUMP( fseries );
            }
            else
            {
              cout << "read " << fseries.size() 
                << " single precision samples" << endl;
            }
          }
          else
          {
            cout << "stream does not provide single precision data" << endl;
          }
        }
        else
        {
          if (is.providesd())
          {
            if (opt.verbose)
            {
              DUMP( dseries );
            }
            else
            {
              cout << "read " << dseries.size() 
                << " double precision samples" << endl;
            }
          }
          else
          {
            cout << "stream does not provide double precision data" << endl;
          }
        }
        if (is.last())
        {
          cout << "This was the last trace in file!" << endl;
        }
      } // while (!is.last())
    } // while (cmdline.extra())
  } // if (opt.readtest)

  /*======================================================================*/

  if (opt.testerror)
  {
    cout << "Test error reports (formatting of messages)" << endl;
    cout << "===========================================" << endl;
    cout << endl;
    if (opt.nerrortest == 0)
    {
      cout << "available tests:" << endl;
      cout << "1: non-fatal reports" << endl;
      cout << "2: direct abort" << endl;
      cout << "3: fatal/non-fatal assert (non-fatal version)" << endl;
      cout << "4: fatal/non-fatal assert (fatal version)" << endl;
      cout << "5: standard assertion" << endl;
    }
    else if (opt.nerrortest == 1)
    {
      cout << "report assert" << endl;
      cout << "-------------" << endl;
      DATRW_report_assert(false, "This message is produced after testing"
                          " a condition to report\n"
                          "that the test fails.");
      cout << "\nwarning" << endl;
      cout <<   "-------" << endl;
      DATRW_warning("main", "This is a warning message from a specific"
                    " function in the library.\n"
                    "The macro takes a multiline message output too.");
    }
    else if (opt.nerrortest == 2)
    {
      cout << "direct abort" << endl;
      cout << "------------" << endl;
      DATRW_abort("Abort program intentionally.\n"
                  "A multi-line message my be passed too in this case.\n"
                  "Pass one of the non-specified values for the error\n"
                  "test to see the output for DATRW_illegal.");
    }
    else if ((opt.nerrortest == 3) || (opt.nerrortest == 4))
    {
      cout << "fatal/non-fatal assert" << endl;
      cout << "----------------------" << endl;
      DATRW_nonfatal_assert(opt.nerrortest==3,
                            (opt.nerrortest<=1)||(opt.nerrortest>=6),
                            "This is a test of a fatal/non-fatal assert.\n"
                            "The error is made non-fatal, if the option"
                            "opt.nerrortest equals 3.\n"
                            "Currently " << DATRW_value(opt.nerrortest));
    }
    else if (opt.nerrortest == 5)
    {
      cout << "standard assertion" << endl;
      cout << "------------------" << endl;
      DATRW_assert(false, 
                   "This type of error is emitted,"
                   " if an assertion is failed.\n"
                   "Several lines of explanation can be provided"
                   " to the user.\n"
                   "This can include the output of variables like "
                   << DATRW_value(opt.nerrortest));
    }
    else
    {
      cout << "no test selected by n=" << opt.nerrortest << endl;
      DATRW_illegal;
    }
    cout << "...program did not abort" << endl;
  } // if (opt.testerror)
}

Here is the call graph for this function: