2. 程式人生 > >Boost中Core模組的lightweight_test用法

Boost中Core模組的lightweight_test用法

阿新 • • 發佈：2018-12-03

標頭檔案

boost/core/lightweight_test.hpp

作用

lightweight_test.hpp提供了大量的巨集定義，如下

#define BOOST_TEST(expression)                                                                           /*判斷 表示式 為真 */
#define BOOST_TEST_NOT(expression)                                                                  /*判斷 表示式 為假*/
#define BOOST_ERROR(message)                                                                             /*表示式為假，列印錯誤資訊*/
#define BOOST_TEST_EQ(expr1, expr2)                                                                   /*判斷 表示式1，表示式2，相等*/
#define BOOST_TEST_NE(expr1, expr2)                                                                    /*判斷 表示式1，表示式2，不相等*/
#define BOOST_TEST_CSTR_EQ(expr1, expr2)                                                       /*判斷 字串1，字串2，相等*/
#define BOOST_TEST_CSTR_NE(expr1, expr2)                                                        /*判斷 字串1，字串2，不相等*/
#define BOOST_TEST_ALL_EQ(begin1, end1, begin2, end2)                                  /* 判斷 [begin1, end1)，[begin2,end2)，每一個相等 */
#define BOOST_TEST_ALL_WITH(begin1, end1, begin2, end2, predicate)            /* 判斷 [begin1, end1)，[begin2,end2)，每一個符合 predicate */
#define BOOST_TEST_THROWS(expr, excep)                                                           /* 執行 expr，丟擲 excep 異常 */

舉例

BOOST_TEST測試

#include <boost/detail/lightweight_test.hpp>

int main()
{
    int x = 0;

    BOOST_TEST( x == 1 ); // will fail

    return boost::report_errors();
}

BOOST_ERROR測試

#include <boost/detail/lightweight_test.hpp>

int main()
{
    BOOST_ERROR( "expected failure" );

    return boost::report_errors();
}

BOOST_TEST_EQ測試

#include <boost/detail/lightweight_test.hpp>

int main()
{
    int x = 0;

    BOOST_TEST_EQ( x, 1 );

    return boost::report_errors();
}

BOOST_TEST_NE測試

#include <boost/detail/lightweight_test.hpp>

int main()
{
    int x = 0;

    BOOST_TEST_NE( x, 0 );

    return boost::report_errors();
}

BOOST_TEST_THROWS測試

#include <boost/detail/lightweight_test.hpp>

struct X
{
};

void f()
{
}

int main()
{
    BOOST_TEST_THROWS( f(), X );

    return boost::report_errors();
}

BOOST_TEST_TRAIT_TRUE測試

#include <boost/core/lightweight_test_trait.hpp>

template<class T1, class T2> struct Y1
{
    enum { value = 1 };
};

template<class T1, class T2> struct Y2
{
    enum { value = 0 };
};

struct X1
{
    typedef int type;
};

struct X2
{
    typedef int type;
};

int main()
{
    BOOST_TEST_TRAIT_TRUE(( Y2<X1::type, X2::type> ));

    return boost::report_errors();
}

BOOST_TEST_CSTR_EQ測試

#include <boost/core/lightweight_test.hpp>

int main()
{
    BOOST_TEST_CSTR_EQ("x" , "y");

    return boost::report_errors();
}

BOOST_TEST_TRAIT_TRUE測試

#include <boost/core/lightweight_test_trait.hpp>

template<class T1, class T2> struct Y1
{
    enum { value = 1 };
};

template<class T1, class T2> struct Y2
{
    enum { value = 0 };
};

struct X1
{
    typedef int type;
};

struct X2
{
    typedef int type;
};

int main()
{
    // BOOST_TEST_TRAIT_TRUE

    BOOST_TEST_TRAIT_TRUE(( Y1<X1::type, X2::type> ));

    // BOOST_TEST_TRAIT_FALSE

    BOOST_TEST_TRAIT_FALSE(( Y2<X1::type, X2::type> ));

    return boost::report_errors();
}

BOOST_TEST_ALL測試

#include <vector>
#include <boost/detail/lightweight_test.hpp>

struct X
{
};

#if !defined( BOOST_NO_EXCEPTIONS )
# define LWT_THROW( x ) throw x
#else
# define LWT_THROW( x ) ((void)(x))
#endif

void f( bool x )
{
    if( x )
    {
        LWT_THROW( X() );
    }
    else
    {
        LWT_THROW( 5 );
    }
}

