streamtestcase.cpp

log4cxx 0.10 unix下编译包

        }
        
        

#if LOG4CXX_WCHAR_T_API
        void testWide() {
            LoggerPtr root(Logger::getRootLogger());
            LOG4CXX_INFO(root, L"This is a test");
            LOGUNIT_ASSERT_EQUAL((size_t) 1, vectorAppender->getVector().size());
        }

        void testWideAppend() {
           LoggerPtr root(Logger::getRootLogger());
           LOG4CXX_INFO(root, L"This is a test" << L": Details to follow");
           LOGUNIT_ASSERT_EQUAL((size_t) 1, vectorAppender->getVector().size());
       }
       
      void testWideWidth() {
          LoggerPtr root(Logger::getRootLogger());
          LOG4CXX_INFO(root, L'[' << std::fixed << std::setprecision(2) << std::setw(7) << std::right << std::setfill(L'_') << 10.0 << L"]");
          spi::LoggingEventPtr event(vectorAppender->getVector()[0]);
          LogString msg(event->getMessage());
          LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("[__10.00]")), msg);
       }

        void testWLogStreamSimple() {
            wlogstream root(Logger::getRootLogger(), Level::getInfo());
            root << L"This is a test" << LOG4CXX_ENDMSG;
            LOGUNIT_ASSERT_EQUAL((size_t) 1, vectorAppender->getVector().size());
        }

        void testWLogStreamMultiple() {
           wlogstream root(Logger::getRootLogger(), Level::getInfo());
           root << L"This is a test" << L": Details to follow" << LOG4CXX_ENDMSG;
           LOGUNIT_ASSERT_EQUAL((size_t) 1, vectorAppender->getVector().size());
       }

       void testWLogStreamShortCircuit() {
         LoggerPtr logger(Logger::getLogger("StreamTestCase.shortCircuit"));
         logger->setLevel(Level::getInfo());
         wlogstream os(logger, Level::getDebug());
         ExceptionOnInsert someObj;
         os << someObj << LOG4CXX_ENDMSG;
         LOGUNIT_ASSERT_EQUAL((size_t) 0, vectorAppender->getVector().size());
       }

       void testWLogStreamInsertException() {
         LoggerPtr logger(Logger::getLogger("StreamTestCase.insertException"));
         ExceptionOnInsert someObj;
         wlogstream os(logger, Level::getInfo());
         os << someObj << LOG4CXX_ENDMSG;
       }

       void testWLogStreamScientific() {
           LoggerPtr root(Logger::getRootLogger());
           wlogstream os(root, Level::getInfo());
           os << std::scientific << 0.000001115 << LOG4CXX_ENDMSG;
           spi::LoggingEventPtr event(vectorAppender->getVector()[0]);
           LogString msg(event->getMessage());
           LOGUNIT_ASSERT(msg.find(LOG4CXX_STR("e-")) != LogString::npos ||
                msg.find(LOG4CXX_STR("E-")) != LogString::npos);
       }

       void testWLogStreamPrecision() {
          LoggerPtr root(Logger::getRootLogger());
          wlogstream os(root, Level::getInfo());
          os << std::setprecision(4) << 1.000001 << LOG4CXX_ENDMSG;
          spi::LoggingEventPtr event(vectorAppender->getVector()[0]);
          LogString msg(event->getMessage());
          LOGUNIT_ASSERT(msg.find(LOG4CXX_STR("1.00000")) == LogString::npos);
      }


      void testWLogStreamWidth() {
          LoggerPtr root(Logger::getRootLogger());
          wlogstream os(root, Level::getInfo());
          os << L"[" << std::fixed << std::setprecision(2) << std::setw(7) << std::right << std::setfill(L'_') << 10.0 << L"]" << LOG4CXX_ENDMSG;
          spi::LoggingEventPtr event(vectorAppender->getVector()[0]);
          LogString msg(event->getMessage());
          LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("[__10.00]")), msg);
       }
       
       void wreport(std::basic_ostream<wchar_t>& os) {
          os << L"This just in: \n";
          os << L"Use logstream in places that expect a std::ostream.\n";
       }
       
        void testWLogStreamDelegate() {
            wlogstream root(Logger::getRootLogger(), Level::getInfo());
            wreport(root);
            root << LOG4CXX_ENDMSG;
            LOGUNIT_ASSERT_EQUAL((size_t) 1, vectorAppender->getVector().size());
        }
        
        void testWLogStreamFormattingPersists() {
          LoggerPtr root(Logger::getRootLogger());
          root->setLevel(Level::getInfo());
          wlogstream os(root, Level::getDebug());
          os << std::hex << 20 << LOG4CXX_ENDMSG;
          os << Level::getInfo() << 16 << LOG4CXX_ENDMSG;
          spi::LoggingEventPtr event(vectorAppender->getVector()[0]);
          LogString msg(event->getMessage());
          LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("10")), msg);
        }

        void testWSetWidthInsert() {
          LoggerPtr root(Logger::getRootLogger());
          root->setLevel(Level::getInfo());
          wlogstream os(root, Level::getInfo());
          os << std::setw(5);
          LOGUNIT_ASSERT_EQUAL(5, os.width());
        }
        
