/**
 * @file llerror_test.cpp
 * @date   December 2006
 * @brief error unit tests
 *
 * $LicenseInfo:firstyear=2006&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2010, Linden Research, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation;
 * version 2.1 of the License only.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
 * $/LicenseInfo$
 */

#include <vector>
#include <stdexcept>

#include "linden_common.h"

#include "../llerror.h"

#include "../llerrorcontrol.h"
#include "../llsd.h"

#include "../test/lltut.h"

enum LogFieldIndex
{
    TIME_FIELD,
    LEVEL_FIELD,
    TAGS_FIELD,
    LOCATION_FIELD,
    FUNCTION_FIELD,
    MSG_FIELD
};

static const char* FieldName[] =
{
    "TIME",
    "LEVEL",
    "TAGS",
    "LOCATION",
    "FUNCTION",
    "MSG"
};

namespace
{
#ifdef __clang__
#   pragma clang diagnostic ignored "-Wunused-function"
#endif
    void test_that_error_h_includes_enough_things_to_compile_a_message()
    {
        LL_INFOS() << "!" << LL_ENDL;
    }
}

namespace
{
    static bool fatalWasCalled = false;
    struct FatalWasCalled: public std::runtime_error
    {
        FatalWasCalled(const std::string& what): std::runtime_error(what) {}
    };
    void fatalCall(const std::string& msg) { throw FatalWasCalled(msg); }
}

// Because we use LLError::setFatalFunction(fatalCall), any LL_ERRS call we
// issue will throw FatalWasCalled. But we want the test program to continue.
// So instead of writing:
// LL_ERRS("tag") << "some message" << LL_ENDL;
// write:
// CATCH(LL_ERRS("tag"), "some message");
#define CATCH(logcall, expr)                    \
    try                                         \
    {                                           \
        logcall << expr << LL_ENDL;             \
    }                                           \
    catch (const FatalWasCalled&)               \
    {                                           \
        fatalWasCalled = true;                  \
    }

namespace tut
{
    class TestRecorder : public LLError::Recorder
    {
    public:
        TestRecorder()
            {
                showTime(false);
            }
        virtual ~TestRecorder()
            {}

        virtual void recordMessage(LLError::ELevel level,
                           const std::string& message)
        {
            mMessages.push_back(message);
        }

        int countMessages() const   { return (int) mMessages.size(); }
        void clearMessages()        { mMessages.clear(); }

        std::string message(int n) const
        {
            std::ostringstream test_name;
            test_name << "testing message " << n << ", not enough messages";

            tut::ensure(test_name.str(), n < countMessages());
            return mMessages[n];
        }

        void reportMessages() const
        {
            std::cerr << '\n';
            int n = 0;
            for (const auto& msg : mMessages)
            {
                std::cerr << std::setw(2) << n++ << ": " << msg.substr(0, 100) << '\n';
            }
        }

    private:
        typedef std::vector<std::string> MessageVector;
        MessageVector mMessages;
    };

    struct ErrorTestData
    {
        LLError::RecorderPtr mRecorder;
        LLError::SettingsStoragePtr mPriorErrorSettings;

        auto recorder() { return std::dynamic_pointer_cast<TestRecorder>(mRecorder); }

        ErrorTestData():
            mRecorder(new TestRecorder())
        {
            fatalWasCalled = false;

            mPriorErrorSettings = LLError::saveAndResetSettings();
            LLError::setDefaultLevel(LLError::LEVEL_DEBUG);
            LLError::setFatalFunction(fatalCall);
            LLError::addRecorder(mRecorder);
        }

        ~ErrorTestData()
        {
            LLError::removeRecorder(mRecorder);
            LLError::restoreSettings(mPriorErrorSettings);
        }

        int countMessages()
        {
            return recorder()->countMessages();
        }

        void clearMessages()
        {
            recorder()->clearMessages();
        }

        void setWantsTime(bool t)
        {
            recorder()->showTime(t);
        }

