538 lines
26 KiB
C++
538 lines
26 KiB
C++
/*
|
|
* Copyright Andrey Semashev 2007 - 2015.
|
|
* Distributed under the Boost Software License, Version 1.0.
|
|
* (See accompanying file LICENSE_1_0.txt or copy at
|
|
* http://www.boost.org/LICENSE_1_0.txt)
|
|
*/
|
|
/*!
|
|
* \file form_named_scope.cpp
|
|
* \author Andrey Semashev
|
|
* \date 07.02.2009
|
|
*
|
|
* \brief This header contains tests for the \c named_scope formatter.
|
|
*/
|
|
|
|
#define BOOST_TEST_MODULE form_named_scope
|
|
|
|
#include <string>
|
|
#include <boost/config.hpp>
|
|
#include <boost/preprocessor/cat.hpp>
|
|
#include <boost/test/unit_test.hpp>
|
|
#include <boost/log/attributes/constant.hpp>
|
|
#include <boost/log/attributes/attribute_set.hpp>
|
|
#include <boost/log/attributes/named_scope.hpp>
|
|
#include <boost/log/expressions.hpp>
|
|
#include <boost/log/utility/formatting_ostream.hpp>
|
|
#include <boost/log/utility/string_literal.hpp>
|
|
#include <boost/log/core/record.hpp>
|
|
#include "char_definitions.hpp"
|
|
#include "make_record.hpp"
|
|
|
|
namespace logging = boost::log;
|
|
namespace attrs = logging::attributes;
|
|
namespace expr = logging::expressions;
|
|
namespace keywords = logging::keywords;
|
|
|
|
namespace {
|
|
|
|
template< typename CharT >
|
|
struct named_scope_test_data;
|
|
|
|
struct named_scope_test_data_base
|
|
{
|
|
static logging::string_literal scope1() { return logging::str_literal("scope1"); }
|
|
static logging::string_literal scope2() { return logging::str_literal("scope2"); }
|
|
|
|
static logging::string_literal file() { return logging::str_literal(__FILE__); }
|
|
static logging::string_literal posix_file() { return logging::str_literal("/home/user/posix_file.cpp"); }
|
|
static logging::string_literal windows_file1() { return logging::str_literal("C:\\user\\windows_file1.cpp"); }
|
|
static logging::string_literal windows_file2() { return logging::str_literal("C:/user/windows_file2.cpp"); }
|
|
};
|
|
|
|
#ifdef BOOST_LOG_USE_CHAR
|
|
template< >
|
|
struct named_scope_test_data< char > :
|
|
public test_data< char >,
|
|
public named_scope_test_data_base
|
|
{
|
|
static logging::string_literal default_format() { return logging::str_literal("%n"); }
|
|
static logging::string_literal full_format() { return logging::str_literal("%n (%f:%l)"); }
|
|
static logging::string_literal short_filename_format() { return logging::str_literal("%n (%F:%l)"); }
|
|
static logging::string_literal scope_function_name_format() { return logging::str_literal("%c"); }
|
|
static logging::string_literal function_name_format() { return logging::str_literal("%C"); }
|
|
static logging::string_literal delimiter1() { return logging::str_literal("|"); }
|
|
static logging::string_literal incomplete_marker() { return logging::str_literal("<<and more>>"); }
|
|
static logging::string_literal empty_marker() { return logging::str_literal("[empty]"); }
|
|
};
|
|
#endif // BOOST_LOG_USE_CHAR
|
|
|
|
#ifdef BOOST_LOG_USE_WCHAR_T
|
|
template< >
|
|
struct named_scope_test_data< wchar_t > :
|
|
public test_data< wchar_t >,
|
|
public named_scope_test_data_base
|
|
{
|
|
static logging::wstring_literal default_format() { return logging::str_literal(L"%n"); }
|
|
static logging::wstring_literal full_format() { return logging::str_literal(L"%n (%f:%l)"); }
|
|
static logging::wstring_literal short_filename_format() { return logging::str_literal(L"%n (%F:%l)"); }
|
|
static logging::wstring_literal scope_function_name_format() { return logging::str_literal(L"%c"); }
|
|
static logging::wstring_literal function_name_format() { return logging::str_literal(L"%C"); }
|
|
static logging::wstring_literal delimiter1() { return logging::str_literal(L"|"); }
|
|
static logging::wstring_literal incomplete_marker() { return logging::str_literal(L"<<and more>>"); }
|
|
static logging::wstring_literal empty_marker() { return logging::str_literal(L"[empty]"); }
|
|
};
|
|
#endif // BOOST_LOG_USE_WCHAR_T
|
|
|
|
template< typename CharT >
|
|
inline bool check_formatting(logging::basic_string_literal< CharT > const& format, logging::record_view const& rec, std::basic_string< CharT > const& expected)
|
|
{
|
|
typedef logging::basic_formatter< CharT > formatter;
|
|
typedef std::basic_string< CharT > string;
|
|
typedef logging::basic_formatting_ostream< CharT > osstream;
|
|
typedef named_scope_test_data< CharT > data;
|
|
|
|
string str;
|
|
osstream strm(str);
|
|
formatter f = expr::stream << expr::format_named_scope(data::attr1(), keywords::format = format.c_str());
|
|
f(rec, strm);
|
|
return equal_strings(strm.str(), expected);
|
|
}
|
|
|
|
} // namespace
|
|
|
|
// The test checks that named scopes stack formatting works
|
|
BOOST_AUTO_TEST_CASE_TEMPLATE(scopes_formatting, CharT, char_types)
|
|
{
|
|
typedef attrs::named_scope named_scope;
|
|
typedef named_scope::sentry sentry;
|
|
|
|
typedef logging::attribute_set attr_set;
|
|
typedef std::basic_string< CharT > string;
|
|
typedef logging::basic_formatting_ostream< CharT > osstream;
|
|
typedef logging::basic_formatter< CharT > formatter;
|
|
typedef logging::record_view record_view;
|
|
typedef named_scope_test_data< CharT > data;
|
|
|
|
named_scope attr;
|
|
|
|
// First scope
|
|
const unsigned int line1 = __LINE__;
|
|
sentry scope1(data::scope1(), data::file(), line1);
|
|
const unsigned int line2 = __LINE__;
|
|
sentry scope2(data::scope2(), data::file(), line2);
|
|
|
|
attr_set set1;
|
|
set1[data::attr1()] = attr;
|
|
|
|
record_view rec = make_record_view(set1);
|
|
|
|
// Default format
|
|
{
|
|
string str;
|
|
osstream strm(str);
|
|
strm << data::scope1() << "->" << data::scope2();
|
|
BOOST_CHECK(check_formatting(data::default_format(), rec, strm.str()));
|
|
}
|
|
// Full format
|
|
{
|
|
string str;
|
|
osstream strm(str);
|
|
strm << data::scope1() << " (" << data::file() << ":" << line1 << ")->"
|
|
<< data::scope2() << " (" << data::file() << ":" << line2 << ")";
|
|
BOOST_CHECK(check_formatting(data::full_format(), rec, strm.str()));
|
|
}
|
|
// Different delimiter
|
|
{
|
|
string str1, str2;
|
|
osstream strm1(str1), strm2(str2);
|
|
formatter f = expr::stream << expr::format_named_scope(data::attr1(),
|
|
keywords::format = data::default_format().c_str(),
|
|
keywords::delimiter = data::delimiter1().c_str());
|
|
f(rec, strm1);
|
|
strm2 << data::scope1() << "|" << data::scope2();
|
|
BOOST_CHECK(equal_strings(strm1.str(), strm2.str()));
|
|
}
|
|
// Different direction
|
|
{
|
|
string str1, str2;
|
|
osstream strm1(str1), strm2(str2);
|
|
formatter f = expr::stream << expr::format_named_scope(data::attr1(),
|
|
keywords::format = data::default_format().c_str(),
|
|
keywords::iteration = expr::reverse);
|
|
f(rec, strm1);
|
|
strm2 << data::scope2() << "<-" << data::scope1();
|
|
BOOST_CHECK(equal_strings(strm1.str(), strm2.str()));
|
|
}
|
|
{
|
|
string str1, str2;
|
|
osstream strm1(str1), strm2(str2);
|
|
formatter f = expr::stream << expr::format_named_scope(data::attr1(),
|
|
keywords::format = data::default_format().c_str(),
|
|
keywords::delimiter = data::delimiter1().c_str(),
|
|
keywords::iteration = expr::reverse);
|
|
f(rec, strm1);
|
|
strm2 << data::scope2() << "|" << data::scope1();
|
|
BOOST_CHECK(equal_strings(strm1.str(), strm2.str()));
|
|
}
|
|
// Limiting the number of scopes
|
|
{
|
|
string str1, str2;
|
|
osstream strm1(str1), strm2(str2);
|
|
formatter f = expr::stream << expr::format_named_scope(data::attr1(),
|
|
keywords::format = data::default_format().c_str(),
|
|
keywords::depth = 1);
|
|
f(rec, strm1);
|
|
strm2 << "..." << data::scope2();
|
|
BOOST_CHECK(equal_strings(strm1.str(), strm2.str()));
|
|
}
|
|
{
|
|
string str1, str2;
|
|
osstream strm1(str1), strm2(str2);
|
|
formatter f = expr::stream << expr::format_named_scope(data::attr1(),
|
|
keywords::format = data::default_format().c_str(),
|
|
keywords::depth = 1,
|
|
keywords::iteration = expr::reverse);
|
|
f(rec, strm1);
|
|
strm2 << data::scope2() << "...";
|
|
BOOST_CHECK(equal_strings(strm1.str(), strm2.str()));
|
|
}
|
|
{
|
|
string str1, str2;
|
|
osstream strm1(str1), strm2(str2);
|
|
formatter f = expr::stream << expr::format_named_scope(data::attr1(),
|
|
keywords::format = data::default_format().c_str(),
|
|
keywords::delimiter = data::delimiter1().c_str(),
|
|
keywords::depth = 1);
|
|
f(rec, strm1);
|
|
strm2 << "..." << data::scope2();
|
|
BOOST_CHECK(equal_strings(strm1.str(), strm2.str()));
|
|
}
|
|
{
|
|
string str1, str2;
|
|
osstream strm1(str1), strm2(str2);
|
|
formatter f = expr::stream << expr::format_named_scope(data::attr1(),
|
|
keywords::format = data::default_format().c_str(),
|
|
keywords::delimiter = data::delimiter1().c_str(),
|
|
keywords::depth = 1,
|
|
keywords::iteration = expr::reverse);
|
|
f(rec, strm1);
|
|
strm2 << data::scope2() << "...";
|
|
BOOST_CHECK(equal_strings(strm1.str(), strm2.str()));
|
|
}
|
|
{
|
|
string str1, str2;
|
|
osstream strm1(str1), strm2(str2);
|
|
formatter f = expr::stream << expr::format_named_scope(data::attr1(),
|
|
keywords::format = data::default_format().c_str(),
|
|
keywords::incomplete_marker = data::incomplete_marker().c_str(),
|
|
keywords::depth = 1);
|
|
f(rec, strm1);
|
|
strm2 << "<<and more>>" << data::scope2();
|
|
BOOST_CHECK(equal_strings(strm1.str(), strm2.str()));
|
|
}
|
|
{
|
|
string str1, str2;
|
|
osstream strm1(str1), strm2(str2);
|
|
formatter f = expr::stream << expr::format_named_scope(data::attr1(),
|
|
keywords::format = data::default_format().c_str(),
|
|
keywords::incomplete_marker = data::incomplete_marker().c_str(),
|
|
keywords::depth = 1,
|
|
keywords::iteration = expr::reverse);
|
|
f(rec, strm1);
|
|
strm2 << data::scope2() << "<<and more>>";
|
|
BOOST_CHECK(equal_strings(strm1.str(), strm2.str()));
|
|
}
|
|
}
|
|
|
|
// The test checks that empty named scopes stack formatting works
|
|
BOOST_AUTO_TEST_CASE_TEMPLATE(empty_scopes_formatting, CharT, char_types)
|
|
{
|
|
typedef attrs::named_scope named_scope;
|
|
typedef named_scope::sentry sentry;
|
|
|
|
typedef logging::attribute_set attr_set;
|
|
typedef std::basic_string< CharT > string;
|
|
typedef logging::basic_formatting_ostream< CharT > osstream;
|
|
typedef logging::basic_formatter< CharT > formatter;
|
|
typedef logging::record_view record_view;
|
|
typedef named_scope_test_data< CharT > data;
|
|
|
|
named_scope attr;
|
|
|
|
attr_set set1;
|
|
set1[data::attr1()] = attr;
|
|
|
|
record_view rec = make_record_view(set1);
|
|
|
|
formatter f = expr::stream << expr::format_named_scope(data::attr1(),
|
|
keywords::format = data::default_format().c_str(),
|
|
keywords::empty_marker = data::empty_marker().c_str());
|
|
|
|
{
|
|
string str1, str2;
|
|
osstream strm1(str1), strm2(str2);
|
|
f(rec, strm1);
|
|
strm2 << "[empty]";
|
|
BOOST_CHECK(equal_strings(strm1.str(), strm2.str()));
|
|
}
|
|
|
|
const unsigned int line1 = __LINE__;
|
|
sentry scope1(data::scope1(), data::file(), line1);
|
|
const unsigned int line2 = __LINE__;
|
|
sentry scope2(data::scope2(), data::file(), line2);
|
|
|
|
{
|
|
string str1, str2;
|
|
osstream strm1(str1), strm2(str2);
|
|
f(rec, strm1);
|
|
strm2 << data::scope1() << "->" << data::scope2();
|
|
BOOST_CHECK(equal_strings(strm1.str(), strm2.str()));
|
|
}
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE_TEMPLATE(scopes_filename_formatting_posix, CharT, char_types)
|
|
{
|
|
typedef attrs::named_scope named_scope;
|
|
typedef named_scope::sentry sentry;
|
|
|
|
typedef logging::attribute_set attr_set;
|
|
typedef std::basic_string< CharT > string;
|
|
typedef logging::basic_formatting_ostream< CharT > osstream;
|
|
typedef logging::record_view record_view;
|
|
typedef named_scope_test_data< CharT > data;
|
|
|
|
named_scope attr;
|
|
|
|
// First scope
|
|
const unsigned int line1 = __LINE__;
|
|
sentry scope1(data::scope1(), data::posix_file(), line1);
|
|
|
|
attr_set set1;
|
|
set1[data::attr1()] = attr;
|
|
|
|
record_view rec = make_record_view(set1);
|
|
|
|
// File names without the full path
|
|
{
|
|
string str;
|
|
osstream strm(str);
|
|
strm << data::scope1() << " (posix_file.cpp:" << line1 << ")";
|
|
BOOST_CHECK(check_formatting(data::short_filename_format(), rec, strm.str()));
|
|
}
|
|
}
|
|
|
|
#if defined(BOOST_WINDOWS)
|
|
|
|
BOOST_AUTO_TEST_CASE_TEMPLATE(scopes_filename_formatting_windows, CharT, char_types)
|
|
{
|
|
typedef attrs::named_scope named_scope;
|
|
typedef named_scope::sentry sentry;
|
|
|
|
typedef logging::attribute_set attr_set;
|
|
typedef std::basic_string< CharT > string;
|
|
typedef logging::basic_formatting_ostream< CharT > osstream;
|
|
typedef logging::record_view record_view;
|
|
typedef named_scope_test_data< CharT > data;
|
|
|
|
named_scope attr;
|
|
|
|
// First scope
|
|
const unsigned int line1 = __LINE__;
|
|
sentry scope1(data::scope1(), data::windows_file1(), line1);
|
|
const unsigned int line2 = __LINE__;
|
|
sentry scope2(data::scope2(), data::windows_file2(), line2);
|
|
|
|
attr_set set1;
|
|
set1[data::attr1()] = attr;
|
|
|
|
record_view rec = make_record_view(set1);
|
|
|
|
// File names without the full path
|
|
{
|
|
string str;
|
|
osstream strm(str);
|
|
strm << data::scope1() << " (windows_file1.cpp:" << line1 << ")->"
|
|
<< data::scope2() << " (windows_file2.cpp:" << line2 << ")";
|
|
BOOST_CHECK(check_formatting(data::short_filename_format(), rec, strm.str()));
|
|
}
|
|
}
|
|
|
|
#endif // defined(BOOST_WINDOWS)
|
|
|
|
namespace {
|
|
|
|
struct named_scope_test_case
|
|
{
|
|
logging::string_literal scope_name;
|
|
const char* function_name;
|
|
const char* function_name_no_scope;
|
|
};
|
|
|
|
const named_scope_test_case named_scope_test_cases[] =
|
|
{
|
|
// Generic signatures
|
|
{ logging::str_literal("int main(int, char *[])"), "main", "main" },
|
|
{ logging::str_literal("namespace_name::type foo()"), "foo", "foo" },
|
|
{ logging::str_literal("namespace_name::type& foo::bar(int[], std::string const&)"), "foo::bar", "bar" },
|
|
{ logging::str_literal("void* namespc::foo<char>::bar()"), "namespc::foo<char>::bar", "bar" },
|
|
{ logging::str_literal("void* namespc::foo<char>::bar<int>(int) const"), "namespc::foo<char>::bar<int>", "bar<int>" },
|
|
|
|
// MSVC-specific
|
|
{ logging::str_literal("int __cdecl main(int, char *[])"), "main", "main" },
|
|
{ logging::str_literal("struct namespc::strooct __cdecl foo3(int [])"), "foo3", "foo3" },
|
|
{ logging::str_literal("void (__cdecl *__cdecl foo4(void))(void)"), "foo4", "foo4" }, // function returning pointer to function
|
|
{ logging::str_literal("void (__cdecl *__cdecl foo5(void (__cdecl *)(void)))(void)"), "foo5", "foo5" },
|
|
{ logging::str_literal("void (__cdecl *__cdecl namespc::my_class<int>::member1(void (__cdecl *)(void)))(void)"), "namespc::my_class<int>::member1", "member1" },
|
|
{ logging::str_literal("void (__cdecl *__cdecl namespc::my_class<int>::member2<int>(int))(void)"), "namespc::my_class<int>::member2<int>", "member2<int>" },
|
|
{ logging::str_literal("void (__cdecl *__cdecl namespc::my_class<int>::member2<void(__cdecl *)(void)>(void (__cdecl *)(void)))(void)"), "namespc::my_class<int>::member2<void(__cdecl *)(void)>", "member2<void(__cdecl *)(void)>" },
|
|
{ logging::str_literal("void (__cdecl *__cdecl namespc::my_class<int>::member3<void __cdecl foo1(void)>(void))(void)"), "namespc::my_class<int>::member3<void __cdecl foo1(void)>", "member3<void __cdecl foo1(void)>" },
|
|
{ logging::str_literal("void (__cdecl *__cdecl namespc::my_class<void (__cdecl*)(void)>::member1(void (__cdecl *)(void)))(void)"), "namespc::my_class<void (__cdecl*)(void)>::member1", "member1" },
|
|
{ logging::str_literal("void (__cdecl *__cdecl namespc::my_class<void (__cdecl*)(void)>::member2<int>(int))(void)"), "namespc::my_class<void (__cdecl*)(void)>::member2<int>", "member2<int>" },
|
|
{ logging::str_literal("void (__cdecl *__cdecl namespc::my_class<void (__cdecl*)(void)>::member2<void(__cdecl *)(void)>(void (__cdecl *)(void)))(void)"), "namespc::my_class<void (__cdecl*)(void)>::member2<void(__cdecl *)(void)>", "member2<void(__cdecl *)(void)>" },
|
|
{ logging::str_literal("void (__cdecl *__cdecl namespc::my_class<void (__cdecl*)(void)>::member3<void __cdecl foo1(void)>(void))(void)"), "namespc::my_class<void (__cdecl*)(void)>::member3<void __cdecl foo1(void)>", "member3<void __cdecl foo1(void)>" },
|
|
{ logging::str_literal("void (__cdecl namespc::my_class2::* __cdecl namespc::foo6(void (__cdecl *)(void)))(void)"), "namespc::foo6", "foo6" },
|
|
{ logging::str_literal("struct namespc::my_class<void __cdecl(int)> __cdecl namespc::foo7(void)"), "namespc::foo7", "foo7" },
|
|
{ logging::str_literal("void (__cdecl namespc::my_class2::* const (&__cdecl namespc::foo8(void (__cdecl *)(void)))[2])(void)"), "namespc::foo8", "foo8" },
|
|
{ logging::str_literal("__cdecl namespc::my_class2::my_class2(void)"), "namespc::my_class2::my_class2", "my_class2" },
|
|
{ logging::str_literal("__cdecl namespc::my_class2::~my_class2(void)"), "namespc::my_class2::~my_class2", "~my_class2" },
|
|
{ logging::str_literal("void __cdecl namespc::my_class2::operator =(const struct namespc::my_class2 &)"), "namespc::my_class2::operator =", "operator =" },
|
|
{ logging::str_literal("void __cdecl namespc::my_class2::operator *(void) const"), "namespc::my_class2::operator *", "operator *" },
|
|
{ logging::str_literal("void __cdecl namespc::my_class2::operator ()(void)"), "namespc::my_class2::operator ()", "operator ()" },
|
|
{ logging::str_literal("bool __cdecl namespc::my_class2::operator <(int) const"), "namespc::my_class2::operator <", "operator <" },
|
|
{ logging::str_literal("bool __cdecl namespc::my_class2::operator >(int) const"), "namespc::my_class2::operator >", "operator >" },
|
|
{ logging::str_literal("bool __cdecl namespc::my_class2::operator <=(int) const"), "namespc::my_class2::operator <=", "operator <=" },
|
|
{ logging::str_literal("bool __cdecl namespc::my_class2::operator >=(int) const"), "namespc::my_class2::operator >=", "operator >=" },
|
|
{ logging::str_literal("__cdecl namespc::my_class2::operator bool(void) const"), "namespc::my_class2::operator bool", "operator bool" },
|
|
// MSVC generates incorrect strings in case of conversion operators to function types. We don't support these.
|
|
// { logging::str_literal("__cdecl namespc::my_class2::operator char (__cdecl *)(double)(__cdecl *(void) const)(double)"), "namespc::my_class2::operator char (__cdecl *)(double)", "operator char (__cdecl *)(double)" },
|
|
// { logging::str_literal("__cdecl namespc::my_class2::operator char (__cdecl namespc::my_class2::* )(double)(__cdecl namespc::my_class2::* (void) const)(double)"), "namespc::my_class2::operator char (__cdecl namespc::my_class2::* )(double)", "operator char (__cdecl namespc::my_class2::* )(double)" },
|
|
{ logging::str_literal("class std::basic_ostream<char,struct std::char_traits<char> > &__cdecl namespc::operator <<<char,struct std::char_traits<char>>(class std::basic_ostream<char,struct std::char_traits<char> > &,const struct namespc::my_class2 &)"), "namespc::operator <<<char,struct std::char_traits<char>>", "operator <<<char,struct std::char_traits<char>>" },
|
|
{ logging::str_literal("class std::basic_istream<char,struct std::char_traits<char> > &__cdecl namespc::operator >><char,struct std::char_traits<char>>(class std::basic_istream<char,struct std::char_traits<char> > &,struct namespc::my_class2 &)"), "namespc::operator >><char,struct std::char_traits<char>>", "operator >><char,struct std::char_traits<char>>" },
|
|
|
|
// GCC-specific
|
|
{ logging::str_literal("namespc::strooct foo3(int*)"), "foo3", "foo3" },
|
|
{ logging::str_literal("void (* foo4())()"), "foo4", "foo4" }, // function returning pointer to function
|
|
{ logging::str_literal("void (* foo5(pfun2_t))()"), "foo5", "foo5" },
|
|
{ logging::str_literal("static void (* namespc::my_class<T>::member1(pfun2_t))() [with T = int; pfun1_t = void (*)(); pfun2_t = void (*)()]"), "namespc::my_class<T>::member1", "member1" },
|
|
{ logging::str_literal("static void (* namespc::my_class<T>::member2(U))() [with U = int; T = int; pfun2_t = void (*)()]"), "namespc::my_class<T>::member2", "member2" },
|
|
{ logging::str_literal("static void (* namespc::my_class<T>::member2(U))() [with U = void (*)(); T = int; pfun2_t = void (*)()]"), "namespc::my_class<T>::member2", "member2" },
|
|
{ logging::str_literal("static void (* namespc::my_class<T>::member3())() [with void (* Fun)() = foo1; T = int; pfun2_t = void (*)()]"), "namespc::my_class<T>::member3", "member3" },
|
|
{ logging::str_literal("static void (* namespc::my_class<T>::member1(pfun2_t))() [with T = void (*)(); pfun1_t = void (*)(); pfun2_t = void (*)()]"), "namespc::my_class<T>::member1", "member1" },
|
|
{ logging::str_literal("static void (* namespc::my_class<T>::member2(U))() [with U = int; T = void (*)(); pfun2_t = void (*)()]"), "namespc::my_class<T>::member2", "member2" },
|
|
{ logging::str_literal("static void (* namespc::my_class<T>::member2(U))() [with U = void (*)(); T = void (*)(); pfun2_t = void (*)()]"), "namespc::my_class<T>::member2", "member2" },
|
|
{ logging::str_literal("static void (* namespc::my_class<T>::member3())() [with void (* Fun)() = foo1; T = void (*)(); pfun2_t = void (*)()]"), "namespc::my_class<T>::member3", "member3" },
|
|
{ logging::str_literal("void (namespc::my_class2::* namespc::foo6(pfun2_t))()"), "namespc::foo6", "foo6" },
|
|
{ logging::str_literal("namespc::my_class<void(int)> namespc::foo7()"), "namespc::foo7", "foo7" },
|
|
{ logging::str_literal("void (namespc::my_class2::* const (& namespc::foo8(pfun2_t))[2])()"), "namespc::foo8", "foo8" },
|
|
{ logging::str_literal("namespc::my_class2::my_class2()"), "namespc::my_class2::my_class2", "my_class2" }, // constructor
|
|
{ logging::str_literal("namespc::my_class2::~my_class2()"), "namespc::my_class2::~my_class2", "~my_class2" }, // destructor
|
|
{ logging::str_literal("void namespc::my_class2::operator=(const namespc::my_class2&)"), "namespc::my_class2::operator=", "operator=" },
|
|
{ logging::str_literal("void namespc::my_class2::operator*() const"), "namespc::my_class2::operator*", "operator*" },
|
|
{ logging::str_literal("void namespc::my_class2::operator()()"), "namespc::my_class2::operator()", "operator()" },
|
|
{ logging::str_literal("bool namespc::my_class2::operator<(int) const"), "namespc::my_class2::operator<", "operator<" },
|
|
{ logging::str_literal("bool namespc::my_class2::operator>(int) const"), "namespc::my_class2::operator>", "operator>" },
|
|
{ logging::str_literal("bool namespc::my_class2::operator<=(int) const"), "namespc::my_class2::operator<=", "operator<=" },
|
|
{ logging::str_literal("bool namespc::my_class2::operator>=(int) const"), "namespc::my_class2::operator>=", "operator>=" },
|
|
{ logging::str_literal("namespc::my_class2::operator bool() const"), "namespc::my_class2::operator bool", "operator bool" },
|
|
{ logging::str_literal("namespc::my_class2::operator pfun1_t() const"), "namespc::my_class2::operator pfun1_t", "operator pfun1_t" },
|
|
{ logging::str_literal("std::basic_ostream<_CharT, _Traits>& namespc::operator<<(std::basic_ostream<_CharT, _Traits>&, const namespc::my_class2&) [with CharT = char; TraitsT = std::char_traits<char>]"), "namespc::operator<<", "operator<<" },
|
|
{ logging::str_literal("std::basic_istream<_CharT, _Traits>& namespc::operator>>(std::basic_istream<_CharT, _Traits>&, namespc::my_class2&) [with CharT = char; TraitsT = std::char_traits<char>]"), "namespc::operator>>", "operator>>" },
|
|
|
|
// BOOST_CURRENT_FUNCTION fallback value
|
|
{ logging::str_literal("(unknown)"), "(unknown)", "(unknown)" }
|
|
};
|
|
|
|
} // namespace
|
|
|
|
// Function name formatting
|
|
BOOST_AUTO_TEST_CASE_TEMPLATE(scopes_scope_function_name_formatting, CharT, char_types)
|
|
{
|
|
typedef attrs::named_scope named_scope;
|
|
typedef named_scope::sentry sentry;
|
|
|
|
typedef logging::attribute_set attr_set;
|
|
typedef std::basic_string< CharT > string;
|
|
typedef logging::basic_formatting_ostream< CharT > osstream;
|
|
typedef logging::record_view record_view;
|
|
typedef named_scope_test_data< CharT > data;
|
|
|
|
named_scope attr;
|
|
|
|
// First scope
|
|
const unsigned int line1 = __LINE__;
|
|
|
|
attr_set set1;
|
|
set1[data::attr1()] = attr;
|
|
|
|
record_view rec = make_record_view(set1);
|
|
|
|
for (unsigned int i = 0; i < sizeof(named_scope_test_cases) / sizeof(*named_scope_test_cases); ++i)
|
|
{
|
|
sentry scope1(named_scope_test_cases[i].scope_name, data::file(), line1, attrs::named_scope_entry::function);
|
|
string str;
|
|
osstream strm(str);
|
|
strm << named_scope_test_cases[i].function_name;
|
|
BOOST_CHECK_MESSAGE(check_formatting(data::scope_function_name_format(), rec, strm.str()), "Scope name: " << named_scope_test_cases[i].scope_name);
|
|
}
|
|
}
|
|
|
|
// Function name without scope formatting
|
|
BOOST_AUTO_TEST_CASE_TEMPLATE(scopes_function_name_formatting, CharT, char_types)
|
|
{
|
|
typedef attrs::named_scope named_scope;
|
|
typedef named_scope::sentry sentry;
|
|
|
|
typedef logging::attribute_set attr_set;
|
|
typedef std::basic_string< CharT > string;
|
|
typedef logging::basic_formatting_ostream< CharT > osstream;
|
|
typedef logging::record_view record_view;
|
|
typedef named_scope_test_data< CharT > data;
|
|
|
|
named_scope attr;
|
|
|
|
// First scope
|
|
const unsigned int line1 = __LINE__;
|
|
|
|
attr_set set1;
|
|
set1[data::attr1()] = attr;
|
|
|
|
record_view rec = make_record_view(set1);
|
|
|
|
for (unsigned int i = 0; i < sizeof(named_scope_test_cases) / sizeof(*named_scope_test_cases); ++i)
|
|
{
|
|
sentry scope1(named_scope_test_cases[i].scope_name, data::file(), line1, attrs::named_scope_entry::function);
|
|
string str;
|
|
osstream strm(str);
|
|
strm << named_scope_test_cases[i].function_name_no_scope;
|
|
BOOST_CHECK_MESSAGE(check_formatting(data::function_name_format(), rec, strm.str()), "Scope name: " << named_scope_test_cases[i].scope_name);
|
|
}
|
|
}
|
|
|
|
// The test checks that function name formatters do not affect scopes denoted with BOOST_LOG_NAMED_SCOPE
|
|
BOOST_AUTO_TEST_CASE_TEMPLATE(function_name_does_not_affect_non_function_scopes, CharT, char_types)
|
|
{
|
|
typedef attrs::named_scope named_scope;
|
|
|
|
typedef logging::attribute_set attr_set;
|
|
typedef std::basic_string< CharT > string;
|
|
typedef logging::basic_formatting_ostream< CharT > osstream;
|
|
typedef logging::record_view record_view;
|
|
typedef named_scope_test_data< CharT > data;
|
|
|
|
named_scope attr;
|
|
|
|
attr_set set1;
|
|
set1[data::attr1()] = attr;
|
|
|
|
record_view rec = make_record_view(set1);
|
|
|
|
{
|
|
BOOST_LOG_NAMED_SCOPE("void foo()");
|
|
string str;
|
|
osstream strm(str);
|
|
strm << "void foo()";
|
|
BOOST_CHECK(check_formatting(data::scope_function_name_format(), rec, strm.str()));
|
|
BOOST_CHECK(check_formatting(data::function_name_format(), rec, strm.str()));
|
|
}
|
|
}
|