source: trunk/test/commandline_test.cc @ 975

// $Id: commandline_test.cc 975 2007-10-17 21:03:37Z peter $

/*
  Copyright (C) 2007 Peter Johansson

  This file is part of the yat library, http://trac.thep.lu.se/trac/yat

  The yat library is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License as
  published by the Free Software Foundation; either version 2 of the
  License, or (at your option) any later version.

  The yat library 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
  General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  02111-1307, USA.
*/

#include "yat/utility/CommandLine.h"
#include "yat/utility/OptionArg.h"
#include "yat/utility/OptionFile.h"
#include "yat/utility/OptionSwitch.h"

#include <fstream>
#include <stdexcept>

using namespace theplu::yat::utility;
bool cmd_help(std::ostream& error);
bool test_switch(std::ostream& error);
bool test_arg(std::ostream& error);
bool test_failures(std::ostream& error);

int main(const int argc,const char* argv[])
{  

  std::ostream* error;
  if (argc>1 && argv[1]==std::string("-v"))
    error = &std::cerr;
  else {
    error = new std::ofstream("/dev/null");
    if (argc>1)
      std::cout << "commandline_test -v : for printing extra "  
                << "information\n";
  }
  *error << "testing commandline" << std::endl;
  bool ok = true;

  try {
    ok &= cmd_help(*error);
  
    ok &= test_switch(*error);
    ok &= test_arg(*error);
    ok &= test_failures(*error);
  }
  catch (std::runtime_error& e) {
    *error << "exception thrown\n" << e.what() << std::endl;
  }

  CommandLine cmd;
  OptionFile file(cmd, "f,file", "description");

  if (!ok)
    *error << "commandline test failed" << std::endl;
  else
    *error << "All tests are OK." << std::endl;
  
  if (error!=&std::cerr)
    delete error;

  return (ok ? 0 : -1);
}


bool cmd_help(std::ostream& error)
{
  using namespace theplu::yat::utility;
  CommandLine cmd;
  OptionArg<std::string> dir(cmd, "d,dir", "output directory");
  OptionSwitch help(cmd, "h,help", "display this help and exit");
  OptionSwitch target(cmd, "T,target", "treat DEST as a normal file", true);
  OptionSwitch verbose(cmd, "v,verbose", "explain what is being done");
  OptionSwitch version(cmd, "version", "output version and exit");

  error << cmd;
  return true;
}

bool test_switch(std::ostream& error)
{
  bool ok=true;
  CommandLine cmd;
  OptionSwitch target(cmd, "T,target", "treat DEST as a normal file", true);
  OptionSwitch verbose(cmd, "v,verbose", "explain what is being done", true);

  error << "Testing OptionSwitch -T...";
  {
    int ac = 2;
    char* av[] = { "test_prog", "-T" };
    cmd.parse(ac,av);
    if (target.present() && !verbose.present())
      error << "ok\n";
    else {
      error << "failed\n";
      ok =false;
    }
  }


  error << "Testing OptionSwitch --target...";
  {
    int ac = 2;
    char* av[] = { "test_prog", "--target" };
    cmd.parse(ac,av);
    if (target.present() && !verbose.present())
      error << "ok\n";
    else {
      error << "failed\n";
      ok =false;
    }
  }

  error << "Testing OptionSwitch -T -v...";
  {
    int ac = 3;
    char* av[] = { "test_prog", "-T" , "-v"};
    cmd.parse(ac,av);
    if (target.present() && verbose.present())
      error << "ok\n";
    else {
      error << "failed\n";
      ok =false;
    }
  }

  error << "Testing OptionSwitch -vT...";
  {
    int ac = 2;
    char* av[] = { "test_prog", "-vT"};
    cmd.parse(ac,av);
    if (target.present() && verbose.present())
      error << "ok\n";
    else {
      error << "failed\n";
      ok =false;
    }
  }
  return ok;
}