        void setWantsMultiline(bool t)
        {
            recorder()->showMultiline(t);
        }

        std::string message(int n)
        {
            return recorder()->message(n);
        }

        void reportMessages()
        {
            recorder()->reportMessages();
        }

        void ensure_message_count(int expectedCount)
        {
            ensure_equals("message count", countMessages(), expectedCount);
        }

        std::string message_field(int msgnum, LogFieldIndex fieldnum)
        {
            std::ostringstream test_name;
            test_name << "testing message " << msgnum << ", not enough messages";
            tut::ensure(test_name.str(), msgnum < countMessages());

            std::string msg(message(msgnum));

            std::string field_value;

            // find the start of the field; fields are separated by a single space
            size_t scan = 0;
            int on_field = 0;
            while ( scan < msg.length() && on_field < fieldnum )
            {
                // fields are delimited by one space
                if ( ' ' == msg[scan] )
                {
                    if ( on_field < FUNCTION_FIELD )
                    {
                        on_field++;
                    }
                    // except function, which may have embedded spaces so ends with " : "
                    else if (( on_field == FUNCTION_FIELD )
                             && ( ':' == msg[scan+1] && ' ' == msg[scan+2] )
                             )
                    {
                        on_field++;
                        scan +=2;
                    }
                }
                scan++;
            }
            size_t start_field = scan;
            size_t fieldlen = 0;
            if ( fieldnum < FUNCTION_FIELD )
            {
                fieldlen = msg.find(' ', start_field) - start_field;
            }
            else if ( fieldnum == FUNCTION_FIELD )
            {
                fieldlen = msg.find(" : ", start_field) - start_field;
            }
            else if ( MSG_FIELD == fieldnum ) // no delimiter, just everything to the end
            {
                fieldlen = msg.length() - start_field;
            }

            return msg.substr(start_field, fieldlen);
        }

        void ensure_message_field_equals(int msgnum, LogFieldIndex fieldnum, const std::string& expectedText)
        {
            std::ostringstream test_name;
            test_name << "testing message " << msgnum << " field " << FieldName[fieldnum] << "\n  message: \"" << message(msgnum).substr(0, 100) << "\"\n   ";

            try
            {
                ensure_equals(test_name.str(), message_field(msgnum, fieldnum), expectedText);
            }
            catch (const failure&)
            {
                reportMessages();
                throw;
            }
        }

        void ensure_message_does_not_contain(int n, const std::string& expectedText)
        {
            std::ostringstream test_name;
            test_name << "testing message " << n;

            try
            {
                ensure_does_not_contain(test_name.str(), message(n), expectedText);
            }
            catch (const failure&)
            {
                reportMessages();
                throw;
            }
        }
    };

    typedef test_group<ErrorTestData>   ErrorTestGroup;
    typedef ErrorTestGroup::object      ErrorTestObject;

    ErrorTestGroup errorTestGroup("error");

    template<> template<>
    void ErrorTestObject::test<1>()
        // basic test of output
    {
        LL_INFOS() << "test" << LL_ENDL;
        LL_INFOS() << "bob" << LL_ENDL;

        ensure_message_field_equals(0, MSG_FIELD, "test");
        ensure_message_field_equals(1, MSG_FIELD, "bob");
    }
}

namespace
{
    void writeSome()
    {
        LL_DEBUGS("WriteTag","AnotherTag") << "one" << LL_ENDL;
        LL_INFOS("WriteTag") << "two" << LL_ENDL;
        LL_WARNS("WriteTag") << "three" << LL_ENDL;
        CATCH(LL_ERRS("WriteTag"), "four");
    }
};

