source: trunk/test/commandline.cc @ 2382

// $Id: commandline.cc 2382 2010-12-21 13:16:58Z peter $

/*
  Copyright (C) 2007, 2008, 2009, 2010 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/FileUtil.h"
#include "yat/utility/OptionArg.h"
#include "yat/utility/OptionFile.h"
#include "yat/utility/OptionHelp.h"
#include "yat/utility/OptionSwitch.h"

#include <cassert>
#include <cstdlib>
#include <fstream>
#include <stdexcept>
#include <string>

#include <string.h>

using namespace theplu;
using namespace yat::utility;
bool cmd_help(yat::test::Suite& error);
char** stradup(const char* str[], int size);
void strafree(char** str, int size);
bool test_switch(yat::test::Suite& error);
bool test_arg(yat::test::Suite& error);
void test_exception_msg(yat::test::Suite& error);
bool test_file(yat::test::Suite& error);
bool test_file2(yat::test::Suite& error);
bool test_file3(yat::test::Suite& error);
bool test_file3_(yat::test::Suite& error, const std::string&);
bool test_file4(yat::test::Suite& error);
bool test_file4_(yat::test::Suite& error, const std::string&);
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;

  // Peter, creation of this directory should perhaps be in a more central place
  FileUtil dir("testSubDir");
  if (!dir.exists())
    if (mkdir(dir.path().c_str(), 0755)) {
      suite.err() << "mkdir " << dir.path() << " failed\n";
      return 1;
    }
  FileUtil subdir("testSubDir/commandline_test.dir");
  if (!subdir.exists()) {
    if (mkdir(subdir.path().c_str(), 0755)) {
      suite.err() << "mkdir " << subdir.path() << " failed\n";
      return 1;
    }
  }
  if (subdir.permissions("w")) {
    chmod(subdir.path().c_str(), S_IREAD | S_IWRITE | S_IEXEC);
  }

  try {
    suite.add(cmd_help(suite));
    suite.add(test_switch(suite));
    suite.add(test_arg(suite));
    suite.add(test_file(suite));
    suite.add(test_file2(suite));
    suite.add(test_file3(suite));
    suite.add(test_file4(suite));
    suite.add(test_failures(suite));
    suite.add(test_option_name_clash(suite));
    suite.add(test_free_arg(suite));
    test_exception_msg(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;
}


char** stradup(const char** str, int size)
{
  char** res = new char*[size];
  for (int i = 0; i<size; ++i) {
    res[i] = strdup(str[i]);
    assert(res[i]);
  }
  return res;
}


void strafree(char** str, int size)
{
  for (int i = 0; i<size; ++i) {
    free(str[i]);
  }
}


void test_exception_msg(yat::test::Suite& suite)
{
  // test for ticket 508
  using namespace theplu::yat::utility;
  CommandLine cmd;
  OptionHelp help(cmd, "h,help", "");
  OptionFile indata(cmd, "i,in", "input file", true, true,"r");
  OptionSwitch cmd_memory(cmd, "m", "transpose in a memory cheap manner");
  OptionArg<size_t> cmd_n(cmd, "n", "number of rows to print in each iteration");
  OptionSwitch cmd_numeric(cmd, "numeric", 
                                         "input is a numeric matrix");
  OptionFile outdata(cmd, "o,out", "output file",true, false,"w");
  OptionSwitch verbose(cmd, "v,verbose", "display progress");
  int ac = 2;
  const char* cav[] = { "test_prog", "--haha" };
  char** av = stradup(cav, ac);
  try {
    cmd.parse(ac,av);
  }
  catch (std::runtime_error& e) {
    std::string msg(e.what());
    if (msg.size()<15) {
      suite.xadd(false);
      suite.err() << "Error: short exception message\n" 
                  << "  exception message is: `" << msg 
                  << "' that is " << msg.size() << " characters long.\n" 
                  << "  expected at least 15 characters\n";
    }
  }
  strafree(av, ac);
}


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;
    const char* cav[] = { "test_prog", "-T" };
    char** av = stradup(cav, ac);
    cmd.parse(ac,av);
    if (target.present() && !verbose.present())
      suite.err() << "ok\n";
    else {
      suite.err() << "failed\n";
      ok =false;
    }
    strafree(av, ac);
  }


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

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

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

  suite.err() << "Testing OptionSwitch --no-target...";
  {
    int ac = 2;
    const char* cav[] = { "test_prog", "--no-target" };
    char** av = stradup(cav, ac);
    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;
    }
    strafree(av, ac);
  }
  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;
    const char* cav[] = { "test_prog", "-i", "file" };
    char** av = stradup(cav, ac);
    cmd.parse(ac,av);
    if (input.present())
      suite.err() << "ok\n";
    else {
      suite.err() << "failed\n";
      ok =false;
    }
    strafree(av, ac);
  }

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

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

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

  suite.err() << "Testing OptionArg value --input=\"file called something\"...";
  {
    int ac = 2;
    const char* cav[] = { "test_prog", "--input=\"file called something\"" };
    char** av = stradup(cav, ac);
    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;
    }
    strafree(av, ac);
  }

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


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

  suite.err() << "Testing OptionArg double value -x -6...";
  try {
    int ac = 3;
    const char* cav[] = { "test_prog", "-x", "-6" };
    char** av = stradup(cav, ac);
    cmd.parse(ac,av);
    if (x.value()==-6)
      suite.err() << "ok\n";
    else {
      suite.err() << "failed\n";
      ok =false;
    }
    strafree(av, ac);
  }
  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;
    const char* cav[] = { "test_prog", "--extra", "-6" };
    char** av = stradup(cav, ac);
    cmd.parse(ac,av);
    if (x.value()==-6)
      suite.err() << "ok\n";
    else {
      suite.err() << "failed\n";
      ok =false;
    }
    strafree(av, ac);
  }
  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;
    const char* cav[] = { "test_prog"};
    char** av = stradup(cav, ac);
    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;
    }
    strafree(av, ac);
  }
  catch (std::runtime_error& e) {
    suite.err() << "failed\n";
    ok = false;
  }

  // test for ticket 645
  suite.err() << "Testing error message with -n STRING\n";
  try {
    int ac = 3;
    const char* cav[] = { "test_prog", "-n", "STRING"};
    char** av = stradup(cav, ac);
    try {
      cmd.parse(ac,av);
      strafree(av, ac);
      ok=false;
      suite.err() << "error: expected parse to throw\n"; 
    }
    catch (std::runtime_error& e) {
      strafree(av, ac);
      suite.err() << "expected exception: what(): " << e.what() << "\n";
    }
  }
  catch (std::runtime_error& e) {
    suite.err() << "failed: " << e.what() << "\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;
    const char* cav[] = { "test_prog", "--peter"};
    char** av = stradup(cav, ac);
    try{
      cmd.parse(ac,av);
      suite.err() << "failed\n";
      ok =false;
    }
    catch (...) {
      suite.err() << "ok\n";
    }
    strafree(av, ac);
  }

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


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


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

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


  suite.err() << "Testing invalid: test_prog peter...";
  {
    int ac = 2;
    const char* cav[] = { "test_prog", "peter" };
    char** av = stradup(cav, ac);
    try{
      cmd.parse(ac,av);
      suite.err() << "failed\n";
      ok =false;
    }
    catch (...) {
      suite.err() << "ok\n";
    }
    strafree(av, ac);
  }

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


  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;
    const char* cav[] = { "test_prog", "--clones", "commandline_test.cc", 
                          "--data", "commandline_test.cc", "-o", 
                          "commandline_test.cc"};
    char** av = stradup(cav, ac);
    cmd.parse(ac,av);
    suite.err() << "ok\n";
    strafree(av, ac);
  }
  return ok;
}


bool test_file2(yat::test::Suite& suite)
{
  suite.err() << "Testing OptionFile in write-protected directory... ";

  if (yat::test::run_as_root()) {
    suite.err() << "skipped because user is root\n";
    // skipping means test should still be successful
    return true;
  }

  FileUtil subdir("testSubDir/commandline_test.dir/write-protected");
  if (!subdir.exists()) {
    if (mkdir(subdir.path().c_str(), 0555)) {
      suite.err() << "mkdir " << subdir.path() << " failed\n";
      return false;
    }
  }
  else
    if (!subdir.permissions("w")) {
      suite.err() << subdir.path() << " already exists\n";
      return false;
    }

  FileUtil file("testSubDir/commandline_test.dir/write-protected/out.txt");
  if (file.exists()) {
    suite.err() << "FileUtil::exists returns true unexpectedly\n";
    return false;
  }
  if (file.permissions("w")==0) {
    suite.err() << "FileUtil::permission(\"w\") returns 0 while "
                << "-1 was expected\n";
    return false;
  }

  bool ok=true;
  CommandLine cmd;
  OptionFile out(cmd, "o,out", "output to file", false, false, "w");
  OptionSwitch help(cmd, "h,help", "display this help and exit");

  {
    int ac = 3;
    const char* cav[] = { "test_prog", "--out", 
                    "testSubDir/commandline_test.dir/write-protected/out.txt"};
    char** av = stradup(cav, ac);
    try {
      cmd.parse(ac,av);
      ok =false;
      suite.err() << "failed\n";
    }
    catch (cmd_error& e) {
      suite.err() << "ok\n";
      suite.err() << "catch expected error: " << e.what() << "\n";
    }
    strafree(av, ac);
  }
  return ok;
}


bool test_file3(yat::test::Suite& suite)
{
  suite.err() << "Testing OptionFile in non-existing tree\n";
  // testing error message from OptionFile when tree is not existing
  bool ok=true;
  ok &= test_file3_(suite, "r");
  ok &= test_file3_(suite, "w");
  ok &= test_file3_(suite, "x");
  ok &= test_file3_(suite, "d");
  return ok;
}


bool test_file3_(yat::test::Suite& suite, const std::string& perm)
{
  CommandLine cmd;
  OptionFile file(cmd, "file", "", true, false, perm);

  suite.err() << "Testing OptionFile '" << perm << "' ... "; 
  int ac = 3;
  const char* cav[] = { "test_prog", "--file", "sjhgaw/jmegb/tmp.tmpx"};
  char** av = stradup(cav, ac);
  try {
    cmd.parse(ac,av);
    suite.err() << "no\n";
    strafree(av, ac);
    return false;
  }
  catch (cmd_error& e) {
    suite.err() << "ok\n";
    suite.err() << "catch expected error: " << e.what() << "\n";
  }
  strafree(av, ac);
  return true;
}


bool test_file4(yat::test::Suite& suite)
{
  FileUtil file("testSubDir/commandline_test.dir/test_file4.txt");
  if (!file.exists()) {
    std::ofstream os(file.path().c_str());
  } 
  chmod(file.path().c_str(), 0);

  suite.err() << "Testing OptionFile with no permssions\n";
  bool ok=true;
  ok &= test_file4_(suite, "r");
  ok &= test_file4_(suite, "w");
  ok &= test_file4_(suite, "x");
  ok &= test_file4_(suite, "d");
  return ok;
}


bool test_file4_(yat::test::Suite& suite, const std::string& perm)
{
  CommandLine cmd;
  OptionFile file(cmd, "file", "", true, false, perm);

  suite.err() << "Testing OptionFile '" << perm << "' ... "; 
  try {
    int ac = 3;
    const char* cav[] = { "test_prog", "--file", 
                          "testSubDir/commandline_test.dir/test_file4.txt"};
    char** av = stradup(cav, ac);
    cmd.parse(ac,av);
    suite.err() << "no\n";
    strafree(av, ac);
    return false;
  }
  catch (cmd_error& e) {
    suite.err() << "ok\n";
    suite.err() << "catch expected error: " << e.what() << "\n";
  }
  return true;
}


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;
  const char* cav[] = { "test_prog", "file", "kl"};
  char** av = stradup(cav, ac);
  cmd.parse(ac, av);
  suite.err() << "ok\n";
  strafree(av, ac);
  return ok;
}