[Boost-commit] svn:boost r85456 - in trunk/libs/log: src test/run

Subject: [Boost-commit] svn:boost r85456 - in trunk/libs/log: src test/run
From: andrey.semashev_at_[hidden]
Date: 2013-08-25 07:28:23

Author: andysem
Date: 2013-08-25 07:28:23 EDT (Sun, 25 Aug 2013)
New Revision: 85456
URL: http://svn.boost.org/trac/boost/changeset/85456

Log:
Added a test for formatter parser. Fixed a few bugs in the parser.

Added:
   trunk/libs/log/test/run/setup_formatter_parser.cpp   (contents, props changed)
Text files modified: 
   trunk/libs/log/src/formatter_parser.cpp            |     4                                         
   trunk/libs/log/test/run/setup_filter_parser.cpp    |    28 ++++                                    
   trunk/libs/log/test/run/setup_formatter_parser.cpp |   257 ++++++++++++++++++++++++++++++++++++++++
   3 files changed, 286 insertions(+), 3 deletions(-)

Modified: trunk/libs/log/src/formatter_parser.cpp
==============================================================================
--- trunk/libs/log/src/formatter_parser.cpp	Sun Aug 25 05:46:36 2013	(r85455)
+++ trunk/libs/log/src/formatter_parser.cpp	2013-08-25 07:28:23 EDT (Sun, 25 Aug 2013)	(r85456)
@@ -267,7 +267,7 @@
         if (p == end)
             BOOST_LOG_THROW_DESCR(parse_error, "Invalid attribute placeholder arguments description in the formatter string");
         if (*p == constants::char_paren_bracket_right)
-            return p;
+            return ++p;
 
         while (true)
         {
@@ -282,7 +282,7 @@
                 c = *p;
                 if (encoding::isspace(c) || c == constants::char_equal)
                     break;
-                if (!encoding::isalnum(c))
+                if (!encoding::isalnum(c) && c != constants::char_underline)
                     BOOST_LOG_THROW_DESCR(parse_error, "Placeholder argument name is invalid");
             }
 

Modified: trunk/libs/log/test/run/setup_filter_parser.cpp
==============================================================================
--- trunk/libs/log/test/run/setup_filter_parser.cpp	Sun Aug 25 05:46:36 2013	(r85455)
+++ trunk/libs/log/test/run/setup_filter_parser.cpp	2013-08-25 07:28:23 EDT (Sun, 25 Aug 2013)	(r85456)
@@ -610,7 +610,7 @@
     typedef base_type::string_type string_type;
 
 public:
-    explicit test_filter_factory(logging::attribute_name const& name) : m_name(name), m_rel(custom)
+    explicit test_filter_factory(logging::attribute_name const& name) : m_name(name), m_rel(custom), m_called(false)
     {
     }
 
@@ -628,10 +628,17 @@
         m_custom_rel = rel;
     }
 
+    void check_called()
+    {
+        BOOST_CHECK(m_called);
+        m_called = false;
+    }
+
     logging::filter on_exists_test(logging::attribute_name const& name)
     {
         BOOST_CHECK_EQUAL(m_name, name);
         BOOST_CHECK_EQUAL(m_rel, exists);
+        m_called = true;
         return logging::filter();
     }
     logging::filter on_equality_relation(logging::attribute_name const& name, string_type const& arg)
@@ -639,6 +646,7 @@
         BOOST_CHECK_EQUAL(m_name, name);
         BOOST_CHECK_EQUAL(m_rel, equality);
         BOOST_CHECK_EQUAL(m_arg, arg);
+        m_called = true;
         return logging::filter();
     }
     logging::filter on_inequality_relation(logging::attribute_name const& name, string_type const& arg)
@@ -646,6 +654,7 @@
         BOOST_CHECK_EQUAL(m_name, name);
         BOOST_CHECK_EQUAL(m_rel, inequality);
         BOOST_CHECK_EQUAL(m_arg, arg);