namespace tut
{
    template<> template<>
    void ErrorTestObject::test<2>()
        // messages are filtered based on default level
    {
        LLError::setDefaultLevel(LLError::LEVEL_DEBUG);
        writeSome();
        ensure_message_field_equals(0, MSG_FIELD, "one");
        ensure_message_field_equals(0, LEVEL_FIELD, "DEBUG");
        ensure_message_field_equals(0, TAGS_FIELD, "#WriteTag#AnotherTag#");
        ensure_message_field_equals(1, MSG_FIELD, "two");
        ensure_message_field_equals(1, LEVEL_FIELD, "INFO");
        ensure_message_field_equals(1, TAGS_FIELD, "#WriteTag#");
        ensure_message_field_equals(2, MSG_FIELD, "three");
        ensure_message_field_equals(2, LEVEL_FIELD, "WARNING");
        ensure_message_field_equals(2, TAGS_FIELD, "#WriteTag#");
        ensure_message_field_equals(3, MSG_FIELD, "four");
        ensure_message_field_equals(3, LEVEL_FIELD, "ERROR");
        ensure_message_field_equals(3, TAGS_FIELD, "#WriteTag#");
        // LL_ERRS() produces 2 recordMessage() calls
        ensure_message_count(5);

        LLError::setDefaultLevel(LLError::LEVEL_INFO);
        writeSome();
        ensure_message_field_equals(5, MSG_FIELD, "two");
        ensure_message_field_equals(6, MSG_FIELD, "three");
        ensure_message_field_equals(7, MSG_FIELD, "four");
        // LL_ERRS() produces 2 recordMessage() calls
        ensure_message_count(9);

        LLError::setDefaultLevel(LLError::LEVEL_WARN);
        writeSome();
        ensure_message_field_equals(9, MSG_FIELD, "three");
        ensure_message_field_equals(10, MSG_FIELD, "four");
        // LL_ERRS() produces 2 recordMessage() calls
        ensure_message_count(12);

        LLError::setDefaultLevel(LLError::LEVEL_ERROR);
        writeSome();
        ensure_message_field_equals(12, MSG_FIELD, "four");
        // LL_ERRS() produces 2 recordMessage() calls
        ensure_message_count(14);

        LLError::setDefaultLevel(LLError::LEVEL_NONE);
        writeSome();
        ensure_message_count(14);
    }

    template<> template<>
    void ErrorTestObject::test<3>()
        // error type string in output
    {
        writeSome();
        ensure_message_field_equals(0, LEVEL_FIELD, "DEBUG");
        ensure_message_field_equals(1, LEVEL_FIELD, "INFO");
        ensure_message_field_equals(2, LEVEL_FIELD, "WARNING");
        ensure_message_field_equals(3, LEVEL_FIELD, "ERROR");
        // LL_ERRS() produces 2 recordMessage() calls
        ensure_message_count(5);
    }

    template<> template<>
    void ErrorTestObject::test<4>()
        // file abbreviation
    {
        std::string prev, abbreviateFile = __FILE__;
        do
        {
            prev = abbreviateFile;
            abbreviateFile = LLError::abbreviateFile(abbreviateFile);
            // __FILE__ is assumed to end with
            // indra/llcommon/tests/llerror_test.cpp. This test used to call
            // abbreviateFile() exactly once, then check below whether it
            // still contained the string 'indra'. That fails if the FIRST
            // part of the pathname also contains indra! Certain developer
            // machine images put local directory trees under
            // /ngi-persist/indra, which is where we observe the problem. So
            // now, keep calling abbreviateFile() until it returns its
            // argument unchanged, THEN check.
        } while (abbreviateFile != prev);

        ensure_ends_with("file name abbreviation",
            abbreviateFile,
            "llcommon/tests/llerror_test.cpp"
            );
        ensure_does_not_contain("file name abbreviation",
            abbreviateFile, "indra");

        std::string someFile =
#if LL_WINDOWS
            "C:/amy/bob/cam.cpp"
#else
            "/amy/bob/cam.cpp"
#endif
            ;
        std::string someAbbreviation = LLError::abbreviateFile(someFile);

        ensure_equals("non-indra file abbreviation",
            someAbbreviation, someFile);
    }
}