#endif        

#if LOG4CXX_UNICHAR_API
        void testUniChar() {
            LoggerPtr root(Logger::getRootLogger());
            const log4cxx::UniChar msg[] = { 'T', 'h', 'i', 's', ' ', 'i', 's', ' ', 'a', ' ', 't', 'e', 's', 't', 0 };
            LOG4CXX_INFO(root, msg);
            LOGUNIT_ASSERT_EQUAL((size_t) 1, vectorAppender->getVector().size());
        }

        void testUniCharAppend() {
           LoggerPtr root(Logger::getRootLogger());
           const log4cxx::UniChar msg1[] = { 'T', 'h', 'i', 's', ' ', 'i', 's', ' ', 'a', ' ', 't', 'e', 's', 't', 0 };
           const log4cxx::UniChar msg2[] = { ':', ' ', 'D', 'e', 't', 'a', 'i', 'l', 's', ' ', 't', 'o', ' ', 'f', 'o', 'l', 'l', 'o', 'w', 0 };
           LOG4CXX_INFO(root, msg1 << msg2);
           LOGUNIT_ASSERT_EQUAL((size_t) 1, vectorAppender->getVector().size());
       }
       
      void testUniCharWidth() {
          LoggerPtr root(Logger::getRootLogger());
          const log4cxx::UniChar openBracket[] = { '[', 0 };
          const log4cxx::UniChar closeBracket[] = { ']', 0 };
          LOG4CXX_INFO(root, openBracket << std::fixed << std::setprecision(2) << std::setw(7) << std::right << std::setfill((log4cxx::UniChar) '_') << 10.0 << closeBracket);
          spi::LoggingEventPtr event(vectorAppender->getVector()[0]);
          LogString msg(event->getMessage());
          LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("[__10.00]")), msg);
       }

        void testULogStreamSimple() {
            ulogstream root(Logger::getRootLogger(), Level::getInfo());
            const log4cxx::UniChar msg[] = { 'T', 'h', 'i', 's', ' ', 'i', 's', ' ', 'a', ' ', 't', 'e', 's', 't', 0 };
            root << msg << LOG4CXX_ENDMSG;
            LOGUNIT_ASSERT_EQUAL((size_t) 1, vectorAppender->getVector().size());
        }

        void testULogStreamMultiple() {
           ulogstream root(Logger::getRootLogger(), Level::getInfo());
           const log4cxx::UniChar msg1[] = { 'T', 'h', 'i', 's', ' ', 'i', 's', ' ', 'a', ' ', 't', 'e', 's', 't', 0 };
           const log4cxx::UniChar msg2[] = { ':',  ' ', 'D', 'e', 't', 'a', 'i', 'l', 's', ' ', 't', 'o', ' ', 'f', 'o', 'l', 'l', 'o', 'w', 0 };
           root << msg1 << msg2 << LOG4CXX_ENDMSG;
           LOGUNIT_ASSERT_EQUAL((size_t) 1, vectorAppender->getVector().size());
       }

       void testULogStreamShortCircuit() {
         LoggerPtr logger(Logger::getLogger("StreamTestCase.shortCircuit"));
         logger->setLevel(Level::getInfo());
         ulogstream os(logger, Level::getDebug());
         ExceptionOnInsert someObj;
         os << someObj << LOG4CXX_ENDMSG;
         LOGUNIT_ASSERT_EQUAL((size_t) 0, vectorAppender->getVector().size());
       }

       void testULogStreamInsertException() {
         LoggerPtr logger(Logger::getLogger("StreamTestCase.insertException"));
         ExceptionOnInsert someObj;
         ulogstream os(logger, Level::getInfo());
         os << someObj << LOG4CXX_ENDMSG;
       }

       void testULogStreamScientific() {
           LoggerPtr root(Logger::getRootLogger());
           ulogstream os(root, Level::getInfo());
           os << std::scientific << 0.000001115 << LOG4CXX_ENDMSG;
           LOGUNIT_ASSERT_EQUAL((size_t) 1, vectorAppender->getVector().size());
           spi::LoggingEventPtr event(vectorAppender->getVector()[0]);
           LogString msg(event->getMessage());
           LOGUNIT_ASSERT(msg.find(LOG4CXX_STR("e-")) != LogString::npos ||
                msg.find(LOG4CXX_STR("E-")) != LogString::npos);
       }

       void testULogStreamPrecision() {
          LoggerPtr root(Logger::getRootLogger());
          ulogstream os(root, Level::getInfo());
          os << std::setprecision(4) << 1.000001 << LOG4CXX_ENDMSG;
          LOGUNIT_ASSERT_EQUAL((size_t) 1, vectorAppender->getVector().size());
          spi::LoggingEventPtr event(vectorAppender->getVector()[0]);
          LogString msg(event->getMessage());
          LOGUNIT_ASSERT(msg.find(LOG4CXX_STR("1.00000")) == LogString::npos);
      }


      void testULogStreamWidth() {
          LoggerPtr root(Logger::getRootLogger());
          ulogstream os(root, Level::getInfo());
          const log4cxx::UniChar openBracket[] = { '[', 0 };
          const log4cxx::UniChar closeBracket[] = { ']', 0 };
          
          os << openBracket << std::fixed << std::setprecision(2) << std::setw(7) << std::right 
              << std::setfill((log4cxx::UniChar) '_') << 10.0 << closeBracket << LOG4CXX_ENDMSG;
          LOGUNIT_ASSERT_EQUAL((size_t) 1, vectorAppender->getVector().size());
          spi::LoggingEventPtr event(vectorAppender->getVector()[0]);
          LogString msg(event->getMessage());
          LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("[__10.00]")), msg);
       }
       
       void ureport(std::basic_ostream<log4cxx::UniChar>& os) {
          const log4cxx::UniChar msg1[] = { 'T', 'h', 'i', 's', ' ', 'j', 'u', 's', 't', ' ' , 'i', 'n', ':', ' ' , '\n', 0 };
          const log4cxx::UniChar msg2[] = { 'U', 's', 'e', ' ', 'l', 'o', 'g', 's', 't', 'r', 'e', 'a', 'm', '\n', 0 };
          os << msg1;
          os << msg2;
       }
       
        void testULogStreamDelegate() {
            ulogstream root(Logger::getRootLogger(), Level::getInfo());
            ureport(root);
            root << LOG4CXX_ENDMSG;
            LOGUNIT_ASSERT_EQUAL((size_t) 1, vectorAppender->getVector().size());
        }
        
        void testULogStreamFormattingPersists() {
          LoggerPtr root(Logger::getRootLogger());
          root->setLevel(Level::getInfo());
          ulogstream os(root, Level::getDebug());
          os << std::hex << 20 << LOG4CXX_ENDMSG;
          os << Level::getInfo() << 16 << LOG4CXX_ENDMSG;
          LOGUNIT_ASSERT_EQUAL((size_t) 1, vectorAppender->getVector().size());
          spi::LoggingEventPtr event(vectorAppender->getVector()[0]);
          LogString msg(event->getMessage());
          LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("10")), msg);
        }

        void testUSetWidthInsert() {
          LoggerPtr root(Logger::getRootLogger());
          root->setLevel(Level::getInfo());
          ulogstream os(root, Level::getInfo());
          os << std::setw(5);
          LOGUNIT_ASSERT_EQUAL(5, os.width());
        }
        