int main()
{
    int x = 0;

    // BOOST_TEST

    BOOST_TEST( x == 0 );
    BOOST_TEST( ++x == 1 );
    BOOST_TEST( x++ == 1 );
    BOOST_TEST( x == 2? true: false );
    BOOST_TEST( x == 2? &x: 0 );
    
    // BOOST_TEST_NOT
    
    BOOST_TEST_NOT( x == 1 );
    BOOST_TEST_NOT( ++x == 2 );
    BOOST_TEST_NOT( x++ == 2 );
    BOOST_TEST_NOT( --x == 2 );
    BOOST_TEST_NOT( x-- == 2 );
    BOOST_TEST_NOT( x == 2? false: true );
    BOOST_TEST_NOT( x == 2? 0: &x );

    // BOOST_TEST_EQ

    BOOST_TEST_EQ( x, 2 );
    BOOST_TEST_EQ( ++x, 3 );
    BOOST_TEST_EQ( x++, 3 );

    int y = 4;

    BOOST_TEST_EQ( ++x, ++y );
    BOOST_TEST_EQ( x++, y++ );
    BOOST_TEST_CSTR_EQ("xabc"+1, "yabc"+1); // equal cstrings, different addresses
    BOOST_TEST_EQ( &y, &y );

    // BOOST_TEST_NE

    BOOST_TEST_NE( ++x, y );
    BOOST_TEST_NE( &x, &y );
    BOOST_TEST_NE("xabc"+1, "yabc"+1); // equal cstrings, different addresses
    BOOST_TEST_CSTR_NE("x", "y");

    // BOOST_TEST_ALL_EQ
    {
        std::vector<int> xarray;
        xarray.push_back(1);
        xarray.push_back(2);
        std::vector<int> yarray(xarray);
        BOOST_TEST_ALL_EQ(xarray.begin(), xarray.end(), yarray.begin(), yarray.end());
    }

    // BOOST_TEST_THROWS

    BOOST_TEST_THROWS( throw X(), X );
    BOOST_TEST_THROWS( throw 1, int );

    BOOST_TEST_THROWS( f(true), X );
    BOOST_TEST_THROWS( f(false), int );

    return boost::report_errors();
}

BOOST_TEST_ALL_EQ測試

#include <vector>
#include <set>
#include <boost/core/lightweight_test.hpp>

int main()
{
    int test_cases = 0;

    // Array

    {
        int x[] = { 1 };
        int y[] = { 1, 2 };
        BOOST_TEST_ALL_EQ( x, x + sizeof(x)/sizeof(x[0]), y, y + sizeof(y)/sizeof(y[0]) );
        ++test_cases;
    }

    {
        int x[] = { 1, 2 };
        int y[] = { 1 };
        BOOST_TEST_ALL_EQ( x, x + sizeof(x)/sizeof(x[0]), y, y + sizeof(y)/sizeof(y[0]) );
        ++test_cases;
    }

    {
        int x[] = { 2 };
        int y[] = { 1, 2 };
        BOOST_TEST_ALL_EQ( x, x + sizeof(x)/sizeof(x[0]), y, y + sizeof(y)/sizeof(y[0]) );
        ++test_cases;
    }

    {
        int x[] = { 1, 2, 3, 4 };
        int y[] = { 1, 3, 2, 4 };
        BOOST_TEST_ALL_EQ( x, x + sizeof(x)/sizeof(x[0]), y, y + sizeof(y)/sizeof(y[0]) );
        ++test_cases;
    }

    // Vector

    {
        std::vector<int> x, y;
        x.push_back( 1 );
        BOOST_TEST_ALL_EQ( x.begin(), x.end(), y.begin(), y.end() );
        ++test_cases;
    }

    {
        std::vector<int> x, y;
        y.push_back( 1 );
        BOOST_TEST_ALL_EQ( x.begin(), x.end(), y.begin(), y.end() );
        ++test_cases;
    }

    {
        std::vector<int> x, y;
        x.push_back( 1 ); x.push_back( 2 ); x.push_back( 3 ); x.push_back( 4 );
        y.push_back( 1 ); y.push_back( 3 ); y.push_back( 2 ); y.push_back( 4 );
        BOOST_TEST_ALL_EQ( x.begin(), x.end(), y.begin(), y.end() );
        ++test_cases;
    }

    {
        std::vector<float> x, y;
        x.push_back( 1.0f ); x.push_back( 2.0f ); x.push_back( 3.0f ); x.push_back( 4.0f );
        y.push_back( 4.0f ); y.push_back( 2.0f ); y.push_back( 3.0f ); y.push_back( 1.0f );
        BOOST_TEST_ALL_EQ( x.begin(), x.end(), y.begin(), y.end() );
        ++test_cases;
    }

    {
        std::vector<int> x, y;
        x.push_back( 1 ); x.push_back( 2 ); x.push_back( 3 );
        y.push_back( 1 ); y.push_back( 3 ); y.push_back( 2 ); y.push_back( 4 );
        BOOST_TEST_ALL_EQ( x.begin(), x.end(), y.begin(), y.end() );
        ++test_cases;
    }

    {
        std::vector<int> x, y;
        x.push_back( 1 ); x.push_back( 2 ); x.push_back( 3 ); x.push_back( 4 );
        y.push_back( 1 ); y.push_back( 3 ); y.push_back( 2 );;
        BOOST_TEST_ALL_EQ( x.begin(), x.end(), y.begin(), y.end() );
        ++test_cases;
    }

    // Set

    {
        std::set<int> x, y;
        x.insert(1);
        y.insert(1); y.insert(3);
        BOOST_TEST_ALL_EQ( x.begin(), x.end(), y.begin(), y.end() );
        ++test_cases;
    }

    {
        std::set<int> x, y;
        x.insert(1); x.insert(2);
        y.insert(1);
        BOOST_TEST_ALL_EQ( x.begin(), x.end(), y.begin(), y.end() );
        ++test_cases;
    }

    {
        std::set<int> x, y;
        x.insert(1); x.insert(2);
        y.insert(1); y.insert(3);
        BOOST_TEST_ALL_EQ( x.begin(), x.end(), y.begin(), y.end() );
        ++test_cases;
    }

    boost::report_errors();

    return boost::detail::test_errors() != test_cases;
}

