如何编写脚本以使用boost :: unit_test执行自动测试？

Question

I am a newbie of automatic unit test in C++. I have followed the instruction of boost::unit_test and finished a test scheme by calling function unit_test_main in boost::unit_test. It is no problem for me to run the test program. However, I have problems with pass the arguments to the test function. Maybe, the following codes can illustrate my problem much better:

#ifndef MAIN_CPP_
#define MAIN_CPP_



#include <string>
#include <vector>
#include <iostream>
#include <assert.h>

#include <boost/program_options.hpp>
#include <boost/test/test_tools.hpp>
#include <boost/test/execution_monitor.hpp>
#include <boost/test/unit_test.hpp>




using namespace boost::program_options;
using namespace std;
using namespace boost;
using namespace boost::unit_test;




/**
* the global test suite
*/

boost::unit_test::test_suite* get_feelfree_test_suite();
boost::unit_test::test_suite* main_global_test_suite;

/**
* name of the test suite
*/
std::string current_global_test_suite_name;

#ifdef BOOST_TEST_ALTERNATIVE_INIT_API

bool  run_global_test_suite () {
    boost::unit_test::test_suite& masterTestSuite = framework::master_test_suite();

    if(masterTestSuite.size() != 0) {
        test_unit_id formerTestSuite = masterTestSuite.get(current_global_test_suite_name);
        masterTestSuite.remove(formerTestSuite);

    }
    masterTestSuite.add(main_global_test_suite);
    current_global_test_suite_name = main_global_test_suite->p_name.get();

    return true;
}
#else
    test_suite* run_global_test_suite(int, char* []) {
    return main_global_test_suite;
}
#endif

/**
* Obtain test program options
*/
int obtain_options(char **optionLine, int argc, char** argv); 





/**
* This function is used to run the test program, and the procedure is really standard.
*/
int main( int argc, char* argv[] )
{
    try 
    {
        /**
        * Step 1. obtain options
        */
        char* optionLine[1024];
        int len ;
        len = obtain_options(optionLine, argc, argv);
        /**
        * Step 2. perform unit test based on user's options
        */
        int test_status=0; 
        main_global_test_suite =   get_feelfree_test_suite();
        test_status = unit_test_main(run_global_test_suite, len, optionLine);
        return test_status;
    } 
    catch(std::exception& e)
    {
        std::cout << e.what() << std::endl;
        return 1;
    }   
    catch (const std::string& s) 
    {
        std::cout << s << std::endl;
        return 1;
    }
    catch (...)
    {
        return 1;
    }


}
/** @} */ 


int obtain_options(char **optionLine, int argc,  char* argv[])
{
    // 1. All the options for testing the program
        options_description desc("Allowed options");
        desc.add_options()("help", "produce help message")
        ("detect_memory_leaks", value<bool>()->default_value(false), "test configuration option (option of boost framework)");
        // 2. Perform parsing 
        variables_map vm;
        store(parse_command_line(argc, argv, desc), vm);
        notify(vm);
        // 3. Illustrate the input 
        std::vector<const char*> options;
        std::string testSuiteToRun;
        if(vm.count("test_suite")){  
            testSuiteToRun = vm["test_suite"].as<string>(); 
        }
        else {
            testSuiteToRun = "main";
        }   

        options.push_back(argv[0]);
        if(vm.count("detect_memory_leaks")) {  
            bool detect = vm["detect_memory_leaks"].as<bool>();
            if(detect) {
                options.push_back("--detect_memory_leaks=1");
            }
            else {
            options.push_back("--detect_memory_leaks=0");
            }
        }
        else {
            options.push_back("--detect_memory_leaks=0");
        }

        // 4. Obtain all the parameters in the format of char** 

        assert(options.size() < 1024);
        std::copy(options.begin(), options.end(), const_cast<const char**>(optionLine));

        return options.size();

}

void Testsub(const std::string &name)
{
    cout<<"File_name: "<<name<<endl;
}
void Testabc( )
{
    std::vector<std::string > name_array;
    name_array.push_back("name 1");
    name_array.push_back("name 2");
    for(int i=0; i<name_array.size(); i++)
        Testsub(name_array[i]);
}


boost::unit_test::test_suite* get_feelfree_test_suite()
{
    test_suite* ts = BOOST_TEST_SUITE( "unit_geometric" );
    ts->add( BOOST_TEST_CASE(&Testabc) ); 
    return ts;
}


#endif

As you can see, in this test framework, the main function I want to test is Testsub , which relies on the input argument const std::string &name . However, I can not pass any arguments via the test suite function get_feelfree_test_suite . Therefore, in this test program, I wrote another test function Testabc , where all the possible file test lists are given and passed to Testsub . This is definitely not the best solution. I am wondering whether there are other solutions. Several solutions are in my mind, but I do not know whether they are good solutions:

• Solution 1: try to figure out a way to pass arguments to get_feelfree_test_suite from the main function ( int main( int argc, char* argv[] ). After that, write a script to run the program several times. In windows, one possible script is .bat script. For this solution, I do not know how to implement it.
• Solution 2: write a list file, where all the possible input file test names are given, and then read the list file in the program. This is much easier to implement.

I also hear that Python can be very easily incorporated in the test framework, but I have no idea about that. Anyway, I am open to all the possible solutions, and thanks!

Answer 1

Do you really need to have the different "names" in a separate file? It would probably simpler to put them into your test suite. One BOOST_AUTO_TEST_CASE for every name. Or an array of names, which you can iterate over in the test case.

Answer 2

Since I do not really understand the purpose of all the code, I post a minimal sample that does the work (calling Testsub several times) by parsing elements like -F file1 -F file2 from the command line. It does use the BOOST_PARAM_TEST_CASE macro of boost::unittest :

#include <boost/test/parameterized_test.hpp>
//...
void Testsub(const std::string &name)
{
    cout<<"File_name: "<<name<<endl;
}
test_suite* init_unit_test_suite( int argc, char* argv[] ) 
{
  std::vector<std::string> files_to_run_local;

  for(int i = 0; i < framework::master_test_suite().argc; i++)
  {
    if(std::string(framework::master_test_suite().argv[i]) == "-F")
    {
      if(i == framework::master_test_suite().argc - 1)
      {
        std::cerr << "Error in the command line" << std::endl;
        throw boost::unit_test::framework::setup_error("Error in the command line");
      }
      files_to_run_local.push_back(framework::master_test_suite().argv[++i]);
    }
  }

  test_suite* ts = BOOST_TEST_SUITE( "unit_geometric" );
  ts->add( BOOST_PARAM_TEST_CASE( &Testsub, 
                                  files_to_run_local.begin(), 
                                  files_to_run_local.end() ) ); 

  framework::master_test_suite().add(ts);

  return 0;
}

Now, I think you are the only one to decide over the method used to pass the list of files to the unit test framework. A file containing all files would be also a good solution, and might be appropriate if the list to pass is big, but has the disadvantage of using an intermediate file to do that.

But answering that question really depends on what framework is driving your tests (cmake, shell, etc.) Python/cmake can generate either the command line or the intermediate file very easily for you.

In all case, the clean method is to call the BOOST_PARAM_TEST_CASE macro.