namespace
{
    std::string locationString(int line)
    {
        std::ostringstream location;
        location << LLError::abbreviateFile(__FILE__)
                 << "(" << line << ")";

        return location.str();
    }

    std::string writeReturningLocation()
    {
        LL_INFOS() << "apple" << LL_ENDL;   int this_line = __LINE__;
        return locationString(this_line);
    }

    void writeReturningLocationAndFunction(std::string& location, std::string& function)
    {
        LL_INFOS() << "apple" << LL_ENDL;   int this_line = __LINE__;
        location = locationString(this_line);
        function = __FUNCTION__;
    }

    std::string errorReturningLocation()
    {
        int this_line = __LINE__;   CATCH(LL_ERRS(), "die");
        return locationString(this_line);
    }
}

/* The following helper functions and class members all log a simple message
    from some particular function scope.  Each function takes a bool argument
    that indicates if it should log its own name or not (in the manner that
    existing log messages often do.)  The functions all return their C++
    name so that test can be substantial mechanized.
 */

std::string logFromGlobal(bool id)
{
    LL_INFOS() << (id ? "logFromGlobal: " : "") << "hi" << LL_ENDL;
    return "logFromGlobal";
}

static std::string logFromStatic(bool id)
{
    LL_INFOS() << (id ? "logFromStatic: " : "") << "hi" << LL_ENDL;
    return "logFromStatic";
}

namespace
{
    std::string logFromAnon(bool id)
    {
        LL_INFOS() << (id ? "logFromAnon: " : "") << "hi" << LL_ENDL;
        return "logFromAnon";
    }
}

namespace Foo {
    std::string logFromNamespace(bool id)
    {
        LL_INFOS() << (id ? "Foo::logFromNamespace: " : "") << "hi" << LL_ENDL;
        //return "Foo::logFromNamespace";
            // there is no standard way to get the namespace name, hence
            // we won't be testing for it
        return "logFromNamespace";
    }
}

namespace
{
    class ClassWithNoLogType {
    public:
        std::string logFromMember(bool id)
        {
            LL_INFOS() << (id ? "ClassWithNoLogType::logFromMember: " : "") << "hi" << LL_ENDL;
            return "ClassWithNoLogType::logFromMember";
        }
        static std::string logFromStatic(bool id)
        {
            LL_INFOS() << (id ? "ClassWithNoLogType::logFromStatic: " : "") << "hi" << LL_ENDL;
            return "ClassWithNoLogType::logFromStatic";
        }
    };

    class ClassWithLogType {
        LOG_CLASS(ClassWithLogType);
    public:
        std::string logFromMember(bool id)
        {
            LL_INFOS() << (id ? "ClassWithLogType::logFromMember: " : "") << "hi" << LL_ENDL;
            return "ClassWithLogType::logFromMember";
        }
        static std::string logFromStatic(bool id)
        {
            LL_INFOS() << (id ? "ClassWithLogType::logFromStatic: " : "") << "hi" << LL_ENDL;
            return "ClassWithLogType::logFromStatic";
        }
    };

    std::string logFromNamespace(bool id) { return Foo::logFromNamespace(id); }
    std::string logFromClassWithLogTypeMember(bool id) { ClassWithLogType c; return c.logFromMember(id); }
    std::string logFromClassWithLogTypeStatic(bool id) { return ClassWithLogType::logFromStatic(id); }

    void ensure_has(const std::string& message,
        const std::string& actual, const std::string& expected)
    {
        std::string::size_type n1 = actual.find(expected);
        if (n1 == std::string::npos)
        {
            std::stringstream ss;
            ss << message << ": " << "expected to find a copy of '" << expected
               << "' in actual '" << actual << "'";
            throw tut::failure(ss.str().c_str());
        }
    }

