0

我在一个使用UnitTest++的项目中使用Adob​​e Alchemy。单元测试作为构建过程的一部分运行。

事实证明，UnitTest++ 依赖于在 Alchemy 中没有实现的 C++ 的一个特性，即实例化静态类和/或调用函数来初始化全局变量。

UnitTest++ 的优点在于您不必记住将测试添加到要运行的测试列表中。它使用一些宏魔法自动创建测试用例类并将它们添加到全局测试列表中。所以这：

TEST(MyTest) {
    CHECK(doSomething());
}

变成这样：

class TestMyTest : public UnitTest::Test {
   ...
} testMyTestInstance;

UnitTest::ListAdder adderMyTest(UnitTest::Test::GetTestList(), &testMyTestInstance);

其中的构造函数ListAdder添加testMyTestInstance到测试的全局列表中。

问题是由于 Alchemy 错误，ListAdder构造函数永远不会运行，所以测试列表总是空的。

为了证明ListAdder构造函数永远不会被调用，您可以检测它在调用时崩溃：

ListAdder::ListAdder(TestList& list, Test* test) {
    int *p= (int*)INT_MAX;   // NULL won't crash alchemy (!)
    *p= 0;                   // boom
    list.Add(test);
}

这在本机编译时会崩溃，但在使用 Alchemy 编译时不会。

一个不那么激烈的查看方法是添加一个 printf：

ListAdder::ListAdder(TestList& list, Test* test) {
    printf("ListAdder %s \n", test->m_details.testName);
    list.Add(test);
}

在本机编译时，您将看到每个测试的“ListAdder ...”，但在 Alchemy 下编译时，它不会打印任何内容。

我的问题是：如何修改 UnitTest++ 以便测试能够运行？此处描述的解决方法似乎并不适用。

4

1 回答 1

0

花了一些时间，但我想通了。诀窍是静态初始化函数将起作用，例如，

int someFunc() {
    return 42;
}
int someVal= someFunc();

只要他们不调用任何构造函数或使用 new/malloc 或使用 printf。（我花了一段时间才意识到 Gunslinger47 关于 printfs 把事情搞砸的说法是正确的。）

静态初始化函数工作的事实足以让我们让 UnitTest++ 工作。我们所做的是使用此处描述的“指针”解决方法的变体：

  • 每个测试类都有一个分配器函数，而不是静态分配
  • 指向每个分配器函数的指针被添加到函数指针列表中
  • 在 main 中，然后迭代这个函数指针列表并调用每个函数。

坚韧不拔的细节如下：

(1) 在 TestMacros.h 中，将 TEST_EX 宏更改为使用静态初始化函数而不是构造函数：

#define TEST_EX(Name, List)                                                \
    class Test##Name : public UnitTest::Test                               \
    {                                                                      \
    public:                                                                \
        Test##Name() : Test(#Name, UnitTestSuite::GetSuiteName(), __FILE__, __LINE__) {}  \
    private:                                                               \
        virtual void RunImpl() const;                                      \
    };                                                                     \
                                                                           \
    void create_test##Name##Instance() {                                   \
        Test##Name *test##Name##Instance= new Test##Name();                \
        UnitTest::ListAdder adder##Name (List(), test##Name##Instance);    \
    }                                                                      \
                                                                           \
    UnitTest::test_creator_func_t fp_create_test##Name##Instance=          \
                    UnitTest::addTestCreator(create_test##Name##Instance); \
                                                                           \
    void Test##Name::RunImpl() const


#define TEST(Name) TEST_EX(Name, UnitTest::Test::GetTestList)

(2) 以与 TEST_EX 类似的方式更改 TEST_FIXTURE_EX。我会省去你的冗长。

(3) 在TestList.cpp的底部，添加TEST_EX/TEST_FIXTURE_EX宏调用的函数：

#if !defined(MAX_TEST_CREATORS)
#define MAX_TEST_CREATORS 1024
#endif

const size_t max_test_creators= MAX_TEST_CREATORS;
size_t num_test_creators= 0;

// This list unfortunately must be static-- if we were to 
// dynamically allocate it, then alchemy would break.
// If it winds up not being big enough, then just inject
// a bigger definition for MAX_TEST_CREATORS 
test_creator_func_t test_creator_list[max_test_creators]= {NULL};   

test_creator_func_t addTestCreator(test_creator_func_t fp) {
    int idx= num_test_creators;

    num_test_creators++;    
    if (num_test_creators > max_test_creators) {
        throw "test creator overflow";
    }

    test_creator_list[idx]= fp;
    return fp;
}

void initializeAllTests() {
    for (size_t idx= 0; idx < num_test_creators; idx++) {
        test_creator_list[idx]();
    }
}

当然，将他们的原型添加到 TestList.h：

typedef void (*test_creator_func_t)();
test_creator_func_t addTestCreator(test_creator_func_t fp);
void initializeAllTests();

(4) 最后，在你的单元测试运行器中，你必须调用 initializeAllTests： 

UnitTest::initializeAllTests();
return UnitTest::RunAllTests();

但这还不是全部！在它起作用之前，还有一些其他的花絮需要完成：

(1) 确保 UNITTEST_USE_CUSTOM_STREAMS 在 Config.h 中定义：

// by default, MemoryOutStream is implemented in terms of std::ostringstream, which can be expensive.
// uncomment this line to use the custom MemoryOutStream (no deps on std::ostringstream).

#define UNITTEST_USE_CUSTOM_STREAMS

这样做的原因是，如果它没有定义， MemoryOutStream.h 将#include <sstream>破坏静态初始化（我怀疑它做了某种全局构造函数或其他东西）。

(2) 在 SignalTranslator.h 中，确保 UNITTEST_THROW_SIGNALS 宏是 noop。我通过将 a-D__ALCHEMY__注入我的构建并检查它来做到这一点：

#if defined(__ALCHEMY__)
#define UNITTEST_THROW_SIGNALS
#else
#define UNITTEST_THROW_SIGNALS \
    UnitTest::SignalTranslator sig; \
    if (UNITTEST_EXTENSION sigsetjmp(*UnitTest::SignalTranslator::s_jumpTarget, 1) != 0) \
        throw ("Unhandled system exception"); 
#endif

如果不这样做，sigsetjmp 调用将在运行时失败。

于 2010-11-30T22:08:10.530 回答