Как написать runnable тесты static_assert?

Я пишу блок unit-test для библиотеки исходного кода, содержащей static_assert s. Я хочу обеспечить уверенность, что эти static_assert не делают больше и не меньше, чем они желательно в соответствии с условиями проектирования. Поэтому я хотел бы проверить их.

Я мог бы, конечно, добавить несовместимые модульные тесты интерфейса, которые вызывают static assert s быть нарушенными самыми разнообразными средствами, и комментировать, или #if 0 их всех, с моими личными для пользователя, что если кто-либо из них не комментируется, то они будут наблюдать что библиотека не компилируется.

Но это было бы довольно смешно. Вместо этого я хотел бы некоторые устройства, которые в контексте набора единиц измерения заменят a static_assert с условно спровоцированным исключением во время выполнения, что тестовая структура может ловить и сообщать об этом: этот код имел бы static_assert ed в реальной сборке.

Я не замечаю какую-то вопиющую причину, почему это была бы глупая идея?

Если нет, как это можно сделать? Макро-аппарат - это очевидный подход, и я не Измените это. Но, возможно, также, и предпочтительно, с помощью шаблонной специализации или Подход SFINAE?

ОТВЕТЫ

Ответ 1

Поскольку я, кажется, одинокий кривошип в моем интересе к этому вопросу, я прокрутил ответ для себя, с файлом заголовка, по существу, следующим образом:

exceptionalized_static_assert.h

#ifndef TEST__EXCEPTIONALIZE_STATIC_ASSERT_H
#define TEST__EXCEPTIONALIZE_STATIC_ASSERT_H

/* Conditionally compilable apparatus for replacing `static_assert`
    with a runtime exception of type `exceptionalized_static_assert`
    within (portions of) a test suite.
*/
#if TEST__EXCEPTIONALIZE_STATIC_ASSERT == 1

#include <string>
#include <stdexcept>

namespace test {

struct exceptionalized_static_assert : std::logic_error
{
    exceptionalized_static_assert(char const *what)
    : std::logic_error(what){};
    virtual ~exceptionalized_static_assert() noexcept {}
};

template<bool Cond>
struct exceptionalize_static_assert;

template<>
struct exceptionalize_static_assert<true>
{
    explicit exceptionalize_static_assert(char const * reason) {
        (void)reason;
    }
};


template<>
struct exceptionalize_static_assert<false>
{
    explicit exceptionalize_static_assert(char const * reason) {
        std::string s("static_assert would fail with reason: ");
        s += reason;
        throw exceptionalized_static_assert(s.c_str());
    }
};

} // namespace test

// A macro redefinition of `static_assert`
#define static_assert(cond,gripe) \
    struct _1_test \
    : test::exceptionalize_static_assert<cond> \
    {   _1_test() : \
        test::exceptionalize_static_assert<cond>(gripe){}; \
    }; \
    _1_test _2_test

#endif // TEST__EXCEPTIONALIZE_STATIC_ASSERT == 1

#endif // EOF

Этот заголовок предназначен для включения только в тестовый набор, а затем он будет видимое переопределение макроса static_assert видно только тогда, когда набор тестов построен с помощью

`-DTEST__EXCEPTIONALIZE_STATIC_ASSERT=1`

Использование этого устройства может быть наброшено с помощью библиотеки шаблонов игрушек:

my_template.h

#ifndef MY_TEMPLATE_H
#define MY_TEMPLATE_H

#include <type_traits>

template<typename T>
struct my_template
{
    static_assert(std::is_pod<T>::value,"T must be POD in my_template<T>");

    explicit my_template(T const & t = T())
    : _t(t){}
    // ...
    template<int U>
    static int increase(int i) {
        static_assert(U != 0,"I cannot be 0 in my_template<T>::increase<I>");
        return i + U;
    }
    template<int U>
    static constexpr int decrease(int i) {
        static_assert(U != 0,"I cannot be 0 in my_template<T>::decrease<I>");
        return i - U;
    }
    // ...
    T _t;
    // ...  
};

#endif // EOF

Попробуйте представить, что код достаточно большой и сложный, чтобы вы не может при падении шляпы просто осмотреть его и выбрать static_assert и убедитесь, что вы знаете, почему они там, и что они выполняют их проектные цели. Вы доверяете регрессионному тестированию.