#endif        

#if LOG4CXX_CFSTRING_API
        void testCFString() {
            LoggerPtr root(Logger::getRootLogger());
            LOG4CXX_INFO(root, CFSTR("This is a test"));
            LOGUNIT_ASSERT_EQUAL((size_t) 1, vectorAppender->getVector().size());
        }

        void testCFStringAppend() {
           LoggerPtr root(Logger::getRootLogger());
           LOG4CXX_INFO(root, CFSTR("This is a test") << CFSTR(": Details to follow"));
           LOGUNIT_ASSERT_EQUAL((size_t) 1, vectorAppender->getVector().size());
       }

        void testULogStreamCFString() {
            ulogstream root(Logger::getRootLogger(), Level::getInfo());
            root << CFSTR("This is a test") << LOG4CXX_ENDMSG;
            LOGUNIT_ASSERT_EQUAL((size_t) 1, vectorAppender->getVector().size());
        }

        void testULogStreamCFString2() {
           ulogstream root(Logger::getRootLogger(), Level::getInfo());
           root << CFSTR("This is a test") << CFSTR(": Details to follow") << LOG4CXX_ENDMSG;
           LOGUNIT_ASSERT_EQUAL((size_t) 1, vectorAppender->getVector().size());
       }
#endif

};

LOGUNIT_TEST_SUITE_REGISTRATION(StreamTestCase);


#if !LOG4CXX_USE_GLOBAL_SCOPE_TEMPLATE
//
//   The following code tests compilation errors
//      around bug LOGCXX-150 and is not intended to be executed.
//      Skipped for VC6 since it can't handle having the
//      templated operator<< in class scope.s
namespace foo
{
  class Bar
  {
    void fn();
  };
  
std::ostream &operator<<(std::ostream &o, Bar const &b)
  {
    return o << "Bar";
  }
}


using namespace foo;

namespace
{
  log4cxx::LoggerPtr logger(log4cxx::Logger::getLogger("foo"));
  log4cxx::logstream lout(logger, log4cxx::Level::getDebug());
}

void Bar::fn()
{
  lout << "hi" << LOG4CXX_ENDMSG;
}
#endif