loggertestcase.cpp

log4cxx 0.10 unix下编译包

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <log4cxx/logger.h>
#include <log4cxx/fileappender.h>
#include <log4cxx/appenderskeleton.h>
#include <log4cxx/basicconfigurator.h>
#include <log4cxx/logmanager.h>
#include <log4cxx/level.h>
#include <log4cxx/hierarchy.h>
#include <log4cxx/spi/rootlogger.h>
#include <log4cxx/helpers/propertyresourcebundle.h>
#include "insertwide.h"
#include "testchar.h"
#include "logunit.h"
#include <log4cxx/helpers/locale.h>
#include "vectorappender.h"

using namespace log4cxx;
using namespace log4cxx::spi;
using namespace log4cxx::helpers;

class CountingAppender;
typedef helpers::ObjectPtrT<CountingAppender> CountingAppenderPtr;

class CountingAppender : public AppenderSkeleton
{
public:
        int counter;

        CountingAppender() : counter(0)
                {}

        void close()
                {}

        void append(const spi::LoggingEventPtr& /*event*/, Pool& /*p*/)
                { counter++; }

        bool requiresLayout() const
                { return true; }
};

LOGUNIT_CLASS(LoggerTestCase)
{
        LOGUNIT_TEST_SUITE(LoggerTestCase);
                LOGUNIT_TEST(testAppender1);
                LOGUNIT_TEST(testAppender2);
                LOGUNIT_TEST(testAdditivity1);
                LOGUNIT_TEST(testAdditivity2);
                LOGUNIT_TEST(testAdditivity3);
                LOGUNIT_TEST(testDisable1);
//    LOGUNIT_TEST(testRB1);
//    LOGUNIT_TEST(testRB2);  //TODO restore
//    LOGUNIT_TEST(testRB3);
                LOGUNIT_TEST(testExists);
                LOGUNIT_TEST(testHierarchy1);
                LOGUNIT_TEST(testTrace);
                LOGUNIT_TEST(testIsTraceEnabled);
        LOGUNIT_TEST_SUITE_END();

public:
        void setUp()
        {
        }

        void tearDown()
        {
                BasicConfigurator::resetConfiguration();
                a1 = 0;
                a2 = 0;
        logger = 0;
        }

        /**
        Add an appender and see if it can be retrieved.
        */
        void testAppender1()
        {
                logger = Logger::getLogger(LOG4CXX_TEST_STR("test"));
                a1 = new FileAppender();
                a1->setName(LOG4CXX_STR("testAppender1"));
                logger->addAppender(a1);

                AppenderList list = logger->getAllAppenders();
                AppenderPtr aHat = list.front();
                LOGUNIT_ASSERT_EQUAL(a1, aHat);
        }

        /**
        Add an appender X, Y, remove X and check if Y is the only
        remaining appender.
        */
        void testAppender2()
        {
                a1 = new FileAppender();
                a1->setName(LOG4CXX_STR("testAppender2.1"));
                a2 = new FileAppender();
                a2->setName(LOG4CXX_STR("testAppender2.2"));

                logger = Logger::getLogger(LOG4CXX_TEST_STR("test"));
                logger->addAppender(a1);
                logger->addAppender(a2);
                logger->removeAppender((LogString) LOG4CXX_STR("testAppender2.1"));

                AppenderList list = logger->getAllAppenders();
                AppenderPtr aHat = list.front();
                LOGUNIT_ASSERT_EQUAL(a2, aHat);
                LOGUNIT_ASSERT(list.size() == 1);
        }

        /**
        Test if LoggerPtr a.b inherits its appender from a.
        */
        void testAdditivity1()
        {
                LoggerPtr a = Logger::getLogger(LOG4CXX_TEST_STR("a"));
                LoggerPtr ab = Logger::getLogger(LOG4CXX_TEST_STR("a.b"));
                CountingAppenderPtr ca = new CountingAppender();
                a->addAppender(ca);

                LOGUNIT_ASSERT_EQUAL(ca->counter, 0);
                ab->debug(MSG);
                LOGUNIT_ASSERT_EQUAL(ca->counter, 1);
                ab->info(MSG);
                LOGUNIT_ASSERT_EQUAL(ca->counter, 2);
                ab->warn(MSG);
                LOGUNIT_ASSERT_EQUAL(ca->counter, 3);
                ab->error(MSG);
                LOGUNIT_ASSERT_EQUAL(ca->counter, 4);
        }

        /**
        Test multiple additivity.
        */
        void testAdditivity2()
        {
                LoggerPtr a = Logger::getLogger(LOG4CXX_TEST_STR("a"));
                LoggerPtr ab = Logger::getLogger(LOG4CXX_TEST_STR("a.b"));
                LoggerPtr abc = Logger::getLogger(LOG4CXX_TEST_STR("a.b.c"));
                LoggerPtr x = Logger::getLogger(LOG4CXX_TEST_STR("x"));

                CountingAppenderPtr ca1 = new CountingAppender();
                CountingAppenderPtr ca2 = new CountingAppender();

                a->addAppender(ca1);
                abc->addAppender(ca2);

                LOGUNIT_ASSERT_EQUAL(ca1->counter, 0);
                LOGUNIT_ASSERT_EQUAL(ca2->counter, 0);

                ab->debug(MSG);
                LOGUNIT_ASSERT_EQUAL(ca1->counter, 1);
                LOGUNIT_ASSERT_EQUAL(ca2->counter, 0);

                abc->debug(MSG);
                LOGUNIT_ASSERT_EQUAL(ca1->counter, 2);
                LOGUNIT_ASSERT_EQUAL(ca2->counter, 1);

                x->debug(MSG);
                LOGUNIT_ASSERT_EQUAL(ca1->counter, 2);
                LOGUNIT_ASSERT_EQUAL(ca2->counter, 1);
        }

        /**
        Test additivity flag.
        */
        void testAdditivity3()
        {
                LoggerPtr root = Logger::getRootLogger();
                LoggerPtr a = Logger::getLogger(LOG4CXX_TEST_STR("a"));
                LoggerPtr ab = Logger::getLogger(LOG4CXX_TEST_STR("a.b"));
                LoggerPtr abc = Logger::getLogger(LOG4CXX_TEST_STR("a.b.c"));
                LoggerPtr x = Logger::getLogger(LOG4CXX_TEST_STR("x"));

                CountingAppenderPtr caRoot = new CountingAppender();
                CountingAppenderPtr caA = new CountingAppender();
                CountingAppenderPtr caABC = new CountingAppender();

                root->addAppender(caRoot);
                a->addAppender(caA);
                abc->addAppender(caABC);

                LOGUNIT_ASSERT_EQUAL(caRoot->counter, 0);
                LOGUNIT_ASSERT_EQUAL(caA->counter, 0);
                LOGUNIT_ASSERT_EQUAL(caABC->counter, 0);

                ab->setAdditivity(false);

                a->debug(MSG);
                LOGUNIT_ASSERT_EQUAL(caRoot->counter, 1);
                LOGUNIT_ASSERT_EQUAL(caA->counter, 1);
                LOGUNIT_ASSERT_EQUAL(caABC->counter, 0);

                ab->debug(MSG);
                LOGUNIT_ASSERT_EQUAL(caRoot->counter, 1);
                LOGUNIT_ASSERT_EQUAL(caA->counter, 1);
                LOGUNIT_ASSERT_EQUAL(caABC->counter, 0);

                abc->debug(MSG);
                LOGUNIT_ASSERT_EQUAL(caRoot->counter, 1);
                LOGUNIT_ASSERT_EQUAL(caA->counter, 1);
                LOGUNIT_ASSERT_EQUAL(caABC->counter, 1);
        }

        void testDisable1()
        {
                CountingAppenderPtr caRoot = new CountingAppender();
                LoggerPtr root = Logger::getRootLogger();
                root->addAppender(caRoot);

                LoggerRepositoryPtr h = LogManager::getLoggerRepository();

                //h.disableDebug();
                h->setThreshold(Level::getInfo());
                LOGUNIT_ASSERT_EQUAL(caRoot->counter, 0);

                root->debug(MSG);