source: trunk/test/commandline_test.cc @ 1426

// $Id: commandline_test.cc 1426 2008-08-20 22:26:31Z peter $

/*
  Copyright (C) 2007, 2008 Jari Häkkinen, Peter Johansson

  This file is part of the yat library, http://trac.thep.lu.se/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 "Suite.h"

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

#include <fstream>
#include <stdexcept>

using namespace theplu;
using namespace yat::utility;
bool cmd_help(yat::test::Suite& error);
bool test_switch(yat::test::Suite& error);
bool test_arg(yat::test::Suite& error);
bool test_file(yat::test::Suite& error);
bool test_failures(yat::test::Suite& error);
bool test_option_name_clash(yat::test::Suite& suite);

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

  yat::test::Suite suite(argc, argv);

  suite.err() << "testing commandline" << std::endl;

  try {
    suite.add(cmd_help(suite));
    suite.add(test_switch(suite));
    suite.add(test_arg(suite));
    suite.add(test_file(suite));
    suite.add(test_failures(suite));
    suite.add(test_option_name_clash(suite));
  }
  catch (std::runtime_error& e) {
    suite.err() << "Error: unexpected exception thrown\n" << e.what() 
                << std::endl;
    suite.add(false);
  }

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

  return suite.return_value();
}


bool cmd_help(yat::test::Suite& suite)
{
  using namespace theplu::yat::utility;
  CommandLine cmd;
  OptionArg<std::string> dir(cmd, "d,dir", "output directory");
  OptionHelp help(cmd);
  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");

  suite.err() << cmd;
  return true;
}

bool test_switch(yat::test::Suite& suite)
{
  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);

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


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

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

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


bool test_arg(yat::test::Suite& suite)
{
  bool ok=true;
  CommandLine cmd;
  OptionArg<std::string> input(cmd, "i,input", "input file");
  OptionArg<unsigned int> n(cmd, "n", "number of lines");

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

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

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

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

  suite.err() << "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")
      suite.err() << "ok\n";
    else {
      suite.err() << "failed\n";
      suite.err() << "value is `" << input.value() << "'\n"
            << "expected `file called something'\n";
      ok =false;
    }
  }

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


  suite.err() << "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")
      suite.err() << "ok\n";
    else {
      suite.err() << "failed\n";
      ok =false;
    }
  }


  return ok;
}

bool test_failures(yat::test::Suite& suite)
{
  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<unsigned int> n(cmd, "n", "number of lines");

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

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


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


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

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


  suite.err() << "Testing OptionArg required ...";
  {
    OptionArg<std::string> required(cmd, "required", "required", true); 
    int ac = 1;
    char* av[] = { "test_prog" };
    try{
      cmd.parse(ac,av);
      suite.err() << "failed\n";
      ok =false;
    }
    catch (...) {
      suite.err() << "ok\n";
    }
  }


  return ok;
}


bool test_file(yat::test::Suite& suite)
{
  bool ok=true;
  CommandLine cmd;
  OptionFile inclones(cmd, "clones", "file containing clones");
  OptionFile indata(cmd, "data", "data to merge");
  OptionFile out(cmd, "o,out", "data to merge", true, false, "w");
  OptionSwitch help(cmd, "h,help", "display this help and exit");

  suite.err() << "Testing OptionFile... ";
  {
    int ac = 7;
    char* av[] = { "test_prog", "--clones", "commandline_test.cc", 
                   "--data", "commandline_test.cc", "-o", 
                   "commandline_test.cc"};
    cmd.parse(ac,av);
    suite.err() << "ok\n";
  }
  return ok;
}

bool test_option_name_clash(yat::test::Suite& suite)
{
  bool ok=true;
  suite.err() << "Testing long option name clash ...";
  try {
    CommandLine cmd;
    OptionSwitch op1(cmd, "opt", "bla bla");
    OptionSwitch op2(cmd, "o,opt", "other bla");
    ok=false;
    suite.err() << "failed\n";
  }
  catch (std::runtime_error& e) {
    suite.err() << "ok\n";
  }
  suite.err() << "Testing short option name clash ...";
  try {
    CommandLine cmd;
    OptionSwitch op1(cmd, "o", "bla bla");
    OptionSwitch op2(cmd, "o,opt", "other bla");
    ok=false;
    suite.err() << "failed\n";
  }
  catch (std::runtime_error& e) {
    suite.err() << "ok\n";
  }

  return ok;
}