    typedef std::string (*LogFromFunction)(bool);
    void testLogName(LLError::RecorderPtr recorder, LogFromFunction f,
        const std::string& class_name = "")
    {
        std::dynamic_pointer_cast<tut::TestRecorder>(recorder)->clearMessages();
        std::string name = f(false);
        f(true);

        std::string messageWithoutName = std::dynamic_pointer_cast<tut::TestRecorder>(recorder)->message(0);
        std::string messageWithName = std::dynamic_pointer_cast<tut::TestRecorder>(recorder)->message(1);

        ensure_has(name + " logged without name",
            messageWithoutName, name);
        ensure_has(name + " logged with name",
            messageWithName, name);

        if (!class_name.empty())
        {
            ensure_has(name + "logged without name",
                messageWithoutName, class_name);
            ensure_has(name + "logged with name",
                messageWithName, class_name);
        }
    }
}

namespace
{
    void writeMsgNeedsEscaping()
    {
        LL_DEBUGS("WriteTag") << "backslash\\" << LL_ENDL;
        LL_INFOS("WriteTag") << "newline\nafternewline" << LL_ENDL;
        LL_WARNS("WriteTag") << "return\rafterreturn" << LL_ENDL;

        LL_DEBUGS("WriteTag") << "backslash\\backslash\\" << LL_ENDL;
        LL_INFOS("WriteTag") << "backslash\\newline\nanothernewline\nafternewline" << LL_ENDL;
        LL_WARNS("WriteTag") << "backslash\\returnnewline\r\n\\afterbackslash" << LL_ENDL;
    }
};

namespace tut
{
    template<> template<>
    void ErrorTestObject::test<5>()
        // backslash, return, and newline are not escaped with backslashes
    {
        LLError::setDefaultLevel(LLError::LEVEL_DEBUG);
        setWantsMultiline(true);
        writeMsgNeedsEscaping(); // but should not be now
        ensure_message_field_equals(0, MSG_FIELD, "backslash\\");
        ensure_message_field_equals(1, MSG_FIELD, "newline\nafternewline");
        ensure_message_field_equals(2, MSG_FIELD, "return\rafterreturn");
        ensure_message_field_equals(3, MSG_FIELD, "backslash\\backslash\\");
        ensure_message_field_equals(4, MSG_FIELD, "backslash\\newline\nanothernewline\nafternewline");
        ensure_message_field_equals(5, MSG_FIELD, "backslash\\returnnewline\r\n\\afterbackslash");
        ensure_message_count(6);
    }
}

namespace tut
{
    template<> template<>
        //  class/function information in output
    void ErrorTestObject::test<6>()
    {
        testLogName(mRecorder, logFromGlobal);
        testLogName(mRecorder, logFromStatic);
        testLogName(mRecorder, logFromAnon);
        testLogName(mRecorder, logFromNamespace);
        testLogName(mRecorder, logFromClassWithLogTypeMember, "ClassWithLogType");
        testLogName(mRecorder, logFromClassWithLogTypeStatic, "ClassWithLogType");
    }
}

namespace
{
    std::string innerLogger()
    {
        LL_INFOS() << "inside" << LL_ENDL;
        return "moo";
    }

    std::string outerLogger()
    {
        LL_INFOS() << "outside(" << innerLogger() << ")" << LL_ENDL;
        return "bar";
    }

    class LogWhileLogging
    {
    public:
        void print(std::ostream& out) const
        {
            LL_INFOS() << "logging" << LL_ENDL;
            out << "baz";
        }
    };

    std::ostream& operator<<(std::ostream& out, const LogWhileLogging& l)
        { l.print(out); return out; }

    void metaLogger()
    {
        LogWhileLogging l;
        LL_INFOS() << "meta(" << l << ")" << LL_ENDL;
    }

}

namespace tut
{
    template<> template<>
        // handle nested logging
    void ErrorTestObject::test<7>()
    {
        outerLogger();
        ensure_message_field_equals(0, MSG_FIELD, "inside");
        ensure_message_field_equals(1, MSG_FIELD, "outside(moo)");
        ensure_message_count(2);

        metaLogger();
        ensure_message_field_equals(2, MSG_FIELD, "logging");
        ensure_message_field_equals(3, MSG_FIELD, "meta(baz)");
        ensure_message_count(4);
    }

