Update of test.py

test.py

 #! /usr/bin/env python
 ## -*- Mode: python; py-indent-offset: 4; indent-tabs-mode: nil; coding: utf-8; -*-
 #
 # Copyright (c) 2009 University of Washington
 #
 # 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
 #
 from __future__ import print_function
 import os
 import sys
 import time
-import optparse
+import argparse
 import subprocess
 import threading
 import signal
-import xml.dom.minidom
 import shutil
-import re
+import logging
+import csv
+import io
 
 from utils import get_list_from_file
 
+log = logging.getLogger("ns3log")
+log.addHandler(logging.StreamHandler())
+
 try:
     import queue
 except ImportError:
     import Queue as queue
 #
 # XXX This should really be part of a waf command to list the configuration
 # items relative to optional ns-3 pieces.
 #
 # A list of interesting configuration items in the waf configuration·
 # cache which we may be interested in when deciding on which examples
@@ skipping 525 matching lines @@
 # Examples, however, are a different story.  In that case, we are just given
 # a list of examples that could be run.  Instead of just failing, for example,
 # nsc-tcp-zoo if NSC is not present, we look into the waf saved configuration
 # for relevant configuration items.··
 #
 # XXX This function pokes around in the waf internal state file.  To be a
 # little less hacky, we should add a commmand to waf to return this info
 # and use that result.
 #
 def read_waf_config():
-    for line in open(".lock-waf_" + sys.platform + "_build", "rt"):
+    lock_file = ".lock-waf_" + sys.platform + "_build"
+
+    for line in open(lock_file, "rt"):
         if line.startswith("top_dir ="):
             key, val = line.split('=')
             top_dir = eval(val.strip())
         if line.startswith("out_dir ="):
             key, val = line.split('=')
             out_dir = eval(val.strip())
     global NS3_BASEDIR
     NS3_BASEDIR = top_dir
     global NS3_BUILDDIR
     NS3_BUILDDIR = out_dir
     for line in open("%s/c4che/_cache.py" % out_dir).readlines():
         for item in interesting_config_items:
             if line.startswith(item):
                 exec(line, globals())
-
-    if options.verbose:
-        for item in interesting_config_items:
-            print("%s ==" % item, eval(item))
+                log.info("%s == %r" % (item, eval(item)))
 
 #
 # It seems pointless to fork a process to run waf to fork a process to run
 # the test runner, so we just run the test runner directly.  The main thing·
 # that waf would do for us would be to sort out the shared library path but
 # we can deal with that easily and do here.
 #
 # There can be many different ns-3 repositories on a system, and each has·
 # its own shared libraries, so ns-3 doesn't hardcode a shared library search
 # path -- it is cooked up dynamically, so we do that too.
@@ skipping 15 matching lines @@
         if key == "PYTHONPATH":
             have_PYTHONPATH = True
 
     pypath = os.environ["PYTHONPATH"] = os.path.join (NS3_BUILDDIR, "bindings", "python")
 
     if not have_PYTHONPATH:
         os.environ["PYTHONPATH"] = pypath
     else:
         os.environ["PYTHONPATH"] += ":" + pypath
 
-    if options.verbose:
-        print("os.environ[\"PYTHONPATH\"] == %s" % os.environ["PYTHONPATH"])
+    log.debug("os.environ[\"PYTHONPATH\"] == %s" % os.environ["PYTHONPATH"])
 
     if sys.platform == "darwin":
         if not have_DYLD_LIBRARY_PATH:
             os.environ["DYLD_LIBRARY_PATH"] = ""
         for path in NS3_MODULE_PATH:
             os.environ["DYLD_LIBRARY_PATH"] += ":" + path
-        if options.verbose:
-            print("os.environ[\"DYLD_LIBRARY_PATH\"] == %s" % os.environ["DYLD_LIBRARY_PATH"])
+        log.debug("os.environ[\"DYLD_LIBRARY_PATH\"] == %s" % os.environ["DYLD_LIBRARY_PATH"])
     elif sys.platform == "win32":
         if not have_PATH:
             os.environ["PATH"] = ""
         for path in NS3_MODULE_PATH:
             os.environ["PATH"] += ';' + path