+        m_called = true;
         return logging::filter();
     }
     logging::filter on_less_relation(logging::attribute_name const& name, string_type const& arg)
@@ -653,6 +662,7 @@
         BOOST_CHECK_EQUAL(m_name, name);
         BOOST_CHECK_EQUAL(m_rel, less);
         BOOST_CHECK_EQUAL(m_arg, arg);
+        m_called = true;
         return logging::filter();
     }
     logging::filter on_greater_relation(logging::attribute_name const& name, string_type const& arg)
@@ -660,6 +670,7 @@
         BOOST_CHECK_EQUAL(m_name, name);
         BOOST_CHECK_EQUAL(m_rel, greater);
         BOOST_CHECK_EQUAL(m_arg, arg);
+        m_called = true;
         return logging::filter();
     }
     logging::filter on_less_or_equal_relation(logging::attribute_name const& name, string_type const& arg)
@@ -667,6 +678,7 @@
         BOOST_CHECK_EQUAL(m_name, name);
         BOOST_CHECK_EQUAL(m_rel, less_or_equal);
         BOOST_CHECK_EQUAL(m_arg, arg);
+        m_called = true;
         return logging::filter();
     }
     logging::filter on_greater_or_equal_relation(logging::attribute_name const& name, string_type const& arg)
@@ -674,6 +686,7 @@
         BOOST_CHECK_EQUAL(m_name, name);
         BOOST_CHECK_EQUAL(m_rel, greater_or_equal);
         BOOST_CHECK_EQUAL(m_arg, arg);
+        m_called = true;
         return logging::filter();
     }
     logging::filter on_custom_relation(logging::attribute_name const& name, string_type const& rel, string_type const& arg)
@@ -682,6 +695,7 @@
         BOOST_CHECK_EQUAL(m_rel, custom);
         BOOST_CHECK_EQUAL(m_custom_rel, rel);
         BOOST_CHECK_EQUAL(m_arg, arg);
+        m_called = true;
         return logging::filter();
     }
 
@@ -690,6 +704,7 @@
     relation_type m_rel;
     string_type m_arg;
     string_type m_custom_rel;
+    bool m_called;
 };
 
 } // namespace
@@ -704,46 +719,57 @@
     BOOST_TEST_CHECKPOINT("filter_factory::exists");
     factory->expect_relation(test_filter_factory::exists, "");
     logging::parse_filter("%MyCustomAttr%");
+    factory->check_called();
 
     BOOST_TEST_CHECKPOINT("filter_factory::equality");
     factory->expect_relation(test_filter_factory::equality, "15");
     logging::parse_filter("%MyCustomAttr% = 15");
+    factory->check_called();
 
     BOOST_TEST_CHECKPOINT("filter_factory::equality");
     factory->expect_relation(test_filter_factory::equality, "hello");
     logging::parse_filter("%MyCustomAttr% = hello");
+    factory->check_called();
 
     BOOST_TEST_CHECKPOINT("filter_factory::equality");
     factory->expect_relation(test_filter_factory::equality, "hello");
     logging::parse_filter("%MyCustomAttr% = \"hello\"");
+    factory->check_called();
 
     BOOST_TEST_CHECKPOINT("filter_factory::equality");
     factory->expect_relation(test_filter_factory::equality, "hello\nworld");
     logging::parse_filter("%MyCustomAttr% = \"hello\\nworld\"");
+    factory->check_called();
 
     BOOST_TEST_CHECKPOINT("filter_factory::inequality");
     factory->expect_relation(test_filter_factory::inequality, "hello");
     logging::parse_filter("%MyCustomAttr% != \"hello\"");
+    factory->check_called();
 
     BOOST_TEST_CHECKPOINT("filter_factory::less");
     factory->expect_relation(test_filter_factory::less, "hello");
     logging::parse_filter("%MyCustomAttr% < \"hello\"");
