core/test/CommandLineProcessor/cxx_main.cpp

Go to the documentation of this file.

// @HEADER
// ***********************************************************************
//
//                    Teuchos: Common Tools Package
//                 Copyright (2004) Sandia Corporation
//
// Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
// license for use of this work by or on behalf of the U.S. Government.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the Corporation nor the names of the
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Questions? Contact Michael A. Heroux (maherou@sandia.gov)
//
// ***********************************************************************
// @HEADER
 
#include "Teuchos_CommandLineProcessor.hpp"
#include "Teuchos_GlobalMPISession.hpp"
#include "Teuchos_Version.hpp"
 
int main( int argc, char* argv[] )
{
 
  using Teuchos::CommandLineProcessor;
 
  bool verbose = true;
  bool parse_successful = true;
 
  Teuchos::GlobalMPISession mpiSession(&argc, &argv);
 
  // First create tests for a command line processor that doesn't throw exceptions.
  try {
    // Read options from the commandline
    CommandLineProcessor  clp(false, false); // Don't throw exceptions
 
    double rel_proc_speed = 1e-5; // Should
    clp.setOption( "rel-proc-speed", &rel_proc_speed, "Relative processor speed (try around 1.0 for timing)." );
 
    int size = 1;
    clp.setOption( "size", &size, "Size of memory blocks created." );
 
    size_t sizetOption = 10;
    clp.setOption( "sizeTOption", &sizetOption, "An option of type size_t.");
 
    long long longLongOption = 42;
    clp.setOption( "longLongOption", &longLongOption, "An option of type long long." );
 
    // Parse the current input, which should return succesful.
    CommandLineProcessor::EParseCommandLineReturn parse_return = clp.parse(argc,argv);
    if (verbose)
      std::cout << "Test 1:  CommandLineProcessor - No exceptions - All extra options ignored: ";
    if( parse_return != CommandLineProcessor::PARSE_SUCCESSFUL )
    {
      parse_successful = false;
      if (verbose) std::cout << "FAILED" << std::endl;
    }
    else
      if (verbose) std::cout << "PASSED" << std::endl;
 
    // Add a new option that is required
    int num = 1;
    clp.setOption( "num", &num, "Number of memory blocks created (required option).", true );
 
    // Now parse with this new option (which should not be passed in on the command line)
    parse_return = clp.parse(argc,argv);
    if (verbose)
      std::cout << "Test 2:  CommandLineProcessor - No exceptions - All extra options ignored - 1 required: ";
    if( parse_return != CommandLineProcessor::PARSE_ERROR )
    {
      parse_successful = false;
      if (verbose) std::cout << "FAILED" << std::endl;
    }
    else
      if (verbose) std::cout << "PASSED" << std::endl;
 
  }
  catch( ... ) {
    if(verbose)
      std::cerr << "*** Caught UNEXPECTED unknown exception\n";
    parse_successful = false;  // No exceptions should be thrown for this command line processor.
  }
 
  // Next create tests for a command line processor that does throw exceptions.
  // Read options from the commandline
  try {
    CommandLineProcessor  clp2(true, false); // Throw exceptions
 
    clp2.setOption( "verbose", "quiet", &verbose, "Set if output is printed or not." );
 
    double rel_proc_speed = 1e-5; // Should
    clp2.setOption( "rel-proc-speed", &rel_proc_speed, "Relative processor speed (try around 1.0 for timing)." );
 
    int size = 1;
    clp2.setOption( "size", &size, "Size of memory blocks created." );
 
    // Add a new option that is required
    int num = 1;
    clp2.setOption( "num", &num, "Number of memory blocks created (required option).", true );
 
    // Parse the argument line and see if we get an exception thrown
    clp2.parse(argc,argv);
  }
  catch( CommandLineProcessor::ParseError &excpt ) {
    if(verbose)
      std::cout << "*** Caught EXPECTED standard exception : " << excpt.what() << std::endl
                << "Test 3:  CommandLineProcessor - Throw exceptions - All extra options ignored - 1 required: PASSED" << std::endl;
  }
  catch( ... ) {
    if(verbose)
      std::cout << "*** Caught UNEXPECTED unknown exception" << std::endl
                << "Test 3:  CommandLineProcessor - Throw exceptions - All extra options ignored - 1 required: FAILED" << std::endl;
    parse_successful = false;  // No exceptions should be thrown for this command line processor.
  }
 
  // Next create tests for a command line processor that doesn't throw exceptions, and doesn't recognize all options.
  try {
    CommandLineProcessor  clp3(false, true); // Don't recognize all options
 
    // Parse the current input, which should not be successful because the test is run with "--verbose" argument.
    CommandLineProcessor::EParseCommandLineReturn parse_return = clp3.parse(argc,argv);
    if (verbose)
      std::cout << "Test 4 :  CommandLineProcessor - No exceptions - Extra options not recognized: ";
    if( parse_return != CommandLineProcessor::PARSE_UNRECOGNIZED_OPTION )
    {
      parse_successful = false;
      if (verbose) std::cout << "FAILED" << std::endl;
    }
    else
      if (verbose) std::cout << "PASSED" << std::endl;
 
    // Now add the verbose option back in and add a required option.
    clp3.setOption( "verbose", "quiet", &verbose, "Set if output is printed or not." );
 
    int num = 1;
    clp3.setOption( "num", &num, "Number of memory blocks created (required option).", true );
 
    parse_return = clp3.parse(argc,argv);
    if (verbose)
      std::cout << "Test 5 :  CommandLineProcessor - No exceptions - Extra options not recognized - 1 required: ";
    if( parse_return != CommandLineProcessor::PARSE_ERROR )
    {
      parse_successful = false;
      if (verbose) std::cout << "FAILED" << std::endl;
    }
    else
      if (verbose) std::cout << "PASSED" << std::endl;
  }
  catch( ... ) {
    if(verbose)
      std::cerr << "*** Caught UNEXPECTED unknown exception" << std::endl;
    parse_successful = false;  // No exceptions should be thrown for this command line processor.
  }
 
  // Next create tests for a command line processor that doesn't throw exceptions, and doesn't recognize all options.
  try {
    if (verbose)
      std::cout << "Test 6 :  CommandLineProcessor - Throw exceptions - Extra options not recognized: ";
 
    CommandLineProcessor  clp4(true, true); // Don't recognize all options AND throw exceptions (default mode)
 
    // Parse the current input, which should not be successful because the test is run with "--verbose" argument.
    clp4.parse(argc,argv);
  }
  catch( CommandLineProcessor::UnrecognizedOption &excpt ) {
    if(verbose)
      std::cout << "*** Caught EXPECTED standard exception : " << excpt.what() << std::endl
                << "Test 6:  CommandLineProcessor - Throw exceptions - Extra options not recognized: PASSED" << std::endl;
  }
  catch( ... ) {
    if(verbose)
      std::cout << "*** Caught UNEXPECTED unknown exception" << std::endl
                << "Test 6:  CommandLineProcessor - Throw exceptions - Extra options not recognized: FAILED" << std::endl;
    parse_successful = false;  // No exceptions should be thrown for this command line processor.
  }
 
  // Next create tests for a command line processor that makes sure help output is the same independent of the arg position
  try {
    if (verbose)
      std::cout << "Test 7 :  CommandLineProcessor - Help position" << std::endl;
 
    CommandLineProcessor clp7(false, false);  // Recognize all options AND do not throw exceptions
 
    int n = 10;
    clp7.setOption("n", &n, "A parameter");
 
    char arg_c[] = "command";
    char arg_n[] = "--n=20";
    char arg_h[] = "--help";
 
    const int aux_argc = 3;
    char *aux_argv[aux_argc];
 
    std::stringbuf  buffer1, buffer2;;
    std::streambuf* oldbuffer = NULL;
 
    // help before args
    aux_argv[0] = &arg_c[0];
    aux_argv[1] = &arg_h[0];
    aux_argv[2] = &arg_n[0];
 
    oldbuffer = std::cerr.rdbuf(&buffer1);   // redirect output
    clp7.parse(aux_argc, aux_argv);
    std::cerr.rdbuf(oldbuffer);              // redirect output back
 
    // help after args
    aux_argv[0] = &arg_c[0];
    aux_argv[1] = &arg_n[0];
    aux_argv[2] = &arg_h[0];
 
    oldbuffer = std::cerr.rdbuf(&buffer2);   // redirect output
    clp7.parse(aux_argc, aux_argv);
    std::cerr.rdbuf(oldbuffer);              // redirect output back
 
    if (verbose)
      std::cout << "Test 7 :  CommandLineProcessor - Help position: ";
    if (buffer1.str() != buffer2.str())
    {
      parse_successful = false;
      if (verbose) std::cout << "FAILED" << std::endl;
    }
    else
      if (verbose) std::cout << "PASSED" << std::endl;
  }
  catch( CommandLineProcessor::UnrecognizedOption &excpt ) {
    if(verbose)
      std::cout << "*** Caught EXPECTED standard exception : " << excpt.what() << std::endl
                << "Test 7:  CommandLineProcessor - Help position: PASSED" << std::endl;
  }
  catch( ... ) {
    if(verbose)
      std::cout << "*** Caught UNEXPECTED unknown exception" << std::endl
                << "Test 7:  CommandLineProcessor - Help position: FAILED" << std::endl;
    parse_successful = false;  // No exceptions should be thrown for this command line processor.
  }
 
  // Return whether the command line processor tests passed.
  if (parse_successful) {
    std::cout << "End Result: TEST PASSED" << std::endl;
    return 0;
  }
  else {
    std::cout << "End Result: TEST FAILED" << std::endl;
    return 1;
  }
}