test_all_with_test測試

#include <cmath>
#include <functional>
#include <vector>
#include <boost/core/lightweight_test.hpp>

void test_vector()
{
    {
        std::vector<int> x, y;
        x.push_back( 1 ); x.push_back( 2 ); x.push_back( 3 ); x.push_back( 4 );
        y.push_back( 1 ); y.push_back( 2 ); y.push_back( 3 ); y.push_back( 4 );
        BOOST_TEST_ALL_WITH( x.begin(), x.end(), y.begin(), y.end(), std::equal_to<int>() );
    }

    {
        std::vector<int> x, y;
        x.push_back( 1 ); x.push_back( 2 ); x.push_back( 3 ); x.push_back( 4 );
        y.push_back( 2 ); y.push_back( 3 ); y.push_back( 4 ); y.push_back( 5 );
        BOOST_TEST_ALL_WITH( x.begin(), x.end(), y.begin(), y.end(), std::not_equal_to<int>() );
    }

    {
        std::vector<int> x, y;
        x.push_back( 1 ); x.push_back( 2 ); x.push_back( 3 ); x.push_back( 4 );
        y.push_back( 2 ); y.push_back( 3 ); y.push_back( 4 ); y.push_back( 5 );
        BOOST_TEST_ALL_WITH( x.begin(), x.end(), y.begin(), y.end(), std::less<int>() );
    }
}

template <typename T>
struct with_tolerance
{
    with_tolerance(T tolerance) : tolerance(tolerance) {}
    bool operator()(T lhs, T rhs)
    {
        return (std::abs(lhs - rhs) <= tolerance);
    }

private:
    T tolerance;
};

void test_tolerance_predicate()
{
    {
        std::vector<double> x, y;
        x.push_back( 1.0 ); x.push_back( 2.0 ); x.push_back( 3.0 ); x.push_back( 4.0 );
        y.push_back( 1.0 ); y.push_back( 2.0 ); y.push_back( 3.0 ); y.push_back( 4.0 );
        BOOST_TEST_ALL_WITH( x.begin(), x.end(), y.begin(), y.end(), with_tolerance<double>(1e-5) );
    }

    {
        std::vector<double> x, y;
        x.push_back( 1.0 ); x.push_back( 1.0 );
        y.push_back( 1.0 - 1e-6 ); y.push_back( 1.0 + 1e-6 );
        BOOST_TEST_ALL_WITH( x.begin(), x.end(), y.begin(), y.end(), with_tolerance<double>(1e-5) );
    }
}

int main()
{
    test_vector();
    test_tolerance_predicate();

    return boost::report_errors();
}

BOOST_TEST_ALL_WITH fail測試

#include <cmath>
#include <functional>
#include <vector>
#include <boost/core/lightweight_test.hpp>