bool test_arg(std::ostream& error)
{
  bool ok=true;
  CommandLine cmd;
  OptionArg<std::string> input(cmd, "i,input", "input file");
  OptionArg<u_int> n(cmd, "n", "number of lines");

  error << "Testing OptionArg existence -i file...";
  {
    int ac = 3;
    char* av[] = { "test_prog", "-i", "file" };
    cmd.parse(ac,av);
    if (input.present())
      error << "ok\n";
    else {
      error << "failed\n";
      ok =false;
    }
  }

  error << "Testing OptionArg value -i file...";
  {
    int ac = 3;
    char* av[] = { "test_prog", "-i", "file" };
    cmd.parse(ac,av);
    if (input.value()=="file")
      error << "ok\n";
    else {
      error << "failed\n";
      ok =false;
    }
  }

  error << "Testing OptionArg existence --input file...";
  {
    int ac = 3;
    char* av[] = { "test_prog", "--input", "file" };
    cmd.parse(ac,av);
    if (input.present())
      error << "ok\n";
    else {
      error << "failed\n";
      ok =false;
    }
  }

  error << "Testing OptionArg value --input=file...";
  {
    int ac = 2;
    char* av[] = { "test_prog", "--input=file" };
    cmd.parse(ac,av);
    if (input.value()=="file")
      error << "ok\n";
    else {
      error << "failed\n";
      ok =false;
    }
  }

  error << "Testing OptionArg value --input=\"file called something\"...";
  {
    int ac = 2;
    char* av[] = { "test_prog", "--input=\"file called something\"" };
    cmd.parse(ac,av);
    if (input.value()=="file called something")
      error << "ok\n";
    else {
      error << "failed\n";
      error << "value is `" << input.value() << "'\n"
            << "expected `file called something'\n";
      ok =false;
    }
  }

  error << "Testing OptionArg u_int value -n 3...";
  {
    int ac = 3;
    char* av[] = { "test_prog", "-n", "3" };
    cmd.parse(ac,av);
    if (n.value()==3)
      error << "ok\n";
    else {
      error << "failed\n";
      ok =false;
    }
  }


  error << "Testing OptionArg 2 value --input file -n 3...";
  {
    int ac = 5;
    char* av[] = { "test_prog", "--input", "file", "-n", "3" };
    cmd.parse(ac,av);
    if (input.value()=="file")
      error << "ok\n";
    else {
      error << "failed\n";
      ok =false;
    }
  }


  return ok;
}

bool test_failures(std::ostream& error)
{
  bool ok=true;
  CommandLine cmd;
  OptionSwitch verbose(cmd, "v,verbose", "explain what is being done");
  OptionArg<std::string> input(cmd, "i,input", "input file");
  OptionArg<u_int> n(cmd, "n", "number of lines");

  error << "Testing unknown option --peter...";
  {
    int ac = 2;
    char* av[] = { "test_prog", "--peter"};
    try{
      cmd.parse(ac,av);
      error << "failed\n";
      ok =false;
    }
    catch (...) {
      error << "ok\n";
    }
  }

  error << "Testing unknown option -jvjhsgad...";
  {
    int ac = 2;
    char* av[] = { "test_prog", "-vjhsgad"};
    try{
      cmd.parse(ac,av);
      error << "failed\n";
      ok =false;
    }
    catch (...) {
      error << "ok\n";
    }
  }


  error << "Testing invalid option -nv 3...";
  {
    int ac = 3;
    char* av[] = { "test_prog", "-nv", "3"};
    try{
      cmd.parse(ac,av);
      error << "failed\n";
      ok =false;
    }
    catch (...) {
      error << "ok\n";
    }
  }


  error << "Testing 23.12 is not u_int...";
  {
    int ac = 3;
    char* av[] = { "test_prog", "-n", "23.12"};
    try{
      cmd.parse(ac,av);
      error << "failed\n";
      ok =false;
    }
    catch (std::runtime_error& e) {
      error << "ok\n";
    }
  }

  error << "Testing -1 is not u_int...";
  {
    int ac = 3;
    char* av[] = { "test_prog", "-n" "-1"};
    try{
      cmd.parse(ac,av);
      error << "failed\n";
      ok =false;
    }
    catch (...) {
      error << "ok\n";
    }
  }
  return ok;
}