command-line-test-suite.cc

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2008 INRIA
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program 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
 *
 * Authors: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
 */
#include "ns3/command-line.h"
#include "ns3/log.h"
#include "ns3/config.h"
#include "ns3/global-value.h"
#include "ns3/system-path.h"
#include "ns3/type-id.h"
#include "ns3/test.h"
#include "ns3/string.h"
#include <cstdlib>
#include <cstdarg>
#include <sstream>

namespace ns3 {

  namespace tests {
    

class CommandLineTestCaseBase : public TestCase
{
public:
  CommandLineTestCaseBase (std::string description);
  virtual ~CommandLineTestCaseBase () {}

  void Parse (CommandLine &cmd, int n, ...);

  static int m_count;
};

int CommandLineTestCaseBase::m_count = 0;

CommandLineTestCaseBase::CommandLineTestCaseBase (std::string description)
  : TestCase (description)
{
}

void
CommandLineTestCaseBase::Parse (CommandLine &cmd, int n, ...)
{
  std::stringstream ss;
  ss << GetParent ()->GetName () << "-testcase-" << m_count << "-" << GetName ();
  ++m_count;
  
  int argc = n + 1;  // test name will go in argv[0], other n to follow
  char ** argv = new char* [argc + 1];  // extra entry for final null
  argv[argc] = 0;

  argv[0] = new char [strlen (ss.str ().c_str ()) + 1];
  strcpy (argv[0], ss.str ().c_str ());
  
  va_list ap;
  va_start (ap, n);
  for (int i = 1; i < argc; ++i)
    {
      char *arg = va_arg (ap, char *);
      argv[i] = new char [strlen (arg) + 1];
      strcpy (argv[i], arg);
    }
  va_end (ap);

  cmd.Parse (argc, argv);

  // Clean up all the new's
  for (int i = 0; i < argc; ++i)
    {
      delete [] argv[i];
    }
  delete [] argv;
}

class CommandLineBooleanTestCase : public CommandLineTestCaseBase
{
public:
  CommandLineBooleanTestCase ();             
  virtual ~CommandLineBooleanTestCase () {}  
private:
  virtual void DoRun (void);                 
};

CommandLineBooleanTestCase::CommandLineBooleanTestCase ()
  : CommandLineTestCaseBase ("boolean")
{
}

void
CommandLineBooleanTestCase::DoRun (void)
{
  CommandLine cmd;
  bool myBool = true;
  bool myDefaultFalseBool = false;

  cmd.AddValue ("my-bool", "help", myBool);
  cmd.AddValue ("my-false-bool", "help", myDefaultFalseBool);

  Parse (cmd, 1, "--my-bool=0");
  NS_TEST_ASSERT_MSG_EQ (myBool, false, "CommandLine did not correctly set a boolean value to false, given 0");

  Parse (cmd, 1, "--my-bool=1");
  NS_TEST_ASSERT_MSG_EQ (myBool, true, "CommandLine did not correctly set a boolean value to true, given 1");

  Parse (cmd, 1, "--my-bool");
  NS_TEST_ASSERT_MSG_EQ (myBool, false, "CommandLine did not correctly toggle a default true boolean value to false, given no argument");

  Parse (cmd, 1, "--my-false-bool");
  NS_TEST_ASSERT_MSG_EQ (myDefaultFalseBool, true, "CommandLine did not correctly toggle a default false boolean value to true, given no argument");

  Parse (cmd, 1, "--my-bool=t");
  NS_TEST_ASSERT_MSG_EQ (myBool, true, "CommandLine did not correctly set a boolean value to true, given 't' argument");

  Parse (cmd, 1, "--my-bool=true");
  NS_TEST_ASSERT_MSG_EQ (myBool, true, "CommandLine did not correctly set a boolean value to true, given \"true\" argument");
}

class CommandLineIntTestCase : public CommandLineTestCaseBase
{
public:
  CommandLineIntTestCase ();                 
  virtual ~CommandLineIntTestCase () {}      
private:                                                         
  virtual void DoRun (void);                 
};

CommandLineIntTestCase::CommandLineIntTestCase ()
  : CommandLineTestCaseBase ("int")
{
}

void
CommandLineIntTestCase::DoRun (void)
{
  CommandLine cmd;
  bool myBool = true;
  int32_t myInt32 = 10;

  cmd.AddValue ("my-bool", "help", myBool);
  cmd.AddValue ("my-int32", "help", myInt32);

  Parse (cmd, 2, "--my-bool=0", "--my-int32=-3");
  NS_TEST_ASSERT_MSG_EQ (myBool, false, "CommandLine did not correctly set a boolean value to false");
  NS_TEST_ASSERT_MSG_EQ (myInt32, -3, "CommandLine did not correctly set an integer value to -3");

  Parse (cmd, 2, "--my-bool=1", "--my-int32=+2");
  NS_TEST_ASSERT_MSG_EQ (myBool, true, "CommandLine did not correctly set a boolean value to true");
  NS_TEST_ASSERT_MSG_EQ (myInt32, +2, "CommandLine did not correctly set an integer value to +2");
}

class CommandLineUnsignedIntTestCase : public CommandLineTestCaseBase
{
public:
  CommandLineUnsignedIntTestCase ();              
  virtual ~CommandLineUnsignedIntTestCase () {}   
private:                                                              
  virtual void DoRun (void);                      
};

CommandLineUnsignedIntTestCase::CommandLineUnsignedIntTestCase ()
  : CommandLineTestCaseBase ("unsigned-int")
{
}

void
CommandLineUnsignedIntTestCase::DoRun (void)
{
  CommandLine cmd;
  bool myBool = true;
  uint32_t myUint32 = 10;

  cmd.AddValue ("my-bool", "help", myBool);
  cmd.AddValue ("my-uint32", "help", myUint32);

  Parse (cmd, 2, "--my-bool=0", "--my-uint32=9");

  NS_TEST_ASSERT_MSG_EQ (myBool, false, "CommandLine did not correctly set a boolean value to false");
  NS_TEST_ASSERT_MSG_EQ (myUint32, 9, "CommandLine did not correctly set an unsigned integer value to 9");
}

class CommandLineStringTestCase : public CommandLineTestCaseBase
{
public:
  CommandLineStringTestCase ();              
  virtual ~CommandLineStringTestCase () {}   
private:                                                         
  virtual void DoRun (void);                 
};

CommandLineStringTestCase::CommandLineStringTestCase ()
  : CommandLineTestCaseBase ("string")
{
}

void
CommandLineStringTestCase::DoRun (void)
{
  CommandLine cmd;
  uint32_t myUint32 = 10;
  std::string myStr = "MyStr";

  cmd.AddValue ("my-uint32", "help", myUint32);
  cmd.AddValue ("my-str", "help", myStr);

  Parse (cmd, 2, "--my-uint32=9", "--my-str=XX");

  NS_TEST_ASSERT_MSG_EQ (myUint32, 9, "CommandLine did not correctly set an unsigned integer value to 9");
  NS_TEST_ASSERT_MSG_EQ (myStr, "XX", "CommandLine did not correctly set a string value to \"XX\"");
}

class CommandLineOrderTestCase : public CommandLineTestCaseBase
{
public:
  CommandLineOrderTestCase ();              
  virtual ~CommandLineOrderTestCase () {}   
private:
  virtual void DoRun (void);                 
};

CommandLineOrderTestCase::CommandLineOrderTestCase ()
  : CommandLineTestCaseBase ("order")
{
}

void
CommandLineOrderTestCase::DoRun (void)
{
  CommandLine cmd;
  uint32_t myUint32 = 0;

  cmd.AddValue ("my-uint32", "help", myUint32);

  Parse (cmd, 2, "--my-uint32=1", "--my-uint32=2");

  NS_TEST_ASSERT_MSG_EQ (myUint32, 2, "CommandLine did not correctly set an unsigned integer value to 2");
}

class CommandLineInvalidTestCase : public CommandLineTestCaseBase
{
public:
  CommandLineInvalidTestCase ();              
  virtual ~CommandLineInvalidTestCase () {}   
private:
  virtual void DoRun (void);                 
};

CommandLineInvalidTestCase::CommandLineInvalidTestCase ()
  : CommandLineTestCaseBase ("invalid")
{
}

void
CommandLineInvalidTestCase::DoRun (void)
{
  CommandLine cmd;
  uint32_t myUint32 = 0;

  cmd.AddValue ("my-uint32", "help", myUint32);

  Parse (cmd, 2, "quack", "--my-uint32=5");

  NS_TEST_ASSERT_MSG_EQ (myUint32, 5, "CommandLine did not correctly set an unsigned integer value to 5");
}

class CommandLineNonOptionTestCase : public CommandLineTestCaseBase
{
public:
  CommandLineNonOptionTestCase ();              
  virtual ~CommandLineNonOptionTestCase () {}   
private:
  virtual void DoRun (void);                 
};

CommandLineNonOptionTestCase::CommandLineNonOptionTestCase ()
  : CommandLineTestCaseBase ("nonoption")
{
}

void
CommandLineNonOptionTestCase::DoRun (void)
{
  CommandLine cmd;
  bool myBool = false;
  int32_t myInt = 1;
  std::string myStr = "MyStr";

  cmd.AddNonOption ("my-bool", "help", myBool);
  cmd.AddNonOption ("my-int", "help", myInt);
  cmd.AddNonOption ("my-str", "help", myStr);

  Parse (cmd, 2, "true", "5");

  NS_TEST_ASSERT_MSG_EQ (myBool, true, "CommandLine did not correctly set a boolean non-option");
  NS_TEST_ASSERT_MSG_EQ (myInt, 5, "CommandLine did not correctly set an integer non-option value to 5");
  NS_TEST_ASSERT_MSG_EQ (myStr, "MyStr", "CommandLine did not leave a non-option unmodified.");

  Parse (cmd, 5, "false", "6", "newValue", "extraVal1", "extraVal2");
  
  NS_TEST_ASSERT_MSG_EQ (myBool, false, "CommandLine did not correctly set a boolean non-option");
  NS_TEST_ASSERT_MSG_EQ (myInt
, 6, "CommandLine did not correctly set an integer non-option value to 5");
  NS_TEST_ASSERT_MSG_EQ (myStr, "newValue", "CommandLine did not leave a non-option unmodified.");

  NS_TEST_ASSERT_MSG_EQ (cmd.GetNExtraNonOptions (), 2, "CommandLine did not parse the correct number of extra non-options.");
  NS_TEST_ASSERT_MSG_EQ (cmd.GetExtraNonOption (0), "extraVal1", "CommandLine did not correctly get one extra non-option");
  NS_TEST_ASSERT_MSG_EQ (cmd.GetExtraNonOption (1), "extraVal2", "CommandLine did not correctly get two extra non-option");
}

class CommandLineTestSuite : public TestSuite
{
public:
  CommandLineTestSuite ();                   
};

CommandLineTestSuite::CommandLineTestSuite ()
  : TestSuite ("command-line")
{
  AddTestCase (new CommandLineBooleanTestCase);
  AddTestCase (new CommandLineIntTestCase);
  AddTestCase (new CommandLineUnsignedIntTestCase);
  AddTestCase (new CommandLineStringTestCase);
  AddTestCase (new CommandLineOrderTestCase);
  AddTestCase (new CommandLineInvalidTestCase);
  AddTestCase (new CommandLineNonOptionTestCase);
}

static CommandLineTestSuite g_commandLineTestSuite;


  }  // namespace tests

}  // namespace ns3