int fail_vector()
{
    int test_cases = 0;

    {
        std::vector<int> x, y;
        x.push_back( 1 );
        BOOST_TEST_ALL_WITH( x.begin(), x.end(), y.begin(), y.end(), std::equal_to<int>() );
        ++test_cases;
    }

    {
        std::vector<int> x, y;
        y.push_back( 1 );
        BOOST_TEST_ALL_WITH( x.begin(), x.end(), y.begin(), y.end(), std::equal_to<int>() );
        ++test_cases;
    }

    {
        std::vector<int> x, y;
        x.push_back( 1 ); x.push_back( 2 ); x.push_back( 3 ); x.push_back( 4 );
        y.push_back( 1 ); y.push_back( 2 ); y.push_back( 3 );
        BOOST_TEST_ALL_WITH( x.begin(), x.end(), y.begin(), y.end(), std::equal_to<int>() );
        ++test_cases;
    }

    {
        std::vector<int> x, y;
        x.push_back( 1 ); x.push_back( 2 ); x.push_back( 3 );
        y.push_back( 1 ); y.push_back( 2 ); y.push_back( 3 ); y.push_back( 4 );
        BOOST_TEST_ALL_WITH( x.begin(), x.end(), y.begin(), y.end(), std::equal_to<int>() );
        ++test_cases;
    }

    {
        std::vector<int> x, y;
        x.push_back( 1 ); x.push_back( 2 ); x.push_back( 3 ); x.push_back( 4 );
        y.push_back( 1 ); y.push_back( 3 ); y.push_back( 2 ); y.push_back( 4 );
        BOOST_TEST_ALL_WITH( x.begin(), x.end(), y.begin(), y.end(), std::equal_to<int>() );
        ++test_cases;
    }

    {
        std::vector<int> x, y;
        x.push_back( 1 ); x.push_back( 2 ); x.push_back( 3 ); x.push_back( 4 );
        y.push_back( 1 ); y.push_back( 3 ); y.push_back( 2 ); y.push_back( 4 );
        BOOST_TEST_ALL_WITH( x.begin(), x.end(), y.begin(), y.end(), std::less<int>() );
        ++test_cases;
    }

    return test_cases;
}

template <typename T>
struct with_tolerance
{
    with_tolerance(T tolerance) : tolerance(tolerance) {}
    bool operator()(T lhs, T rhs)
    {
        return (std::abs(lhs - rhs) <= tolerance);
    }

private:
    T tolerance;
};

int fail_tolerance_predicate()
{
    int test_cases = 0;

    {
        std::vector<double> x, y;
        x.push_back( 1.0 ); x.push_back( 1.0 );
        y.push_back( 1.0 - 1e-4 ); y.push_back( 1.0 + 1e-4 );
        BOOST_TEST_ALL_WITH( x.begin(), x.end(), y.begin(), y.end(), with_tolerance<double>(1e-5) );
        ++test_cases;
    }

    return test_cases;
}

int main()
{
    int test_cases = 0;

    test_cases += fail_vector();
    test_cases += fail_tolerance_predicate();

    boost::report_errors();

    return boost::detail::test_errors() != test_cases;
}

原始碼

原始碼太複雜，省略。。。

相關推薦

Boost中Core模組的lightweight_test用法

標頭檔案 boost/core/lightweight_test.hpp 作用 lightweight_test.hpp提供了大量的巨集定義，如下 #define BOOST_TEST(expression)      &n

Boost中Core模組的enable_if用法及說明

標頭檔案 boost/utility/enable_if.hpp 作用 enable_if，lazy_enable_if，disable_if，lazy_disable_if 作用說明 enable_if 說明 template <class Cond, class T =

Boost中Core模組的demangle用法及說明

標頭檔案 boost/core/demangle.hpp 作用 我們都知道，C++中，編譯變數，類，及全域性函式，編譯後的名稱，已經發生了改變，我們稱之為 新增修飾。那麼，我們有什麼方法將這種修飾，擦除掉呢？，demangle能夠幫助我們完成這一項功能。 舉例 boost::co

Boost中Core模組的checked_delete用法

標頭檔案 boost/core/checked_delete.hpp 作用 delete 物件指標，或 物件陣列指標，如果物件是不完整定義型別或者空指標，則 編譯期間 出錯。 何為不完整型別定義，就是隻有 型別前置宣告，沒有引入標頭檔案。 舉例 //base.h #inclu

Boost中Core模組的visit_each用法

 標頭檔案 boost/visit_each.hpp 作用 按照 指定的謂詞 處理，如果引數為一個集合，則處理集合的每一個元素，如果引數為一個元素，則，只處理一次。 舉例 #include <boost/visit_each.hpp> #include &l