-        if options.verbose:
-            print("os.environ[\"PATH\"] == %s" % os.environ["PATH"])
+        log.debug("os.environ[\"PATH\"] == %s" % os.environ["PATH"])
     elif sys.platform == "cygwin":
         if not have_PATH:
             os.environ["PATH"] = ""
         for path in NS3_MODULE_PATH:
             os.environ["PATH"] += ":" + path
-        if options.verbose:
-            print("os.environ[\"PATH\"] == %s" % os.environ["PATH"])
+        log.debug("os.environ[\"PATH\"] == %s" % os.environ["PATH"])
     else:
         if not have_LD_LIBRARY_PATH:
             os.environ["LD_LIBRARY_PATH"] = ""
         for path in NS3_MODULE_PATH:
             os.environ["LD_LIBRARY_PATH"] += ":" + str(path)
-        if options.verbose:
-            print("os.environ[\"LD_LIBRARY_PATH\"] == %s" % os.environ["LD_LIBRARY_PATH"])
+        log.debug("os.environ[\"LD_LIBRARY_PATH\"] == %s" % os.environ["LD_LIBRARY_PATH"])
 
 #
 # Short note on generating suppressions:
 #
 # See the valgrind documentation for a description of suppressions.  The easiest
 # way to generate a suppression expression is by using the valgrind·
 # --gen-suppressions option.  To do that you have to figure out how to run the·
 # test in question.
 #
 # If you do "test.py -v -g -s <suitename> then test.py will output most of what
@@ skipping 78 matching lines @@
             path_cmd = os.path.join (build_path, shell_command)
         else:
             path_cmd = os.path.join (NS3_BUILDDIR, shell_command)
 
     if valgrind:
         cmd = "valgrind --suppressions=%s --leak-check=full --show-reachable=yes --error-exitcode=2 %s" % (suppressions_path,·
             path_cmd)
     else:
         cmd = path_cmd
 