    template<> template<>
        // special handling of LL_ERRS() calls
    void ErrorTestObject::test<8>()
    {
        std::string location = errorReturningLocation();

        ensure_message_field_equals(0, LOCATION_FIELD, location);
        ensure_message_field_equals(0, MSG_FIELD, "die");
        // LL_ERRS() produces 2 recordMessage() calls
        ensure_message_count(2);

        ensure("fatal callback called", fatalWasCalled);
    }
}

namespace
{
    std::string roswell()
    {
        return "1947-07-08T03:04:05Z";
    }

    void ufoSighting()
    {
        LL_INFOS() << "ufo" << LL_ENDL;
    }
}

namespace tut
{
    template<> template<>
        // time in output (for recorders that need it)
    void ErrorTestObject::test<9>()
    {
        LLError::setTimeFunction(roswell);

        setWantsTime(false);
        ufoSighting();
        ensure_message_field_equals(0, MSG_FIELD, "ufo");
        ensure_message_does_not_contain(0, roswell());

        setWantsTime(true);
        ufoSighting();
        ensure_message_field_equals(1, MSG_FIELD, "ufo");
        ensure_message_field_equals(1, TIME_FIELD, roswell());
    }

    template<> template<>
        // output order
    void ErrorTestObject::test<10>()
    {
        LLError::setTimeFunction(roswell);
        setWantsTime(true);

        std::string location,
                    function;
        writeReturningLocationAndFunction(location, function);

        ensure_equals("order is time level tags location function message",
                      message(0),
                      roswell() + " INFO " + "# " /* no tag */ + location + " " + function + " : " + "apple");
    }

    template<> template<>
        // multiple recorders
    void ErrorTestObject::test<11>()
    {
        LLError::RecorderPtr altRecorder(new TestRecorder());
        LLError::addRecorder(altRecorder);

        LL_INFOS() << "boo" << LL_ENDL;

        ensure_message_field_equals(0, MSG_FIELD, "boo");
        ensure_equals("alt recorder count", std::dynamic_pointer_cast<TestRecorder>(altRecorder)->countMessages(), 1);
        ensure_contains("alt recorder message 0", std::dynamic_pointer_cast<TestRecorder>(altRecorder)->message(0), "boo");

        LLError::setTimeFunction(roswell);

        LLError::RecorderPtr anotherRecorder(new TestRecorder());
        std::dynamic_pointer_cast<TestRecorder>(anotherRecorder)->showTime(true);
        LLError::addRecorder(anotherRecorder);

        LL_INFOS() << "baz" << LL_ENDL;

        std::string when = roswell();

        ensure_message_does_not_contain(1, when);
        ensure_equals("alt recorder count", std::dynamic_pointer_cast<TestRecorder>(altRecorder)->countMessages(), 2);
        ensure_does_not_contain("alt recorder message 1", std::dynamic_pointer_cast<TestRecorder>(altRecorder)->message(1), when);
        ensure_equals("another recorder count", std::dynamic_pointer_cast<TestRecorder>(anotherRecorder)->countMessages(), 1);
        ensure_contains("another recorder message 0", std::dynamic_pointer_cast<TestRecorder>(anotherRecorder)->message(0), when);

        LLError::removeRecorder(altRecorder);
        LLError::removeRecorder(anotherRecorder);
    }
}

class TestAlpha
{
    LOG_CLASS(TestAlpha);
public:
    static void doDebug()   { LL_DEBUGS() << "add dice" << LL_ENDL; }
    static void doInfo()    { LL_INFOS()  << "any idea" << LL_ENDL; }
    static void doWarn()    { LL_WARNS()  << "aim west" << LL_ENDL; }
    static void doError()   { CATCH(LL_ERRS(), "ate eels"); }
    static void doAll() { doDebug(); doInfo(); doWarn(); doError(); }
};