+    factory->check_called();
 
     BOOST_TEST_CHECKPOINT("filter_factory::greater");
     factory->expect_relation(test_filter_factory::greater, "hello");
     logging::parse_filter("%MyCustomAttr% > \"hello\"");
+    factory->check_called();
 
     BOOST_TEST_CHECKPOINT("filter_factory::less_or_equal");
     factory->expect_relation(test_filter_factory::less_or_equal, "hello");
     logging::parse_filter("%MyCustomAttr% <= \"hello\"");
+    factory->check_called();
 
     BOOST_TEST_CHECKPOINT("filter_factory::greater_or_equal");
     factory->expect_relation(test_filter_factory::greater_or_equal, "hello");
     logging::parse_filter("%MyCustomAttr% >= \"hello\"");
+    factory->check_called();
 
     BOOST_TEST_CHECKPOINT("filter_factory::custom");
     factory->expect_relation("my_relation", "hello");
     logging::parse_filter("%MyCustomAttr% my_relation \"hello\"");
+    factory->check_called();
 }
 
 // Tests for invalid filters

Added: trunk/libs/log/test/run/setup_formatter_parser.cpp
==============================================================================
--- /dev/null	00:00:00 1970	(empty, because file is newly added)
+++ trunk/libs/log/test/run/setup_formatter_parser.cpp	2013-08-25 07:28:23 EDT (Sun, 25 Aug 2013)	(r85456)
@@ -0,0 +1,257 @@
+/*
+ *          Copyright Andrey Semashev 2007 - 2013.
+ * 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   setup_formatter_parser.cpp
+ * \author Andrey Semashev
+ * \date   25.08.2013
+ *
+ * \brief  This header contains tests for the formatter parser.
+ */
+
+#define BOOST_TEST_MODULE setup_formatter_parser
+
+#include <string>
+#include <boost/test/unit_test.hpp>
+#include <boost/log/utility/setup/formatter_parser.hpp>
+
+#if !defined(BOOST_LOG_WITHOUT_SETTINGS_PARSERS) && !defined(BOOST_LOG_WITHOUT_DEFAULT_FACTORIES)
+
+#include <boost/shared_ptr.hpp>
+#include <boost/log/exceptions.hpp>
+#include <boost/log/core/record.hpp>
+#include <boost/log/core/record_view.hpp>
+#include <boost/log/attributes/constant.hpp>
+#include <boost/log/attributes/attribute_set.hpp>
+#include <boost/log/attributes/attribute_value_set.hpp>
+#include <boost/log/utility/formatting_ostream.hpp>
+#include <boost/log/expressions/formatter.hpp>
+#include "make_record.hpp"
+
+namespace logging = boost::log;
+namespace attrs = logging::attributes;
+
+typedef logging::attribute_set attr_set;
+typedef logging::attribute_value_set attr_values;
+typedef logging::record_view record_view;
+
+typedef logging::basic_formatting_ostream< char > osstream;
+typedef logging::basic_formatter< char > formatter;
+
+// Tests for simple attribute placeholders in formatters
+BOOST_AUTO_TEST_CASE(attr_placeholders)
+{
+    attrs::constant< int > attr1(10);
+    attrs::constant< std::string > attr2("hello");
+    attr_set set1;
+
+    set1["MyAttr"] = attr1;
+    set1["MyStr"] = attr2;
+
+    record_view rec = make_record_view(set1);
+
+    {
+        formatter f = logging::parse_formatter("String literal");
+        std::string str1, str2;
+        osstream strm1(str1), strm2(str2);
+        f(rec, strm1);
+        strm2 << "String literal";
+        BOOST_CHECK_EQUAL(strm1.str(), strm2.str());
+    }
+    {
+        formatter f = logging::parse_formatter("MyAttr: %MyAttr%, MyStr: %MyStr%");
+        std::string str1, str2;
+        osstream strm1(str1), strm2(str2);
+        f(rec, strm1);
+        strm2 << "MyAttr: " << attr1.get() << ", MyStr: " << attr2.get();
+        BOOST_CHECK_EQUAL(strm1.str(), strm2.str());
+    }
+    {
+        formatter f = logging::parse_formatter("MyAttr: % MyAttr %, MyStr: % MyStr %");
+        std::string str1, str2;
+        osstream strm1(str1), strm2(str2);
+        f(rec, strm1);
+        strm2 << "MyAttr: " << attr1.get() << ", MyStr: " << attr2.get();
+        BOOST_CHECK_EQUAL(strm1.str(), strm2.str());
+    }
+    {
+        formatter f = logging::parse_formatter("%MyAttr%%MyStr%");
+        std::string str1, str2;
+        osstream strm1(str1), strm2(str2);
+        f(rec, strm1);
+        strm2 << attr1.get() << attr2.get();
+        BOOST_CHECK_EQUAL(strm1.str(), strm2.str());
+    }
+    {
+        formatter f = logging::parse_formatter("MyAttr: %MyAttr%, MissingAttr: %MissingAttr%");
+        std::string str1, str2;
+        osstream strm1(str1), strm2(str2);
+        f(rec, strm1);
+        strm2 << "MyAttr: " << attr1.get() << ", MissingAttr: ";
+        BOOST_CHECK_EQUAL(strm1.str(), strm2.str());
+    }
+}
+
+namespace {
+
+class test_formatter_factory :
+    public logging::formatter_factory< char >
+{
+private:
+    typedef logging::formatter_factory< char > base_type;
+
+public:
+    typedef base_type::string_type string_type;
+    typedef base_type::args_map args_map;
+    typedef base_type::formatter_type formatter_type;
+
+public:
+    explicit test_formatter_factory(logging::attribute_name const& name) : m_name(name), m_called(false)
+    {
+    }
+
+    void expect_args(args_map const& args)
+    {
+        m_args = args;
+    }
+
+    void check_called()
+    {
+        BOOST_CHECK(m_called);
+        m_called = false;
+    }
+
+    formatter_type create_formatter(logging::attribute_name const& name, args_map const& args)
+    {
+        BOOST_CHECK_EQUAL(m_name, name);
+        BOOST_CHECK_EQUAL(m_args.size(), args.size());
+
+        for (args_map::const_iterator it = m_args.begin(), end = m_args.end(); it != end; ++it)
+        {
+            args_map::const_iterator parsed_it = args.find(it->first);
+            if (parsed_it != args.end())
+            {
+                BOOST_TEST_CHECKPOINT(("Arg: " + it->first));
+                BOOST_CHECK_EQUAL(it->second, parsed_it->second);
+            }
+            else
+            {
+                BOOST_ERROR(("Arg not found: " + it->first));
+            }
+        }
+
+        m_called = true;
+        return formatter_type();
+    }
+
+private:
+    logging::attribute_name m_name;
+    args_map m_args;
+    bool m_called;
+};
+
+} // namespace
+
+// Tests for formatter factory
+BOOST_AUTO_TEST_CASE(formatter_factory)
+{
+    logging::attribute_name attr_name("MyCustomAttr");
+    boost::shared_ptr< test_formatter_factory > factory(new test_formatter_factory(attr_name));
+    logging::register_formatter_factory(attr_name, factory);
+
+    {
+        BOOST_TEST_CHECKPOINT("formatter 1");
+        test_formatter_factory::args_map args;
+        factory->expect_args(args);
+        logging::parse_formatter("Hello: %MyCustomAttr%");
+        factory->check_called();
+    }
+    {
+        BOOST_TEST_CHECKPOINT("formatter 2");
+        test_formatter_factory::args_map args;
+        factory->expect_args(args);
+        logging::parse_formatter("Hello: %MyCustomAttr()%");
+        factory->check_called();
+    }
+    {
+        BOOST_TEST_CHECKPOINT("formatter 3");
+        test_formatter_factory::args_map args;
+        factory->expect_args(args);
+        logging::parse_formatter("Hello: %MyCustomAttr ( ) %");
+        factory->check_called();
+    }
+    {
+        BOOST_TEST_CHECKPOINT("formatter 4");
+        test_formatter_factory::args_map args;
+        args["param1"] = "10";
+        factory->expect_args(args);
+        logging::parse_formatter("Hello: %MyCustomAttr(param1=10)%");
+        factory->check_called();
+    }
+    {
+        BOOST_TEST_CHECKPOINT("formatter 5");
+        test_formatter_factory::args_map args;
+        args["param1"] = "10";
+        factory->expect_args(args);
+        logging::parse_formatter("Hello: % MyCustomAttr ( param1 = 10 ) % ");
+        factory->check_called();
+    }
+    {
+        BOOST_TEST_CHECKPOINT("formatter 6");
+        test_formatter_factory::args_map args;
+        args["param1"] = " 10 ";
+        factory->expect_args(args);
+        logging::parse_formatter("Hello: %MyCustomAttr(param1=\" 10 \")%");
+        factory->check_called();
+    }
+    {
+        BOOST_TEST_CHECKPOINT("formatter 7");
+        test_formatter_factory::args_map args;
+        args["param1"] = "10";
+        args["param2"] = "abcd";
+        factory->expect_args(args);
+        logging::parse_formatter("Hello: %MyCustomAttr(param1 = 10, param2 = abcd)%");
+        factory->check_called();
+    }
+    {
+        BOOST_TEST_CHECKPOINT("formatter 8");
+        test_formatter_factory::args_map args;
+        args["param1"] = "10";
+        args["param2"] = "abcd";
+        factory->expect_args(args);
+        logging::parse_formatter("Hello: %MyCustomAttr(param1=10,param2=abcd)%");
+        factory->check_called();
+    }
+    {
+        BOOST_TEST_CHECKPOINT("formatter 9");
+        test_formatter_factory::args_map args;
+        args["param1"] = "10";
+        args["param2"] = "abcd";
+        args["param_last"] = "-2.2";
+        factory->expect_args(args);
+        logging::parse_formatter("Hello: %MyCustomAttr(param1 = 10, param2 = \"abcd\", param_last = -2.2)%");
+        factory->check_called();
+    }
+}
+
+// Tests for invalid formatters
+BOOST_AUTO_TEST_CASE(invalid)
+{
+    BOOST_CHECK_THROW(logging::parse_formatter("%MyStr"), logging::parse_error);
+    BOOST_CHECK_THROW(logging::parse_formatter("MyStr%"), logging::parse_error);
+    BOOST_CHECK_THROW(logging::parse_formatter("%MyStr(%"), logging::parse_error);
+    BOOST_CHECK_THROW(logging::parse_formatter("%MyStr)%"), logging::parse_error);
+    BOOST_CHECK_THROW(logging::parse_formatter("%MyStr(param%"), logging::parse_error);
+    BOOST_CHECK_THROW(logging::parse_formatter("%MyStr(param=%"), logging::parse_error);
+    BOOST_CHECK_THROW(logging::parse_formatter("%MyStr(param)%"), logging::parse_error);
+    BOOST_CHECK_THROW(logging::parse_formatter("%MyStr(param=)%"), logging::parse_error);
+    BOOST_CHECK_THROW(logging::parse_formatter("%MyStr(=value)%"), logging::parse_error);
+    BOOST_CHECK_THROW(logging::parse_formatter("%MyStr(param,param2)%"), logging::parse_error);
+    BOOST_CHECK_THROW(logging::parse_formatter("%MyStr(param=value,)%"), logging::parse_error);
+    BOOST_CHECK_THROW(logging::parse_formatter("%MyStr(param=value,param2)%"), logging::parse_error);
+}
+
+#endif // !defined(BOOST_LOG_WITHOUT_SETTINGS_PARSERS) && !defined(BOOST_LOG_WITHOUT_DEFAULT_FACTORIES)