* This method builds some file names based on a hard coded date pattern, while the important
* thing is that the used time is "now" for the first and one additional second into the future
* for each subsequent file name. The method is used to build names which are expected to get
* created by loggers afterwards, so the existence of those files can be checked easily.
*
*
* The given {@code prefix} is for the file name only, we hard code "output" as directory.
*
*
* Using {@code startInFuture} the caller can specify if the first created file name uses "now"
* or already starts one second in the future. This depends on what the caller wants to check:
* If it is the existence of specially named files and the caller uses some generic log file to
* start with, it's most likely that the first file name to checks needs to be in the future,
* because new files are only created with subsequent log statements. The first goes to the
* generically named file, afterwards the test sleeps a bit and the next statement is creating
* the first file to check for. During the time between those two calls the current second and
* therefore "now" could have easily past and the first file name will never be found, because
* the rolling appender creates it with a newer "now", at least one second in the future.
*
* @param[in,out] pool
* @param[in] prefix
* @param[in] fnames
* @param[in,opt] compressed
* @param[in,opt] startInFuture
*/
template
void buildTsFnames(
Pool& pool,
const LogString& prefix,
LogString (&fnames)[N],
bool compressed = false,
bool startInFuture = false)
{
SimpleDateFormat sdf(DATE_PATTERN_STR);
log4cxx_time_t now(current_time);
LogString ext(compressed ? LOG4CXX_STR(".gz") : LOG4CXX_STR(""));
now += startInFuture ? APR_USEC_PER_SEC : 0;
for (size_t i = 0; i < N; ++i)
{
fnames[i].assign(LogString(LOG4CXX_STR("" DIR_PRE_OUTPUT)) + prefix);
sdf.format(fnames[i], now, pool);
fnames[i].append(ext);
now += APR_USEC_PER_SEC;
}
}
/**
* Log some msg and sleep.
*
* Most tests need to log some message to some files and sleep afterwards, to spread the msgs
* over time and timestamp based named files. This method handles this for all tests to not need
* to replicate the same code AND deals with the fact that the logigng statements should contain
* the original src function and line. For that to work each caller needs to provide us the
* additional information and we redefine LOG4CXX_LOCATION to use that provided data instead of
* that from the compiler when a log statement is issued. While this is a bit ugly, because we
* need to duplicate the definition of LOG4CXX_LOCATION, it is easier than to duplicate the code
* for logging and sleeping per test in this file.
*
*
* The given wait factor is always multiplied with 1 second and the result is waited for, so a
* caller needs to e.g. provide {@code 0.5} if it needs log statements to distribute over given
* files, resulting in two statements per file. If the caller needs indivdual file to check for
* their existence, {@code 1} can be provided, which ensures that we wait for at least the next
* second.
*
*
* It is important the the caller provides aus with {@code __LOG4CXX_FUNC__} instead of only
* {@code __FUNC__} or such, because the latter is compiler specific and log4cxx already deals
* with such things.
*
*
* We had macro wrappers around this method dealing with such things in the past, but as args
* where added, those become more and more difficult to maintain properly and therefore removed.
*
* @param[in,out] pool
* @param[in] howOften
* @param[in] srcFunc
* @param[in] srcLine
* @param[in,opt] startWith
* @param[in] waitFactor
*/
void logMsgAndSleep(
Pool& pool,
size_t howOften,
std::string srcFunc,
size_t srcLine,
size_t startWith = 0,
float waitFactor = 0.5)
{
#undef LOG4CXX_LOCATION
#define LOG4CXX_LOCATION ::log4cxx::spi::LocationInfo( \
__FILE__, \
__FILE__, \
srcFunc.c_str(), \
srcLine)
for (size_t i = startWith; i < startWith + howOften; ++i)
{
std::string message("Hello---");
message.append(pool.itoa(i));
LOG4CXX_DEBUG(logger, message);
current_time += (APR_USEC_PER_SEC * waitFactor);
}
#undef LOG4CXX_LOCATION
#define LOG4CXX_LOCATION ::log4cxx::spi::LocationInfo( \
__FILE__, \
__FILE__, \
__LOG4CXX_FUNC__, \
__LINE__)
}
/**
* Check witness by comparing file contents.
*
* This method checks the witness for some test by comparing the contents of the given file used
* by that test. To find the corresponding witness, the prefix of the test needs to be provided,
* which is some unique part of the file name to use, while we hard code the parent dir and
* other non changing parts of the name.
*
*
* We don't use a wrapper macro this time because the src line should have the same name in all
* compilers and is easily to add for the caller.
*
* @param[in,out] pool
* @param[in] prefix
* @param[in] fname
* @param[in] witnessIdx
* @param[in] srcLine
*/
void compareWitness(
Pool& pool,
const LogString& prefix,
const LogString& fname,
size_t witnessIdx,
size_t srcLine)
{
LogString witness(LOG4CXX_STR("" DIR_PRE_WITNESS));
witness.append(prefix);
StringHelper::toString(witnessIdx, pool, witness);
//std::wcerr << L"Comparing file: " << fname << L"\n";
//std::wcerr << L"Comparing witness: " << witness << L"\n";
LOGUNIT_ASSERT_SRCL(Compare::compare(fname, File(witness)), srcLine);
}
/**
* Check witnesses by comparing file contents.
*
* This method is a wrapper around {@link compareWitness}, used to iterate over all files from a
* given test.
*
* @param[in,out] pool
* @param[in] prefix
* @param[in] fnames
* @param[in] srcLine
*/
template
void compareWitnesses(
Pool& pool,
const LogString& prefix,
LogString (&fnames)[N],
size_t srcLine)
{
for (int i = 0; i < N; ++i)
{
this->compareWitness(pool, prefix, fnames[i], i, srcLine);
}
}
/**
* Check existing files.
*
* This method checks that the first N - 1 files of the given array actually exist and compares
* the last one by content to some witness.
*
*
* We don't use a wrapper macro this time because the src line should have the same name in all
* compilers and is easily to add for the caller.
*
* @param[in,out] pool
* @param[in] prefix
* @param[in] fnames
* @param[in] witnessIdx
* @param[in] srcLine
*/
template
void checkFilesExist(
Pool& pool,
const LogString& prefix,
LogString (&fnames)[N],
size_t witnessIdx,
size_t srcLine)
{
for (int i = 0; i < N - 1; ++i)
{
//std::wcerr << L"Check: " << fnames[i] << L"\n";
LOGUNIT_ASSERT_EQUAL_SRCL(true, File(fnames[i]).exists(pool), srcLine);
}
this->compareWitness(pool, prefix, fnames[witnessIdx], witnessIdx, srcLine);
}
/**
* Let the current second pass.
*
* This method assures that the current second and some additional time gets passed before
* returning.
*
* @param[in,opt] millis
*/
void delayUntilNextSecond()
{
current_time += APR_USEC_PER_SEC;
}
/**
* Let the current second pass with some msg.
*
* This method works exactly like {@link delayUntilNextSecond(size_t)}, but additionally prints
* a message before and after the wait on STDOUT for debugging purposes.
*
* @param[in,opt] millis
*/
void delayUntilNextSecondWithMsg()
{
std::cout << "Advancing one second\n";
delayUntilNextSecond();
}
/**
* Delete generic log file.
*
* Some tests use generic log file names which may already be available during subsequent calls
* to the test and influence their behavior, e.g. because RollingFileAppender uses the last
* modification time of already existing files to create its internal name. Such a date might be
* from the arbitrary past, but most of the tests assume operations like rollovers within a few
* seconds around "new". Those assumptions will fail for older existing files. This method can
* be used to delete those files, while documenting the problem at the same time.
*
* @param[in,out] pool
* @param[in] path
*/
void delGenericLogFile(
Pool& pool,
LogString path)
{
File(path).deleteFile(pool);
}
/**
* Set the current time for each individual test methhod run.
*
* There's at least one test running multiple other tests WITHIN the same lifecycle of
* {@code setUp} and {@code tearDown}, but each of the test methods need the same current time
* to start with. So this method can be used to set that and is simply used by {@code setUp}
* as well.
*
*/
void setUpCurrTime()
{
//current_time = log4cxx::helpers::Date::currentTime(); // Start at "about" now.
//current_time -= (current_time % APR_USEC_PER_SEC); // Go to the top of the second
//current_time++; // Need to not be at the top of a second for rollover logic to work correctly
current_time = 1; // Start at about unix epoch
}
public:
log4cxx_time_t currentTime()
{
return current_time;
}
void setUp()
{
BasicConfigurator::configure(std::make_shared (
LOG4CXX_STR("%d{ABSOLUTE} [%t] %level %c{2}#%M:%L - %m%n")
));
this->logger = LogManager::getLogger("org.apache.log4j.TimeBasedRollingTest");
this->setUpCurrTime();
helpers::Date::setGetCurrentTimeFunction( std::bind( &TimeBasedRollingTest::currentTime, this ) );
}
void tearDown()
{
LogManager::shutdown();
}
/**
* Test rolling without compression, activeFileName left blank, no stop/start.
*/
void test1()
{
Pool pool;
const size_t nrOfFnames(4);
LogString fnames[nrOfFnames];
PatternLayoutPtr layout( new PatternLayout(PATTERN_LAYOUT));
RollingFileAppenderPtr rfa( new RollingFileAppender());
rfa->setAppend(false);
rfa->setLayout(layout);
TimeBasedRollingPolicyPtr tbrp(new TimeBasedRollingPolicy());
tbrp->setFileNamePattern(LOG4CXX_STR("" DIR_PRE_OUTPUT "test1-%d{" DATE_PATTERN "}"));
tbrp->activateOptions(pool);
rfa->setRollingPolicy(tbrp);
rfa->activateOptions(pool);
logger->addAppender(rfa);
this->buildTsFnames<4>(pool, LOG4CXX_STR("test1-"), fnames);
this->delayUntilNextSecondWithMsg();
this->logMsgAndSleep( pool, nrOfFnames + 1, __LOG4CXX_FUNC__, __LINE__);
this->compareWitnesses<4>( pool, LOG4CXX_STR("test1."), fnames, __LINE__);
}
/**
* No compression, with stop/restart, activeFileName left blank.
*/
void test2()
{
Pool pool;
const size_t nrOfFnames(4);
LogString fnames[nrOfFnames];
PatternLayoutPtr layout1(new PatternLayout(PATTERN_LAYOUT));
RollingFileAppenderPtr rfa1( new RollingFileAppender());
rfa1->setAppend(false);
rfa1->setLayout(layout1);
TimeBasedRollingPolicyPtr tbrp1(new TimeBasedRollingPolicy());
tbrp1->setFileNamePattern(LOG4CXX_STR("" DIR_PRE_OUTPUT "test2-%d{" DATE_PATTERN "}"));
tbrp1->activateOptions(pool);
rfa1->setRollingPolicy(tbrp1);
rfa1->activateOptions(pool);
logger->addAppender(rfa1);
this->buildTsFnames<4>(pool, LOG4CXX_STR("test2-"), fnames);
this->delayUntilNextSecondWithMsg();
this->logMsgAndSleep(pool, 3, __LOG4CXX_FUNC__, __LINE__);
logger->removeAppender(rfa1);
rfa1->close();
PatternLayoutPtr layout2(new PatternLayout(PATTERN_LAYOUT));
RollingFileAppenderPtr rfa2( new RollingFileAppender());
rfa2->setLayout(layout2);
TimeBasedRollingPolicyPtr tbrp2 = TimeBasedRollingPolicyPtr(new TimeBasedRollingPolicy());
tbrp2->setFileNamePattern(LOG4CXX_STR("" DIR_PRE_OUTPUT "test2-%d{" DATE_PATTERN "}"));
tbrp2->activateOptions(pool);
rfa2->setRollingPolicy(tbrp2);
rfa2->activateOptions(pool);
rfa2->setAppend(false);
logger->addAppender(rfa2);
this->logMsgAndSleep( pool, 2, __LOG4CXX_FUNC__, __LINE__, 3);
this->compareWitnesses<4>( pool, LOG4CXX_STR("test2."), fnames, __LINE__);
}
/**
* With compression, activeFileName left blank, no stop/restart.
*/
void test3()
{
Pool pool;
const size_t nrOfFnames(4);
LogString fnames[nrOfFnames];
PatternLayoutPtr layout( new PatternLayout(PATTERN_LAYOUT));
RollingFileAppenderPtr rfa( new RollingFileAppender());
rfa->setAppend(false);
rfa->setLayout(layout);
TimeBasedRollingPolicyPtr tbrp = TimeBasedRollingPolicyPtr(new TimeBasedRollingPolicy());
tbrp->setFileNamePattern(LogString(LOG4CXX_STR("" DIR_PRE_OUTPUT "test3-%d{" DATE_PATTERN "}.gz")));
tbrp->activateOptions(pool);
rfa->setRollingPolicy(tbrp);
rfa->activateOptions(pool);
logger->addAppender(rfa);
this->buildTsFnames<4>(pool, LOG4CXX_STR("test3-"), fnames, true);
fnames[nrOfFnames - 1].resize(fnames[nrOfFnames - 1].size() - 3);
this->delayUntilNextSecondWithMsg();
this->logMsgAndSleep( pool, nrOfFnames + 1, __LOG4CXX_FUNC__, __LINE__);
this->checkFilesExist<4>( pool, LOG4CXX_STR("test3."), fnames, nrOfFnames - 1, __LINE__);
}
/**
* Without compression, activeFileName set, with stop/restart
*
* Note: because this test stops and restarts, it is not possible to use the
* date pattern in the filenames, as log4cxx will use the file's last modified
* time when rolling over and determining the new filename.
*/
void test4()
{
Pool pool;
const size_t nrOfFnames(4);
const size_t nrOfLogMsgs(((nrOfFnames - 1) * 2) - 1);
LogString fnames[nrOfFnames];
PatternLayoutPtr layout1(new PatternLayout(PATTERN_LAYOUT));
RollingFileAppenderPtr rfa1( new RollingFileAppender());
rfa1->setLayout(layout1);
TimeBasedRollingPolicyPtr tbrp1 = TimeBasedRollingPolicyPtr(new TimeBasedRollingPolicy());
tbrp1->setFileNamePattern(LOG4CXX_STR("" DIR_PRE_OUTPUT "test4-%d{" DATE_PATTERN "}"));
tbrp1->activateOptions(pool);
rfa1->setFile(LOG4CXX_STR("" DIR_PRE_OUTPUT "test4.log"));
rfa1->setRollingPolicy(tbrp1);
rfa1->activateOptions(pool);
logger->addAppender(rfa1);
this->delGenericLogFile(pool, rfa1->getFile());
this->buildTsFnames<4>(pool, LOG4CXX_STR("test4-"), fnames);
fnames[0].assign(rfa1->getFile());
this->delayUntilNextSecondWithMsg();
this->logMsgAndSleep(pool, nrOfLogMsgs, __LOG4CXX_FUNC__, __LINE__);
logger->removeAppender(rfa1);
rfa1->close();
PatternLayoutPtr layout2(new PatternLayout(PATTERN_LAYOUT));
RollingFileAppenderPtr rfa2( new RollingFileAppender());
rfa2->setLayout(layout2);
TimeBasedRollingPolicyPtr tbrp2 = TimeBasedRollingPolicyPtr(new TimeBasedRollingPolicy());
tbrp2->setFileNamePattern(LOG4CXX_STR("" DIR_PRE_OUTPUT "test4-%d{" DATE_PATTERN "}"));
tbrp2->activateOptions(pool);
rfa2->setFile(rfa1->getFile());
rfa2->setRollingPolicy(tbrp2);
rfa2->activateOptions(pool);
logger->addAppender(rfa2);
// The one file not checked is the active file from the old appender reused by the new one
// and rolled over afterwards. The problem is that because the reused file exists already,
// it doesn't get an expected fname, but the last write time instead. Though, should be safe
// enough to not check that special file.
this->logMsgAndSleep(pool, 2, __LOG4CXX_FUNC__, __LINE__, nrOfLogMsgs);
this->compareWitness(pool, LOG4CXX_STR("test4."), fnames[0], 0, __LINE__);
this->compareWitness(pool, LOG4CXX_STR("test4."), fnames[1], 1, __LINE__);
this->compareWitness(pool, LOG4CXX_STR("test4."), fnames[2], 2, __LINE__);
}
/**
* No compression, activeFileName set, without stop/restart.
*/
void test5()
{
Pool pool;
const size_t nrOfFnames(4);
const size_t nrOfLogMsgs((nrOfFnames * 2) - 1);
LogString fnames[nrOfFnames];
PatternLayoutPtr layout( new PatternLayout(PATTERN_LAYOUT));
RollingFileAppenderPtr rfa( new RollingFileAppender());
rfa->setLayout(layout);
TimeBasedRollingPolicyPtr tbrp = TimeBasedRollingPolicyPtr(new TimeBasedRollingPolicy());
tbrp->setFileNamePattern(LOG4CXX_STR("" DIR_PRE_OUTPUT "test5-%d{" DATE_PATTERN "}"));
rfa->setFile(LOG4CXX_STR("" DIR_PRE_OUTPUT "test5.log"));
tbrp->activateOptions(pool);
rfa->setRollingPolicy(tbrp);
rfa->activateOptions(pool);
logger->addAppender(rfa);
this->delGenericLogFile(pool, rfa->getFile());
this->buildTsFnames<4>(pool, LOG4CXX_STR("test5-"), fnames);
fnames[0].assign(rfa->getFile());
this->delayUntilNextSecondWithMsg();
this->logMsgAndSleep( pool, nrOfLogMsgs, __LOG4CXX_FUNC__, __LINE__);
this->compareWitnesses<4>( pool, LOG4CXX_STR("test5."), fnames, __LINE__);
}
/**
* With compression, activeFileName set, no stop/restart.
*/
void test6()
{
Pool pool;
const size_t nrOfFnames(4);
const size_t nrOfLogMsgs((nrOfFnames * 2) - 1);
LogString fnames[nrOfFnames];
PatternLayoutPtr layout( new PatternLayout(PATTERN_LAYOUT));
RollingFileAppenderPtr rfa( new RollingFileAppender());
rfa->setAppend(false);
rfa->setLayout(layout);
TimeBasedRollingPolicyPtr tbrp = TimeBasedRollingPolicyPtr(new TimeBasedRollingPolicy());
tbrp->setFileNamePattern(LogString(LOG4CXX_STR("" DIR_PRE_OUTPUT "test6-%d{" DATE_PATTERN "}.gz")));
rfa->setFile(LOG4CXX_STR("" DIR_PRE_OUTPUT "test6.log"));
tbrp->activateOptions(pool);
rfa->setRollingPolicy(tbrp);
rfa->activateOptions(pool);
logger->addAppender(rfa);
this->delGenericLogFile(pool, rfa->getFile());
this->buildTsFnames<4>(pool, LOG4CXX_STR("test6-"), fnames, true);
fnames[0].assign(rfa->getFile());
this->delayUntilNextSecondWithMsg();
this->logMsgAndSleep( pool, nrOfLogMsgs, __LOG4CXX_FUNC__, __LINE__);
this->checkFilesExist( pool, LOG4CXX_STR("test6."), fnames, 0, __LINE__);
}
/**
* Repeat some tests with generic file names.
*
* This test calls some tests which use generic file names and will only work properly if those
* got deleted before running the test during setup.
*
*/
void test7()
{
typedef void (TimeBasedRollingTest::*Test)();
typedef std::vector Tests;
Tests tests(10);
size_t numTest = 0;
tests.at(4) = &TimeBasedRollingTest::test4;
tests.at(5) = &TimeBasedRollingTest::test5;
tests.at(6) = &TimeBasedRollingTest::test6;
for (size_t numTest = 1; numTest < tests.size(); ++numTest)
{
Test test(tests.at(numTest));
if (!test)
{
continue;
}
this->setUpCurrTime();
(this->*test)();
}
}
void rollIntoDir()
{
Pool pool;
const size_t nrOfFnames(4);
const size_t nrOfLogMsgs((nrOfFnames * 2) - 1);
LogString fnames[nrOfFnames];
PatternLayoutPtr layout( new PatternLayout(PATTERN_LAYOUT));
RollingFileAppenderPtr rfa( new RollingFileAppender());
rfa->setLayout(layout);
rfa->setFile(LOG4CXX_STR("" DIR_PRE_OUTPUT "rollIntoDir.log"));
std::random_device dev;
std::mt19937 rng(dev());
std::uniform_int_distribution dist(1,100000);
LogString filenamePattern = LOG4CXX_STR("" DIR_PRE_OUTPUT);
LogString dirNumber;
StringHelper::toString(dist(rng), dirNumber);
LogString directoryName = LOG4CXX_STR("tbr-rollIntoDir-");
directoryName.append( dirNumber );
filenamePattern.append( directoryName );
LogString filenamePatternPrefix = filenamePattern;
filenamePattern.append( LOG4CXX_STR("/file-%d{" DATE_PATTERN "}") );
TimeBasedRollingPolicyPtr tbrp(new TimeBasedRollingPolicy());
tbrp->setFileNamePattern(filenamePattern);
tbrp->activateOptions(pool);
rfa->setRollingPolicy(tbrp);
rfa->activateOptions(pool);
logger->addAppender(rfa);
const logchar* prefix = directoryName.append(LOG4CXX_STR("/file-")).data();
this->delGenericLogFile(pool, rfa->getFile());
this->buildTsFnames<4>(pool, prefix, fnames);
fnames[0].assign(rfa->getFile());
this->delayUntilNextSecondWithMsg();
this->logMsgAndSleep( pool, nrOfLogMsgs, __LOG4CXX_FUNC__, __LINE__);
this->checkFilesExist( pool, LOG4CXX_STR("test6."), fnames, 0, __LINE__);
}
};
LOGUNIT_TEST_SUITE_REGISTRATION(TimeBasedRollingTest);
apache-log4cxx-1.3.1/src/test/cpp/rolling/rollingfileappenderpropertiestest.cpp 0000644 0001751 0000177 00000016702 14721727031 027446 0 ustar runner docker /*
* 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 "../util/compare.h"
#include "../insertwide.h"
#include "../logunit.h"
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
using namespace log4cxx;
using namespace log4cxx::filter;
using namespace log4cxx::helpers;
using namespace log4cxx::rolling;
/**
*
*/
LOGUNIT_CLASS(RollingFileAppenderPropertiesTest)
{
LOGUNIT_TEST_SUITE(RollingFileAppenderPropertiesTest);
LOGUNIT_TEST(testIsOptionHandler);
LOGUNIT_TEST(test1);
LOGUNIT_TEST(test2);
LOGUNIT_TEST(test3);
LOGUNIT_TEST(test4);
LOGUNIT_TEST(testRollingFromProperties);
LOGUNIT_TEST_SUITE_END();
public:
void setUp()
{
}
void tearDown()
{
LogManager::shutdown();
}
/**
* Test basic rolling functionality.
*/
void test1()
{
PropertyConfigurator::configure(File("input/rolling/obsoleteRFA1.properties"));
// Make sure that the configured values are what we expect
auto appender = LogManager::getRootLogger()->getAppender(LOG4CXX_STR("testAppender"));
LOGUNIT_ASSERT(appender);
auto rfa = cast(appender);
LOGUNIT_ASSERT(rfa);
LOGUNIT_ASSERT_EQUAL(3, rfa->getMaxBackupIndex());
LOGUNIT_ASSERT_EQUAL(100, static_cast(rfa->getMaximumFileSize()));
logchar msg[] = { 'H', 'e', 'l', 'l', 'o', '-', '-', '-', '?', 0};
auto logger = Logger::getLogger("RollingFileAppenderTest");
// Write exactly 10 bytes with each log
for (int i = 0; i < 25; i++)
{
apr_sleep(100000);
if (i < 10)
{
msg[8] = (logchar) ('0' + i);
LOG4CXX_DEBUG(logger, msg);
}
else if (i < 100)
{
msg[7] = (logchar) ('0' + i / 10);
msg[8] = (logchar) ('0' + i % 10);
LOG4CXX_DEBUG(logger, msg);
}
}
Pool p;
LOGUNIT_ASSERT_EQUAL(true, File("output/obsoleteRFA-test1.log").exists(p));
LOGUNIT_ASSERT_EQUAL(true, File("output/obsoleteRFA-test1.log.1").exists(p));
}
/**
* Test basic rolling functionality.
*/
void test2()
{
auto layout = std::make_shared (LOG4CXX_STR("%m\n"));
auto rfa = std::make_shared();
rfa->setName(LOG4CXX_STR("ROLLING"));
rfa->setLayout(layout);
rfa->setOption(LOG4CXX_STR("append"), LOG4CXX_STR("false"));
rfa->setMaximumFileSize(100);
rfa->setFile(LOG4CXX_STR("output/obsoleteRFA-test2.log"));
Pool p;
rfa->activateOptions(p);
auto root = Logger::getRootLogger();
root->addAppender(rfa);
logchar msg[] = { 'H', 'e', 'l', 'l', 'o', '-', '-', '-', '?', 0};
auto logger = Logger::getLogger("org.apache.logj4.ObsoleteRollingFileAppenderTest");
// Write exactly 10 bytes with each log
for (int i = 0; i < 25; i++)
{
apr_sleep(100000);
if (i < 10)
{
msg[8] = (logchar) ('0' + i);
LOG4CXX_DEBUG(logger, msg);
}
else if (i < 100)
{
msg[7] = (logchar) ('0' + i / 10);
msg[8] = (logchar) ('0' + i % 10);
LOG4CXX_DEBUG(logger, msg);
}
}
LOGUNIT_ASSERT_EQUAL(true, File("output/obsoleteRFA-test2.log").exists(p));
LOGUNIT_ASSERT_EQUAL(true, File("output/obsoleteRFA-test2.log.1").exists(p));
}
/**
* Test propertyfile configured time based rolling functionality.
*/
void test3()
{
PropertyConfigurator::configure(File("input/rolling/obsoleteDRFA1.properties"));
int preCount = getFileCount("output", LOG4CXX_STR("obsoleteDRFA-test1.log."));
LoggerPtr logger(Logger::getLogger("DailyRollingFileAppenderTest"));
char msg[11];
strncpy(msg, "Hello---??", sizeof(msg));
for (int i = 0; i < 25; i++)
{
apr_sleep(100000);
msg[8] = (char) ('0' + (i / 10));
msg[9] = (char) ('0' + (i % 10));
LOG4CXX_DEBUG(logger, msg);
}
int postCount = getFileCount("output", LOG4CXX_STR("obsoleteDRFA-test1.log."));
LOGUNIT_ASSERT_EQUAL(true, postCount > preCount);
}
/**
* Test programatically configured time based rolling functionality.
*/
void test4()
{
PatternLayoutPtr layout(new PatternLayout(LOG4CXX_STR("%m%n")));
auto rfa = std::make_shared();
rfa->setName(LOG4CXX_STR("ROLLING"));
rfa->setLayout(layout);
rfa->setAppend(false);
rfa->setFile(LOG4CXX_STR("output/obsoleteDRFA-test2.log"));
rfa->setDatePattern(LOG4CXX_STR("'.'yyyy-MM-dd-HH_mm_ss"));
Pool p;
rfa->activateOptions(p);
LoggerPtr root(Logger::getRootLogger());
root->addAppender(rfa);
LoggerPtr logger(Logger::getLogger("ObsoleteDailyRollingAppenderTest"));
int preCount = getFileCount("output", LOG4CXX_STR("obsoleteDRFA-test2.log."));
char msg[11];
strncpy(msg, "Hello---??", sizeof(msg));
for (int i = 0; i < 25; i++)
{
apr_sleep(100000);
msg[8] = (char) ('0' + i / 10);
msg[9] = (char) ('0' + i % 10);
LOG4CXX_DEBUG(logger, msg);
}
int postCount = getFileCount("output", LOG4CXX_STR("obsoleteDRFA-test2.log."));
LOGUNIT_ASSERT_EQUAL(true, postCount > preCount);
}
/**
* Tests if class is declared to support the OptionHandler interface.
* See LOGCXX-136.
*/
void testIsOptionHandler()
{
auto rfa = std::make_shared();
LOGUNIT_ASSERT_EQUAL(true, rfa->instanceof(log4cxx::spi::OptionHandler::getStaticClass()));
}
void testRollingFromProperties(){
// Load the properties from the file and make sure that the configured values are
// what we expect
PropertyConfigurator::configure(LOG4CXX_FILE("input/rolling/rollingFileAppenderFromProperties.properties"));
auto appender = LogManager::getRootLogger()->getAppender(LOG4CXX_STR("FILE"));
LOGUNIT_ASSERT(appender);
auto rfa = cast(appender);
LOGUNIT_ASSERT(rfa);
FixedWindowRollingPolicyPtr fixedWindowRolling = cast