class TestBeta
{
    LOG_CLASS(TestBeta);
public:
    static void doDebug()   { LL_DEBUGS() << "bed down" << LL_ENDL; }
    static void doInfo()    { LL_INFOS()  << "buy iron" << LL_ENDL; }
    static void doWarn()    { LL_WARNS()  << "bad word" << LL_ENDL; }
    static void doError()   { CATCH(LL_ERRS(), "big easy"); }
    static void doAll() { doDebug(); doInfo(); doWarn(); doError(); }
};

namespace tut
{
    template<> template<>
        // filtering by class
    void ErrorTestObject::test<12>()
    {
        LLError::setDefaultLevel(LLError::LEVEL_WARN);
        LLError::setClassLevel("TestBeta", LLError::LEVEL_INFO);

        TestAlpha::doAll();
        TestBeta::doAll();

        ensure_message_field_equals(0, MSG_FIELD, "aim west");
        ensure_message_field_equals(1, MSG_FIELD, "ate eels");
        // LL_ERRS() produces 2 recordMessage() calls
        ensure_message_field_equals(3, MSG_FIELD, "buy iron");
        ensure_message_field_equals(4, MSG_FIELD, "bad word");
        ensure_message_field_equals(5, MSG_FIELD, "big easy");
        // LL_ERRS() produces 2 recordMessage() calls
        ensure_message_count(7);
    }

    template<> template<>
        // filtering by function, and that it will override class filtering
    void ErrorTestObject::test<13>()
    {
        LLError::setDefaultLevel(LLError::LEVEL_DEBUG);
        LLError::setClassLevel("TestBeta", LLError::LEVEL_WARN);
        LLError::setFunctionLevel("TestBeta::doInfo", LLError::LEVEL_DEBUG);
        LLError::setFunctionLevel("TestBeta::doError", LLError::LEVEL_NONE);

        TestBeta::doAll();
        ensure_message_field_equals(0, MSG_FIELD, "buy iron");
        ensure_message_field_equals(1, MSG_FIELD, "bad word");
        ensure_message_count(2);
    }

    template<> template<>
        // filtering by file
        // and that it is overridden by both class and function filtering
    void ErrorTestObject::test<14>()
    {
        LLError::setDefaultLevel(LLError::LEVEL_DEBUG);
        LLError::setFileLevel(LLError::abbreviateFile(__FILE__),
                                    LLError::LEVEL_WARN);
        LLError::setClassLevel("TestAlpha", LLError::LEVEL_INFO);
        LLError::setFunctionLevel("TestAlpha::doError",
                                    LLError::LEVEL_NONE);
        LLError::setFunctionLevel("TestBeta::doError",
                                    LLError::LEVEL_NONE);

        TestAlpha::doAll();
        TestBeta::doAll();
        ensure_message_field_equals(0, MSG_FIELD, "any idea");
        ensure_message_field_equals(1, MSG_FIELD, "aim west");
        ensure_message_field_equals(2, MSG_FIELD, "bad word");
        ensure_message_count(3);
    }

    template<> template<>
        // proper cached, efficient lookup of filtering
    void ErrorTestObject::test<15>()
    {
        LLError::setDefaultLevel(LLError::LEVEL_NONE);

        TestAlpha::doInfo();
        ensure_message_count(0);
        ensure_equals("first check", LLError::shouldLogCallCount(), 1);
        TestAlpha::doInfo();
        ensure_message_count(0);
        ensure_equals("second check", LLError::shouldLogCallCount(), 1);

        LLError::setClassLevel("TestAlpha", LLError::LEVEL_DEBUG);
        TestAlpha::doInfo();
        ensure_message_count(1);
        ensure_equals("third check", LLError::shouldLogCallCount(), 2);
        TestAlpha::doInfo();
        ensure_message_count(2);
        ensure_equals("fourth check", LLError::shouldLogCallCount(), 2);

        LLError::setClassLevel("TestAlpha", LLError::LEVEL_WARN);
        TestAlpha::doInfo();
        ensure_message_count(2);
        ensure_equals("fifth check", LLError::shouldLogCallCount(), 3);
        TestAlpha::doInfo();
        ensure_message_count(2);
        ensure_equals("sixth check", LLError::shouldLogCallCount(), 3);
    }