-    if options.verbose:
-        print("Synchronously execute %s" % cmd)
+    log.info("Synchronously execute %s" % cmd)
 
     start_time = time.time()
     proc = subprocess.Popen(cmd, shell = True, cwd = directory, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
     stdout_results, stderr_results = proc.communicate()
     elapsed_time = time.time() - start_time
 
     retval = proc.returncode
     try:
         stdout_results = stdout_results.decode()
     except UnicodeDecodeError:
@@ skipping 12 matching lines @@
     # errors are important.  We want to detect *any* leaks, so the way to do·
     # that is to look for the presence of a valgrind leak summary section.
     #
     # If another error has occurred (like a test suite has failed), we don't·
     # want to trump that error, so only do the valgrind output scan if the·
     # test has otherwise passed (return code was zero).
     #
     if valgrind and retval == 0 and "== LEAK SUMMARY:" in stderr_results:
         retval = 2
 ····
-    if options.verbose:
         print("Return code = ", retval)
-        print("stderr = ", stderr_results)
+        log.info("stderr = ", stderr_results)
 
     return (retval, stdout_results, stderr_results, elapsed_time)
 
 #
 # This class defines a unit of testing work.  It will typically refer to
 # a test suite to run using the test-runner, or an example to run directly.
 #
 class Job:
     def __init__(self):
         self.is_break = False
@@ skipping 146 matching lines @@
             if thread_exit == True:
                 job.set_is_break(True)
                 self.output_queue.put(job)
                 continue
 
             #
             # If we are actually supposed to skip this job, do so.  Note that
             # if is_skip is true, returncode is undefined.
             #
             if job.is_skip:
-                if options.verbose:
-                    print("Skip %s" % job.shell_command)
+                log.info("Skip %s" % job.shell_command)
                 self.output_queue.put(job)
                 continue
 
             #
             # Otherwise go about the business of running tests as normal.
             #
             else:
-                if options.verbose:
-                    print("Launch %s" % job.shell_command)
+                log.info("Launch %s" % job.shell_command)
 
                 if job.is_example or job.is_pyexample:
                     #
                     # If we have an example, the shell command is all we need to
                     # know.  It will be something like "examples/udp/udp-echo" or·
                     # "examples/wireless/mixed-wireless.py"
                     #
                     (job.returncode, standard_out, standard_err, et) = run_job_synchronously(job.shell_command,·
                         job.cwd, options.valgrind, job.is_pyexample, job.build_path)
                 else:
                     #
                     # If we're a test suite, we need to provide a little more info
                     # to the test runner, specifically the base directory and temp
                     # file name
                     #
                     if options.update_data:
                         update_data = '--update-data'
                     else:
                         update_data = ''
                     (job.returncode, standard_out, standard_err, et) = run_job_synchronously(job.shell_command +·
                         " --xml --tempdir=%s --out=%s %s" % (job.tempdir, job.tmp_file_name, update_data),·
                         job.cwd, options.valgrind, False)
 
                 job.set_elapsed_time(et)
 
-                if options.verbose:
-                    print("returncode = %d" % job.returncode)
-                    print("---------- begin standard out ----------")
-                    print(standard_out)
-                    print("---------- begin standard err ----------")
-                    print(standard_err)
-                    print("---------- end standard err ----------")
+                log.info("returncode = %d" % job.returncode)
+                log.info("---------- begin standard out ----------")
+                log.info(standard_out)
+                log.info("---------- begin standard err ----------")
+                log.info(standard_err)
+                log.info("---------- end standard err ----------")
 
                 self.output_queue.put(job)
 
+def list_tests(test_runner_name, constrain=None):
+    """
+    Return a dict
+    """
+    path_cmd = os.path.join("utils", test_runner_name)
+    path_cmd += " --print-test-name-list --print-test-types {constraint}".format(
+        constraint= "--test-type=%s" % constrain if constrain else ""
+    )
+    (rc, standard_out, standard_err, et) = run_job_synchronously(path_cmd, os.getcwd(), False, False)
+    if rc != 0:
+        # This is usually a sign that ns-3 crashed or exited uncleanly
+        print('test.py error:  test-runner return code returned {}'.format(rc))
+        print('To debug, try running {}\n'.format('\'./waf --run \"test-runner --list\"\''))
+        return
+
+    if isinstance(standard_out, bytes):
+        standard_out = standard_out.decode()
+
+    reader = csv.DictReader(io.StringIO(standard_out), fieldnames=["kind", "name"], delimiter=' ', skipinitialspace=True)
+
+    return dict((row['name'], row['kind']) for row in reader)
 #
 # This is the main function that does the work of interacting with the
 # test-runner itself.
 #
-def run_tests():
+def run_tests(unknown_args):
+
+    if options.debug:
+        log.setLevel(logging.DEBUG)
     #
     # Pull some interesting configuration information out of waf, primarily
     # so we can know where executables can be found, but also to tell us what
     # pieces of the system have been built.  This will tell us what examples·
     # are runnable.
     #
     read_waf_config()
 
     #
     # Set the proper suffix.
@@ skipping 28 matching lines @@
         # file, we can only ask waf to build what we know will be necessary.
         # For example, if the user only wants to run BVT tests, we only have
         # to build the test-runner and can ignore all of the examples.
         #
         # If the user only wants to run a single example, then we can just build
         # that example.
         #
         # If there is no constraint, then we have to build everything since the
         # user wants to run everything.
         #
-        if options.kinds or options.list or (len(options.constrain) and options.constrain in core_kinds):
+        if options.kinds or options.list or (options.constrain and options.constrain in core_kinds):
             if sys.platform == "win32":
                 waf_cmd = sys.executable + " waf --target=test-runner"
             else:
                 waf_cmd = sys.executable + " waf --target=test-runner"
         elif len(options.example):
             if sys.platform == "win32": #Modify for windows
                 waf_cmd = sys.executable + " waf --target=%s" % os.path.basename(options.example)
             else:
                 waf_cmd = sys.executable + " waf --target=%s" % os.path.basename(options.example)
 
         else:
             if sys.platform == "win32": #Modify for windows
                 waf_cmd = sys.executable + " waf"
             else:
                 waf_cmd = sys.executable + " waf"
 
-        if options.verbose:
-            print("Building: %s" % waf_cmd)
+        log.info("Building: %s" % waf_cmd)
 
         proc = subprocess.Popen(waf_cmd, shell = True)
         proc.communicate()
         if proc.returncode:
             print("Waf died. Not running tests", file=sys.stderr)
             return proc.returncode
 
 
     #
     # Dynamically set up paths.
     #
     make_paths()
 
     #
     # Get the information from the build status file.
     #
     build_status_file = os.path.join (NS3_BUILDDIR, 'build-status.py')
     if os.path.exists(build_status_file):
         ns3_runnable_programs = get_list_from_file(build_status_file, "ns3_runnable_programs")
         ns3_runnable_scripts = get_list_from_file(build_status_file, "ns3_runnable_scripts")
     else:
-        print('The build status file was not found.  You must do waf build before running test.py.', file=sys.stderr)
+        print('The build status file was not found. You must do waf build before running test.py.', file=sys.stderr)
         sys.exit(2)
 
     #
     # Make a dictionary that maps the name of a program to its path.
     #
     ns3_runnable_programs_dictionary = {}
     for program in ns3_runnable_programs:
         # Remove any directory names from path.
         program_name = os.path.basename(program)
         ns3_runnable_programs_dictionary[program_name] = program
@@ skipping 49 matching lines @@
     os.environ["NS_LOG"] = ""
 
     #
     # There are a couple of options that imply we can to exit before starting
     # up a bunch of threads and running tests.  Let's detect these cases and·
     # handle them without doing all of the hard work.
     #
     if options.kinds:
         path_cmd = os.path.join("utils", test_runner_name + " --print-test-type-list")
         (rc, standard_out, standard_err, et) = run_job_synchronously(path_cmd, os.getcwd(), False, False)
-        print(standard_out.decode())
+        print(standard_out)
 
     if options.list:
-        if len(options.constrain):
-            path_cmd = os.path.join("utils", test_runner_name + " --print-test-name-list --print-test-types --test-type=%s" % options.constrain)
-        else:
-            path_cmd = os.path.join("utils", test_runner_name + " --print-test-name-list --print-test-types")
-        (rc, standard_out, standard_err, et) = run_job_synchronously(path_cmd, os.getcwd(), False, False)
-        if rc != 0:
-            # This is usually a sign that ns-3 crashed or exited uncleanly
-            print(('test.py error:  test-runner return code returned {}'.format(rc)))
-            print(('To debug, try running {}\n'.format('\'./waf --run \"test-runner --print-test-name-list\"\'')))
-            return
-        if isinstance(standard_out, bytes):
-            standard_out = standard_out.decode()
-        list_items = standard_out.split('\n')
-        list_items.sort()
+        tests = list_tests(test_runner_name, options.constrain)
         print("Test Type    Test Name")
         print("---------    ---------")
-        for item in list_items:
-            if len(item.strip()):
-                print(item)
+        for name, desc  in tests.items():
+            line = "{:<12}{}".format(desc, name)
+            print(line)
         example_names_original.sort()
         for item in example_names_original:
                 print("example     ", item)
         print()
 
     if options.kinds or options.list:
         return
 
     #
     # We communicate results in two ways.  First, a simple message relating·
@@ skipping 50 matching lines @@
     #  ./test.py --constrain=core:                          run all of the suites of all kinds
     #  ./test.py --constrain=unit:                          run all unit suites
     #  ./test.py --suite=some-test-suite:                   run a single suite
     #  ./test.py --example=examples/udp/udp-echo:           run single example
     #  ./test.py --pyexample=examples/wireless/mixed-wireless.py:  run python example
     #  ./test.py --suite=some-suite --example=some-example: run the single suite
     #
     # We can also use the --constrain option to provide an ordering of test·
     # execution quite easily.
     #
-    if len(options.suite):
+    available_tests = list_tests(test_runner_name)
+    suite_list = []
+    for suite in options.suite:
         # See if this is a valid test suite.
-        path_cmd = os.path.join("utils", test_runner_name + " --print-test-name-list")
-        (rc, suites, standard_err, et) = run_job_synchronously(path_cmd, os.getcwd(), False, False)
-        if isinstance(suites, bytes):
-            suites = suites.decode()
-        if options.suite in suites.split('\n'):
-            suites = options.suite + "\n"
-        else:
-            print('The test suite was not run because an unknown test suite name was requested.', file=sys.stderr)
+        if suite not in available_tests.keys():
+            print('The test suite was not run because an unknown test suite "%s" name was requested.' % suite, file=sys.stderr)
             sys.exit(2)
+        suite_list.append(suite)
 
-    elif len(options.example) == 0 and len(options.pyexample) == 0:
-        if len(options.constrain):
+    if len(options.example) == 0 and len(options.pyexample) == 0:
+        if options.constrain:
             path_cmd = os.path.join("utils", test_runner_name + " --print-test-name-list --test-type=%s" % options.constrain)
             (rc, suites, standard_err, et) = run_job_synchronously(path_cmd, os.getcwd(), False, False)
         else:
             path_cmd = os.path.join("utils", test_runner_name + " --print-test-name-list")
             (rc, suites, standard_err, et) = run_job_synchronously(path_cmd, os.getcwd(), False, False)
-    else:
-        suites = ""
 
     #
     # suite_list will either a single test suite name that the user has·
     # indicated she wants to run or a list of test suites provided by
     # the test-runner possibly according to user provided constraints.
     # We go through the trouble of setting up the parallel execution·
     # even in the case of a single suite to avoid having two process the
     # results in two different places.
     #

[Tommaso Pecorella, 2016/04/04 13:32:41]

If there's no more code following this comment, perhaps its position is wrong.

-    if isinstance(suites, bytes):
-        suites = suites.decode()
-    suite_list = suites.split('\n')
 
     #
     # Performance tests should only be run when they are requested,
     # i.e. they are not run by default in test.py.
     #
     if options.constrain != 'performance':
 
         # Get a list of all of the performance tests.
         path_cmd = os.path.join("utils", test_runner_name + " --print-test-name-list --test-type=%s" % "performance")
         (rc, performance_tests, standard_err, et) = run_job_synchronously(path_cmd, os.getcwd(), False, False)
@@ skipping 63 matching lines @@
         test = test.strip()
         if len(test):
             job = Job()
             job.set_is_example(False)
             job.set_is_pyexample(False)
             job.set_display_name(test)
             job.set_tmp_file_name(os.path.join(testpy_output_dir, "%s.xml" % test))
             job.set_cwd(os.getcwd())
             job.set_basedir(os.getcwd())
             job.set_tempdir(testpy_output_dir)
-            if (options.multiple):
-                multiple = ""
-            else:
-                multiple = " --stop-on-failure"
-            if (len(options.fullness)):
-                fullness = options.fullness.upper()
-                fullness = " --fullness=%s" % fullness
-            else:
-                fullness = " --fullness=QUICK"
 
-            path_cmd = os.path.join("utils", test_runner_name + " --test-name=%s%s%s" % (test, multiple, fullness))
+            path_cmd = os.path.join("utils", test_runner_name)
+            path_cmd += " --test-name={name} {multiple} --fullness={fullness} {verbose} {args}".format(
+                name=test,
+                multiple= "" if options.multiple else " --stop-on-failure",
+                fullness=options.fullness,
+                verbose="--verbose" if options.verbose else "",
+                args= ""
+            )
 
             job.set_shell_command(path_cmd)
 
             if options.valgrind and test in core_valgrind_skip_tests:
                 job.set_is_skip(True)
 
             # Skip tests that will fail if NSC is missing.
             if not NSC_ENABLED and test in core_nsc_missing_skip_tests:
                 job.set_is_skip(True)
 
-            if options.verbose:
-                print("Queue %s" % test)
+            log.debug("Queue %s" % test)
 
             input_queue.put(job)
             jobs = jobs + 1
             total_tests = total_tests + 1
 ····
     #
     # We've taken care of the discovered or specified test suites.  Now we
     # have to deal with examples run as smoke tests.  We have a list of all of
     # the example programs it makes sense to try and run.  Each example will
     # have a condition associated with it that must evaluate to true for us
@@ skipping 25 matching lines @@
     #
     #  ./test.py:                                           run all of the examples
     #  ./test.py --constrain=unit                           run no examples
     #  ./test.py --constrain=example                        run all of the examples
     #  ./test.py --suite=some-test-suite:                   run no examples
     #  ./test.py --example=some-example:                    run the single example
     #  ./test.py --suite=some-suite --example=some-example: run the single example
     #
     #
     if len(options.suite) == 0 and len(options.example) == 0 and len(options.pyexample) == 0:
-        if len(options.constrain) == 0 or options.constrain == "example":
+        if not options.constrain  or options.constrain == "example":
             if ENABLE_EXAMPLES:
                 for name, test, do_run, do_valgrind_run in example_tests:
                     # Remove any arguments and directory names from test.
                     test_name = test.split(' ', 1)[0]·
                     test_name = os.path.basename(test_name)
 
                     # Don't try to run this example if it isn't runnable.
                     if test_name in ns3_runnable_programs_dictionary:
                         if eval(do_run):
                             job = Job()
                             job.set_is_example(True)
                             job.set_is_pyexample(False)
                             job.set_display_name(name)
                             job.set_tmp_file_name("")
                             job.set_cwd(testpy_output_dir)
                             job.set_basedir(os.getcwd())
                             job.set_tempdir(testpy_output_dir)
                             job.set_shell_command(test)
                             job.set_build_path(options.buildpath)
 
                             if options.valgrind and not eval(do_valgrind_run):
                                 job.set_is_skip (True)
 
-                            if options.verbose:
-                                print("Queue %s" % test)
+                            log.info("Queue %s" % test)
 
                             input_queue.put(job)
                             jobs = jobs + 1
                             total_tests = total_tests + 1
 
     elif len(options.example):
         # Add the proper prefix and suffix to the example name to
         # match what is done in the wscript file.
         example_name = "%s%s-%s%s" % (APPNAME, VERSION, options.example, BUILD_PROFILE_SUFFIX)
 
         # Don't try to run this example if it isn't runnable.
         if example_name not in ns3_runnable_programs_dictionary:
             print("Example %s is not runnable." % example_name)
         else:
             #
             # If you tell me to run an example, I will try and run the example
             # irrespective of any condition.
             #
             example_path = ns3_runnable_programs_dictionary[example_name]
             example_path = os.path.abspath(example_path)
+            example_path += " " + ' '.join(unknown_args)
+
             job = Job()
             job.set_is_example(True)
             job.set_is_pyexample(False)
             job.set_display_name(example_path)
             job.set_tmp_file_name("")
             job.set_cwd(testpy_output_dir)
             job.set_basedir(os.getcwd())
             job.set_tempdir(testpy_output_dir)
             job.set_shell_command(example_path)
             job.set_build_path(options.buildpath)
 
-            if options.verbose:
-                print("Queue %s" % example_name)
+            log.debug("Queue %s" % example_name)
 
             input_queue.put(job)
             jobs = jobs + 1
             total_tests = total_tests + 1
 
     #
     # Run some Python examples as smoke tests.  We have a list of all of
     # the example programs it makes sense to try and run.  Each example will
     # have a condition associated with it that must evaluate to true for us
     # to try and execute it.  This is used to determine if the example has
     # a dependency that is not satisfied.
     #
     # We don't care at all how the trace files come out, so we just write them·
     # to a single temporary directory.
     #
     # We need to figure out what python examples to execute.  We are either·
     # given one pyexample explicitly via the --pyexample option, or we
     # need to walk the list of python examples
     #
     # This translates into allowing the following options with respect to the·
     # suites
     #
     #  ./test.py --constrain=pyexample           run all of the python examples
     #  ./test.py --pyexample=some-example.py:    run the single python example
     #
     if len(options.suite) == 0 and len(options.example) == 0 and len(options.pyexample) == 0:
-        if len(options.constrain) == 0 or options.constrain == "pyexample":
+        if not options.constrain or options.constrain == "pyexample":
             if ENABLE_EXAMPLES:
                 for test, do_run in python_tests:
                     # Remove any arguments and directory names from test.
                     test_name = test.split(' ', 1)[0]·
                     test_name = os.path.basename(test_name)
 
                     # Don't try to run this example if it isn't runnable.
                     if test_name in ns3_runnable_scripts:
                         if eval(do_run):
                             job = Job()
@@ skipping 18 matching lines @@
                                 job.set_is_skip (True)
 
                             #
                             # The user can disable python bindings, so we need
                             # to pay attention to that and give some feedback
                             # that we're not testing them
                             #
                             if not ENABLE_PYTHON_BINDINGS:
                                 job.set_is_skip (True)
 
-                            if options.verbose:
-                                print("Queue %s" % test)
+                            log.debug("Queue %s" % test)
 
                             input_queue.put(job)
                             jobs = jobs + 1
                             total_tests = total_tests + 1
 
     elif len(options.pyexample):
         # Don't try to run this example if it isn't runnable.
         example_name = os.path.basename(options.pyexample)
         if example_name not in ns3_runnable_scripts:
             print("Example %s is not runnable." % example_name)
         else:
             #
             # If you tell me to run a python example, I will try and run the example
             # irrespective of any condition.
             #
             job = Job()
             job.set_is_pyexample(True)
             job.set_display_name(options.pyexample)
             job.set_tmp_file_name("")
             job.set_cwd(testpy_output_dir)
             job.set_basedir(os.getcwd())
             job.set_tempdir(testpy_output_dir)
             job.set_shell_command(options.pyexample)
             job.set_build_path("")
 
-            if options.verbose:
-                print("Queue %s" % options.pyexample)
+            log.debug("Queue %s" % options.pyexample)
 
             input_queue.put(job)
             jobs = jobs + 1
             total_tests = total_tests + 1
 
     #
     # Tell the worker threads to pack up and go home for the day.  Each one
     # will exit when they see their is_break task.
     #
     for i in range(processors):
@@ skipping 140 matching lines @@
                 if job.returncode == 0 or job.returncode == 1 or job.returncode == 2:
                     f_to = open(xml_results_file, 'a')
                     f_from = open(job.tmp_file_name)
                     f_to.write(f_from.read())
                     f_to.close()
                     f_from.close()
                 else:
                     f = open(xml_results_file, 'a')
                     f.write("<Test>\n")
                     f.write("  <Name>%s</Name>\n" % job.display_name)
-                    f.write('  <Result>CRASH</Suite>\n')
+                    f.write('  <Result>CRASH</Result>\n')
                     f.write("</Test>\n")
                     f.close()
 
                     if job.returncode == 2:
                         f = open(xml_results_file, 'a')
                         f.write("<Test>\n")
                         f.write("  <Name>%s</Name>\n" % job.display_name)
                         f.write('  <Result>VALGR</Result>\n')
                         f.write("</Test>\n")
                         f.close()
@@ skipping 81 matching lines @@
     #
     if not options.retain:
         shutil.rmtree(testpy_output_dir)
 
     if passed_tests + skipped_tests == total_tests:
         return 0 # success
     else:
         return 1 # catchall for general errors
 
 def main(argv):
-    parser = optparse.OptionParser()
-    parser.add_option("-b", "--buildpath", action="store", type="string", dest="buildpath", default="",
+    parser = argparse.ArgumentParser(description='ns3 test helper')
+    parser.add_argument("-b", "--buildpath", action="store", type=str, dest="buildpath", default="",
                       metavar="BUILDPATH",
                       help="specify the path where ns-3 was built (defaults to the build directory for the current variant)")
 
-    parser.add_option("-c", "--constrain", action="store", type="string", dest="constrain", default="",
+    parser.add_argument("-c", "--constrain", action="store", choices=core_kinds + ["example"], dest="constrain",·
                       metavar="KIND",
                       help="constrain the test-runner by kind of test")
 
-    parser.add_option("-d", "--duration", action="store_true", dest="duration", default=False,
+    parser.add_argument("-d", "--duration", action="store_true", dest="duration", default=False,
                       help="print the duration of each test suite and example")
 
-    parser.add_option("-e", "--example", action="store", type="string", dest="example", default="",
-                      metavar="EXAMPLE",
+    parser.add_argument("-e", "--example", type=str,  metavar="EXAMPLE",
                       help="specify a single example to run (no relative path is needed)")
 
-    parser.add_option("-u", "--update-data", action="store_true", dest="update_data", default=False,
+    parser.add_argument("-u", "--update-data", action="store_true", dest="update_data", default=False,
                       help="If examples use reference data files, get them to re-generate them")
 
-    parser.add_option("-f", "--fullness", action="store", type="string", dest="fullness", default="QUICK",
-                      metavar="FULLNESS",
-                      help="choose the duration of tests to run: QUICK, EXTENSIVE, or TAKES_FOREVER, where EXTENSIVE includes QUICK and TAKES_FOREVER includes QUICK and EXTENSIVE (only QUICK tests are run by default)")
+    parser.add_argument("-f", "--fullness", action="store", choices=["QUICK", "EXTENSIVE", "TAKES_FOREVER"],
+            dest="fullness", default="QUICK", metavar="FULLNESS",
+            help="choose the duration of tests to run: QUICK, EXTENSIVE, or TAKES_FOREVER, where EXTENSIVE includes QUICK and TAKES_FOREVER includes QUICK and EXTENSIVE (only QUICK tests are run by default)")
 
-    parser.add_option("-g", "--grind", action="store_true", dest="valgrind", default=False,
+    parser.add_argument("-g", "--grind", action="store_true", dest="valgrind", default=False,
                       help="run the test suites and examples using valgrind")
 
-    parser.add_option("-k", "--kinds", action="store_true", dest="kinds", default=False,
+    parser.add_argument("-k", "--kinds", action="store_true", dest="kinds", default=False,
                       help="print the kinds of tests available")
 
-    parser.add_option("-l", "--list", action="store_true", dest="list", default=False,
+    parser.add_argument("-l", "--list", action="store_true", dest="list", default=False,
                       help="print the list of known tests")
 
-    parser.add_option("-m", "--multiple", action="store_true", dest="multiple", default=False,
+    parser.add_argument("-m", "--multiple", action="store_true", dest="multiple", default=False,
                       help="report multiple failures from test suites and test cases")
 
-    parser.add_option("-n", "--nowaf", action="store_true", dest="nowaf", default=False,
+    parser.add_argument("-n", "--nowaf", action="store_true", dest="nowaf", default=False,
                       help="do not run waf before starting testing")
 
-    parser.add_option("-p", "--pyexample", action="store", type="string", dest="pyexample", default="",
+    parser.add_argument("-p", "--pyexample", action="store", type=str, dest="pyexample", default="",
                       metavar="PYEXAMPLE",
                       help="specify a single python example to run (with relative path)")
 
-    parser.add_option("-r", "--retain", action="store_true", dest="retain", default=False,
+    parser.add_argument("-r", "--retain", action="store_true", dest="retain", default=False,
                       help="retain all temporary files (which are normally deleted)")
 
-    parser.add_option("-s", "--suite", action="store", type="string", dest="suite", default="",
-                      metavar="TEST-SUITE",
-                      help="specify a single test suite to run")
+    parser.add_argument("-s", "--suite", action="append", default=[], metavar="TEST-SUITE",
+                      help="specify a test suite to run. Can appear several times")
 
-    parser.add_option("-t", "--text", action="store", type="string", dest="text", default="",
-                      metavar="TEXT-FILE",
+    parser.add_argument("-t", "--text", action="store", type=str, default="", metavar="TEXT-FILE",
                       help="write detailed test results into TEXT-FILE.txt")
 
-    parser.add_option("-v", "--verbose", action="store_true", dest="verbose", default=False,
+    parser.add_argument("-D", "--debug", action="store_true", default=False,
                       help="print progress and informational messages")
 
-    parser.add_option("-w", "--web", "--html", action="store", type="string", dest="html", default="",
+    parser.add_argument("-v", "--verbose", action="store_true", default=False,
+                      help="print progress and informational messages")
+
+    parser.add_argument("-w", "--web", "--html", action="store", type=str, dest="html", default="",
                       metavar="HTML-FILE",
                       help="write detailed test results into HTML-FILE.html")
 
-    parser.add_option("-x", "--xml", action="store", type="string", dest="xml", default="",
+    parser.add_argument("-x", "--xml", action="store", type=str, dest="xml", default="",
                       metavar="XML-FILE",
                       help="write detailed test results into XML-FILE.xml")
 
     global options
-    options = parser.parse_args()[0]
+    options, unknown_args = parser.parse_known_args()
     signal.signal(signal.SIGINT, sigint_hook)
 
-    return run_tests()
+    return run_tests(unknown_args)
 
 if __name__ == '__main__':
     sys.exit(main(sys.argv))