socketservertestcase.cpp

log4cxx 0.10 unix下编译包

        void test4()
        {
                SocketAppenderPtr socketAppender1 =
                        new SocketAppender(LOG4CXX_STR("localhost"), PORT);
                root->addAppender(socketAppender1);
                NDC::push(LOG4CXX_TEST_STR("some"));
                common("test4", LOG4CXX_STR("T4"), LOG4CXX_STR("key4"), LOG4CXX_STR("MDC-TEST4"));
                NDC::pop();
                delay(1);

                ControlFilter cf;
                cf << PAT4;

                ThreadFilter threadFilter;

                std::vector<Filter *> filters;
                filters.push_back(&cf);
                filters.push_back(&threadFilter);

                try
                {
                        Transformer::transform(TEMP, FILTERED, filters);
                }
                catch(UnexpectedFormatException& e)
                {
                        std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
                        throw;
                }

                LOGUNIT_ASSERT(Compare::compare(FILTERED, LOG4CXX_FILE("witness/socketServer.4")));
        }

        void test5()
        {
                SocketAppenderPtr socketAppender1 =
                        new SocketAppender(LOG4CXX_STR("localhost"), PORT);
                AsyncAppenderPtr asyncAppender = new AsyncAppender();

                root->addAppender(socketAppender1);
                root->addAppender(asyncAppender);

                NDC::push(LOG4CXX_TEST_STR("some5"));
                common("test5", LOG4CXX_STR("T5"), LOG4CXX_STR("key5"), LOG4CXX_STR("MDC-TEST5"));
                NDC::pop();
                delay(2);

                ControlFilter cf;
                cf << PAT5;

                ThreadFilter threadFilter;

                std::vector<Filter *> filters;
                filters.push_back(&cf);
                filters.push_back(&threadFilter);

                try
                {
                        Transformer::transform(TEMP, FILTERED, filters);
                }
                catch(UnexpectedFormatException& e)
                {
                        std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
                        throw;
                }

                LOGUNIT_ASSERT(Compare::compare(FILTERED, LOG4CXX_FILE("witness/socketServer.5")));
        }

        void test6()
        {
                SocketAppenderPtr socketAppender1 =
                        new SocketAppender(LOG4CXX_STR("localhost"), PORT);
                AsyncAppenderPtr asyncAppender = new AsyncAppender();

                root->addAppender(socketAppender1);
                root->addAppender(asyncAppender);

                NDC::push(LOG4CXX_TEST_STR("some6"));
                MDC::put(LOG4CXX_TEST_STR("hostID"), LOG4CXX_TEST_STR("client-test6"));
                common("test6", LOG4CXX_STR("T6"), LOG4CXX_STR("key6"), LOG4CXX_STR("MDC-TEST6"));
                NDC::pop();
                MDC::remove(LOG4CXX_TEST_STR("hostID"));
                delay(2);

                ControlFilter cf;
                cf << PAT6;

                ThreadFilter threadFilter;

                std::vector<Filter *> filters;
                filters.push_back(&cf);
                filters.push_back(&threadFilter);

                try
                {
                        Transformer::transform(TEMP, FILTERED, filters);
                }
                catch(UnexpectedFormatException& e)
                {
                        std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
                        throw;
                }

                LOGUNIT_ASSERT(Compare::compare(FILTERED, LOG4CXX_FILE("witness/socketServer.6")));
        }

        void test7()
        {
                SocketAppenderPtr socketAppender1 =
                        new SocketAppender(LOG4CXX_STR("localhost"), PORT);
                AsyncAppenderPtr asyncAppender = new AsyncAppender();

                root->addAppender(socketAppender1);
                root->addAppender(asyncAppender);

                NDC::push(LOG4CXX_TEST_STR("some7"));
                MDC::put(LOG4CXX_TEST_STR("hostID"), LOG4CXX_TEST_STR("client-test7"));
                common("test7", LOG4CXX_STR("T7"), LOG4CXX_STR("key7"), LOG4CXX_STR("MDC-TEST7"));
                NDC::pop();
                MDC::remove(LOG4CXX_TEST_STR("hostID"));
                delay(2);

                ControlFilter cf;
                cf << PAT7;

                ThreadFilter threadFilter;

                std::vector<Filter *> filters;
                filters.push_back(&cf);
                filters.push_back(&threadFilter);

                try
                {
                        Transformer::transform(TEMP, FILTERED, filters);
                }
                catch(UnexpectedFormatException& e)
                {
                        std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
                        throw;
                }

                LOGUNIT_ASSERT(Compare::compare(FILTERED, LOG4CXX_FILE("witness/socketServer.7")));
        }

        void test8()
        {
                SocketAppenderPtr socketAppender1 =
                        new SocketAppender(LOG4CXX_STR("localhost"), PORT);

                root->addAppender(socketAppender1);

                NDC::push(LOG4CXX_TEST_STR("some8"));
                common("test8", LOG4CXX_STR("T8"), LOG4CXX_STR("key8"), LOG4CXX_STR("MDC-TEST8"));
                NDC::pop();
                delay(2);

                ControlFilter cf;
                cf << PAT8;

                ThreadFilter threadFilter;

                std::vector<Filter *> filters;
                filters.push_back(&cf);
                filters.push_back(&threadFilter);

                try
                {
                        Transformer::transform(TEMP, FILTERED, filters);
                }
                catch(UnexpectedFormatException& e)
                {
                        std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
                        throw;
                }

                LOGUNIT_ASSERT(Compare::compare(FILTERED, LOG4CXX_FILE("witness/socketServer.8")));
        }

        void common(const std::string& testName, const LogString& dc, const LogString& key, const LogString& val)
        {
                int i = -1;
                NDC::push(dc);
                MDC::put(key, val);
                
                logger->setLevel(Level::getDebug());
                root->setLevel(Level::getDebug());

                LOG4CXX_TRACE(logger, "Message " << i);
                i++;

                logger->setLevel(Level::getTrace());
                root->setLevel(Level::getTrace());
                
                LOG4CXX_TRACE(logger, "Message " << ++i);
                LOG4CXX_TRACE(root, "Message " << ++i);

                LOG4CXX_DEBUG(logger, "Message " << ++i);
                LOG4CXX_DEBUG(root, "Message " << ++i);
                
                LOG4CXX_INFO(logger, "Message "  << ++i);
                LOG4CXX_WARN(logger, "Message " << ++i);
                LOG4CXX_FATAL(logger, "Message " << ++i); //5
                
                std::string exceptionMsg("\njava.lang.Exception: Just testing\n"
                    "\tat org.apache.log4j.net.SocketServerTestCase.common(SocketServerTestCase.java:XXX)\n"
                    "\tat org.apache.log4j.net.SocketServerTestCase.");
                exceptionMsg.append(testName);
                exceptionMsg.append("(SocketServerTestCase.java:XXX)\n"
                    "\tat junit.framework.TestCase.runTest(TestCase.java:XXX)\n"
                    "\tat junit.framework.TestCase.runBare(TestCase.java:XXX)\n"
                    "\tat junit.framework.TestResult$1.protect(TestResult.java:XXX)\n"
                    "\tat junit.framework.TestResult.runProtected(TestResult.java:XXX)\n"
                    "\tat junit.framework.TestResult.run(TestResult.java:XXX)\n"
                    "\tat junit.framework.TestCase.run(TestCase.java:XXX)\n"
                    "\tat junit.framework.TestSuite.runTest(TestSuite.java:XXX)\n"
                    "\tat junit.framework.TestSuite.run(TestSuite.java:XXX)");

                
                LOG4CXX_DEBUG(logger, "Message " << ++i << exceptionMsg);
                LOG4CXX_ERROR(root, "Message " << ++i << exceptionMsg);

                NDC::pop();
                MDC::remove(key);
        }

        void delay(int secs)
        {
                apr_sleep(APR_USEC_PER_SEC * secs);
        }

        private:
        static const File TEMP;
        static const File FILTERED;
};

const File SocketServerTestCase::TEMP("output/temp");
const File SocketServerTestCase::FILTERED("output/filtered");

LOGUNIT_TEST_SUITE_REGISTRATION_DISABLED(SocketServerTestCase)