Вот тогда набор тестовых регрессионных тестов для my_template.h:

test.cpp

#include "exceptionalized_static_assert.h"
#include "my_template.h"
#include <iostream>

template<typename T, int I>
struct a_test_template
{
    a_test_template(){};
    my_template<T> _specimen;
    //...
    bool pass = true;
};

template<typename T, int I>
struct another_test_template
{
    another_test_template(int i) {
        my_template<T> specimen;
        auto j = specimen.template increase<I>(i);
        //...
        (void)j;
    }
    bool pass = true;
};

template<typename T, int I>
struct yet_another_test_template
{
    yet_another_test_template(int i) {
        my_template<T> specimen;
        auto j = specimen.template decrease<I>(i);
        //...
        (void)j;
    }
    bool pass = true;
};

using namespace std;

int main()
{
    unsigned tests = 0;
    unsigned passes = 0;

    cout << "Test: " << ++tests << endl;    
    a_test_template<int,0> t0;
    passes += t0.pass;
    cout << "Test: " << ++tests << endl;    
    another_test_template<int,1> t1(1);
    passes += t1.pass;
    cout << "Test: " << ++tests << endl;    
    yet_another_test_template<int,1> t2(1);
    passes += t2.pass;
#if TEST__EXCEPTIONALIZE_STATIC_ASSERT == 1
    try {
        // Cannot instantiate my_template<T> with non-POD T
        using type = a_test_template<int,0>;
        cout << "Test: " << ++tests << endl;
        a_test_template<type,0> specimen;

    }
    catch(test::exceptionalized_static_assert const & esa) {
        ++passes;
        cout << esa.what() << endl;
    }
    try {
        // Cannot call my_template<T>::increase<I> with I == 0
        cout << "Test: " << ++tests << endl;
        another_test_template<int,0>(1);
    }
    catch(test::exceptionalized_static_assert const & esa) {
        ++passes;
        cout << esa.what() << endl;
    }
    try {
        // Cannot call my_template<T>::decrease<I> with I == 0
        cout << "Test: " << ++tests << endl;
        yet_another_test_template<int,0>(1);
    }
    catch(test::exceptionalized_static_assert const & esa) {
        ++passes;
        cout << esa.what() << endl;
    }
#endif // TEST__EXCEPTIONALIZE_STATIC_ASSERT == 1
    cout << "Passed " << passes << " out of " << tests << " tests" << endl;
    cout << (passes == tests ? "*** Success :)" : "*** Failure :(") << endl; 
    return 0;
}

// EOF

Вы можете скомпилировать test.cpp с по крайней мере gcc 6.1, clang 3.8 и опцией -std=c++14 или VС++ 19.10.24631.0 и опцией /std:c++latest. Сделайте это сначала без определения TEST__EXCEPTIONALIZE_STATIC_ASSERT (или определяя его = 0). Затем запустите, и выход должен быть:

Test: 1
Test: 2
Test: 3
Passed 3 out of 3 tests
*** Success :)

Если вы затем повторите, но скомпилируйте с помощью -DTEST__EXCEPTIONALIZE_STATIC_ASSERT=1,

Test: 1
Test: 2
Test: 3
Test: 4
static_assert would fail with reason: T must be POD in my_template<T>
Test: 5
static_assert would fail with reason: I cannot be 0 in my_template<T>::increase<I>
Test: 6
static_assert would fail with reason: I cannot be 0 in my_template<T>::decrease<I>
Passed 6 out of 6 tests
*** Success :)

Очевидно, что повторяющееся кодирование блоков try/catch в static-assert тестовые случаи утомительны, но в условиях реального и респектабельного блок-тест, можно было бы ожидать, что он упакует устройство для тестирования исключений, чтобы сгенерировать такой материал из вашего зрения. Например, в googletest вы можете написать:

TYPED_TEST(t_my_template,insist_non_zero_increase)
{
    ASSERT_THROW(TypeParam::template increase<0>(1),
        exceptionalized_static_assert);
}

Теперь я могу вернуться к моим расчетам даты Армагеддона:)