    template<> template<>
        // configuration from LLSD
    void ErrorTestObject::test<16>()
    {
        LLSD config;
        config["print-location"] = true;
        config["default-level"] = "DEBUG";

        LLSD set1;
        set1["level"] = "WARN";
        set1["files"][0] = LLError::abbreviateFile(__FILE__);

        LLSD set2;
        set2["level"] = "INFO";
        set2["classes"][0] = "TestAlpha";

        LLSD set3;
        set3["level"] = "NONE";
        set3["functions"][0] = "TestAlpha::doError";
        set3["functions"][1] = "TestBeta::doError";

        config["settings"][0] = set1;
        config["settings"][1] = set2;
        config["settings"][2] = set3;

        LLError::configure(config);

        TestAlpha::doAll();
        TestBeta::doAll();
        ensure_message_field_equals(0, MSG_FIELD, "any idea");
        ensure_message_field_equals(1, MSG_FIELD, "aim west");
        ensure_message_field_equals(2, MSG_FIELD, "bad word");
        ensure_message_count(3);

        // make sure reconfiguring works
        LLSD config2;
        config2["default-level"] = "WARN";

        LLError::configure(config2);

        TestAlpha::doAll();
        TestBeta::doAll();
        ensure_message_field_equals(3, MSG_FIELD, "aim west");
        ensure_message_field_equals(4, MSG_FIELD, "ate eels");
        // LL_ERRS() produces 2 recordMessage() calls
        ensure_message_field_equals(6, MSG_FIELD, "bad word");
        ensure_message_field_equals(7, MSG_FIELD, "big easy");
        // LL_ERRS() produces 2 recordMessage() calls
        ensure_message_count(9);
    }
}

namespace tut
{
    template<> template<>
    void ErrorTestObject::test<17>()
        // backslash, return, and newline are escaped with backslashes
    {
        LLError::setDefaultLevel(LLError::LEVEL_DEBUG);
        writeMsgNeedsEscaping();
        ensure_message_field_equals(0, MSG_FIELD, "backslash\\\\");
        ensure_message_field_equals(1, MSG_FIELD, "newline\\nafternewline");
        ensure_message_field_equals(2, MSG_FIELD, "return\\rafterreturn");
        ensure_message_field_equals(3, MSG_FIELD, "backslash\\\\backslash\\\\");
        ensure_message_field_equals(4, MSG_FIELD, "backslash\\\\newline\\nanothernewline\\nafternewline");
        ensure_message_field_equals(5, MSG_FIELD, "backslash\\\\returnnewline\\r\\n\\\\afterbackslash");
        ensure_message_count(6);
    }
}

namespace
{
    std::string writeTagWithSpaceReturningLocation()
    {
        int this_line = __LINE__; CATCH(LL_DEBUGS("Write Tag"), "not allowed");
        return locationString(this_line);
    }
};

namespace tut
{
    template<> template<>
    void ErrorTestObject::test<18>()
        // space character is not allowed in a tag
    {
        LLError::setDefaultLevel(LLError::LEVEL_DEBUG);
        fatalWasCalled = false;

        std::string location = writeTagWithSpaceReturningLocation();
        std::string expected = "Space is not allowed in a log tag at " + location;
        ensure_message_field_equals(0, LEVEL_FIELD, "ERROR");
        ensure_message_field_equals(0, MSG_FIELD, expected);
        ensure("fatal callback called", fatalWasCalled);
    }
}

/* Tests left:
    handling of classes without LOG_CLASS

    live update of filtering from file

    syslog recorder
    file recorder
    cerr/stderr recorder
    fixed buffer recorder
    windows recorder

    mutex use when logging (?)
    strange careful about to crash handling (?)
*/