Boost中Core模組的typeinfo用法

標頭檔案 boost/core/typeinfo.hpp 作用 與std::typeinfo 功能一致 舉例 #include <boost/core/typeinfo.hpp> #include <boost/core/lightweight_test.hpp

Boost中Core模組的ref用法

標頭檔案 boost/core/ref.hpp 作用 能夠將 基本資料型別及自定義類，進行 包裝，及解引用；還可以對函式進行 包裝，及解引用 主要API：boost::ref，boost::cref，boost::is_reference_wrapper，boost::unwrap_

Boost中Core模組的noncopyable用法

標頭檔案 boost/noncopyable.hpp 作用 noncopyable能讓繼承它的子類，不具備 拷貝構造及賦值構造 的功能。 舉例 #include <boost/noncopyable.hpp> #include <iostream> //

Boost中Core模組的is_same用法

標頭檔案 boost/core/is_same.hpp 作用 is_same是一個模板類，內部有一個 static const bool value，接收兩個引數，都是資料型別，包括 自定義的型別，如果兩個型別一致，則 value=true，否則 value=false 舉例 #

Boost中Core模組的ignore_unused用法

標頭檔案 boost/core/ignore_unused.hpp 作用 C++中，沒有使用的變數，在編譯期間，會出現警告，ingnore_unused就是解決這一問題的。 舉例 #include <boost/core/ignore_unused.hpp> BOO

boost中Core模組,addressof使用及說明

標頭檔案 boost/core/addressof.hpp 作用 獲取基本變數的地址，或者是 類變數的地址，或者是 函式的地址，它比 &符號 功能更強，如果一個class 重寫 &運算子 ，當對這個類的變數 取&，其意義不是 獲取物件的地址，而是 會呼叫 &

Boost中Datastruct模組的variant用法

標頭檔案 boost/variant.hpp 作用 將基本資料型別及自定義類，以variant型別儲存，或者boost::get用於將variant轉成需要的型別，如果失敗，則丟擲bad_cast_exception；另外結合boost::static_visitor，可使用更加強大的功

Boost中string模組的predicate用法

標頭檔案 boost/algorithm/string/predicate.hpp 作用 string的謂語有如下API： starts_with，判斷string str是否以string sub開始，返回true，或false istarts_with，判斷string st

Python中collections模組的用法

在內建資料型別（dict、list、set、tuple）的基礎上，collections模組提供了幾個額外的資料型別： namedtuple：生成可以使用名字來訪問元素內容的tuple，通常用來增強程式碼的可讀性， 在訪問一些tuple型別的資料時尤其好用. deque

Boost中DataStruct模組的any

標頭檔案 boost/any.hpp 作用 將基本資料型別，自定義類型別，指標型別，轉化為any，同時通過any_cast函式，將any型別，轉為需要的型別，如果轉化失敗，則會丟擲bad_any_cast異常。 any類，有如下API swap：交換，與std::swap一致。

Boost中string的regex用法

標頭檔案 boost/algorithm/string/regex.hpp 作用 string的regex有如下API find_regex：查詢字串str中第一次滿足 regex的子串，返回子串起始，終止位置。 replace_regex：查詢字串str中第一次滿足 regex

Boost中string的split用法

標頭檔案 boost/algorithm/string/split.hpp 作用 string的split包括如下API find_all：在字串string str中查詢string sub，返回找到的所有的 sub。 ifind_all：在字串string str中查詢str

Boost中string的查詢用法

標頭檔案 boost/algorithm/string/find.hpp 作用 string的查詢有如下API find_first，在大字串中查詢子串第一次出現時，返回 子串在大串的位置。 ifind_first，在大字串中查詢子串第一次出現時，並且忽略大小，返回 子串在大串的

python中 pickle模組的用法

python的pickle模組實現了基本的資料序列和反序列化。通過pickle模組的序列化操作我們能夠將程式中執行的物件資訊儲存到檔案中去，永久儲存；通過pickle模組的反序列化操作，我們能夠從檔案中建立上一次程式儲存的物件。 基本介面： 　　pickle.d

Boost中ASIO的一些用法-定時器

一、介紹 ASIO，基於作業系統的非同步機制，可有效避免多執行緒程式設計的諸多副作用。 目前主要關注於通訊方面，使用大量的類封裝了socket，提供更高層次的介面 二、使用不需要編譯，預設不支援SSL，要支援的話需要自己編譯OpenSSL。 三、用法Sample 1、