source: trunk/test/commandline_test.cc @ 1634

// $Id: commandline_test.cc 1634 2008-11-19 22:37:11Z peter $

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

  This file is part of the yat library, http://dev.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 3 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 yat. If not, see <http://www.gnu.org/licenses/>.
*/

#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);
bool test_free_arg(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));
    suite.add(test_free_arg(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);
  OptionArg<std::string> target(cmd, "T,target", "treat DEST as a normal file", 
                                true);
  target.print_arg("=TARGET");
  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() && target.value() && !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;
    }
  }

  suite.err() << "Testing OptionSwitch --no-target...";
  {
    int ac = 2;
    char* av[] = { "test_prog", "--no-target" };
    cmd.parse(ac,av);
    if (target.present() && !target.value())
      suite.err() << "ok\n";
    else {
      suite.err() << "failed\n";
      if (!target.present())
        suite.err() << "target.present() returned false\n";
      if (target.value())
        suite.err() << "target.value() returned true\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");
  OptionArg<double> x(cmd, "x,extra", "a float number");

  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;
    }
  }

  suite.err() << "Testing OptionArg double value -x -6...";
  try {
    int ac = 3;
    char* av[] = { "test_prog", "-x", "-6" };
    cmd.parse(ac,av);
    if (x.value()==-6)
      suite.err() << "ok\n";
    else {
      suite.err() << "failed\n";
      ok =false;
    }
  }
  catch (std::runtime_error& e) {
    ok = false;
    suite.err() << "failed\nexception thrown with what(): " << e.what() << "\n";
  }

  suite.err() << "Testing OptionArg double value --extra -6...";
  try {
    int ac = 3;
    char* av[] = { "test_prog", "--extra", "-6" };
    cmd.parse(ac,av);
    if (x.value()==-6)
      suite.err() << "ok\n";
    else {
      suite.err() << "failed\n";
      ok =false;
    }
  }
  catch (std::runtime_error& e) {
    ok=false;
    suite.err() << "failed\nexception thrown with what(): " << e.what() << "\n";
  }

  suite.err() << "Testing OptionArg::value(T) ... ";
  try {
    int ac = 1;
    char* av[] = { "test_prog"};
    cmd.parse(ac,av);
    n.value(5);
    if (n.present()==false && n.value()==5)
      suite.err() << "ok\n";
    else {
      suite.err() << "failed\n";
      ok = false;
    }
  }
  catch (std::runtime_error& e) {
    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 invalid: test_prog 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 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;
}

bool test_free_arg(yat::test::Suite& suite)
{
  bool ok=true;
  suite.err() << "Testing free arguments ...";

  CommandLine cmd;
  cmd.allow_free_args(2);
  OptionHelp help(cmd);
  int ac = 3;
  char* av[] = { "test_prog", "file", "kl"};
  cmd.parse(ac, av);
  suite.err() << "ok\n";
  return ok;
}