diff --git a/.astylerc b/.astylerc
index 5459711..eee1b59 100644
--- a/.astylerc
+++ b/.astylerc
@@ -10,6 +10,7 @@
 # Example invocation:
 #
 # astyle --project src/main/include/*.h src/main/cpp/*.cpp
+# astyle --project src/test/cpp/*.h src/test/cpp/*.cpp
 #
 
 --add-braces
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 2809445..51a9c5a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -61,3 +61,44 @@
   NAMESPACE log4cxx::
   DESTINATION share/cmake/log4cxx
 )
+
+#
+# Get the varaibles from the subdirectories
+#
+get_directory_property( HAS_LIBESMTP DIRECTORY src/main/include DEFINITION HAS_LIBESMTP )
+get_directory_property( HAS_ODBC DIRECTORY src/main/include DEFINITION HAS_ODBC )
+get_directory_property( HAS_SYSLOG DIRECTORY src/main/include DEFINITION HAS_SYSLOG )
+
+foreach(varName HAS_STD_LOCALE  HAS_ODBC  HAS_MBSRTOWCS  HAS_WCSTOMBS  HAS_FWIDE  HAS_LIBESMTP  HAS_SYSLOG)
+  if(${varName} EQUAL 0)
+    set(${varName} "OFF" )
+  elseif(${varName} EQUAL 1)
+    set(${varName} "ON" )
+  else()
+    set(${varName} "UNKNOWN" )
+  endif()
+endforeach()
+
+#
+# Output configuration information
+# Similar to APR CMake configuration
+#
+message(STATUS "")
+message(STATUS "")
+message(STATUS "log4cxx configuration summary:")
+message(STATUS "")
+
+message(STATUS "  Build type ...................... : ${CMAKE_BUILD_TYPE}")
+message(STATUS "  Build tests ..................... : ${BUILD_TESTING}")
+message(STATUS "  Install prefix .................. : ${CMAKE_INSTALL_PREFIX}")
+message(STATUS "  C++ compiler .................... : ${CMAKE_CXX_COMPILER}")
+message(STATUS "  log4cxx char API ................ : ${LOG4CXX_CHAR}")
+message(STATUS "  log4cxx wchar API ............... : ${LOG4CXX_WCHAR_T}")
+message(STATUS "  log4cxx unichar API ............. : ${LOG4CXX_UNICHAR}")
+if(APPLE)
+message(STATUS "  log4cxx cfstring API ............ : ${LOG4CXX_CFSTRING}")
+endif()
+message(STATUS "  logchar type .................... : ${LOG4CXX_CHAR}")
+message(STATUS "  Using libESMTP .................. : ${HAS_LIBESMTP}")
+message(STATUS "  ODBC library .................... : ${HAS_ODBC}")
+message(STATUS "  syslog .......................... : ${HAS_SYSLOG}")
diff --git a/pom.xml b/pom.xml
index 1e38b92..0413e80 100644
--- a/pom.xml
+++ b/pom.xml
@@ -74,7 +74,7 @@
 		<releaseVersion>${project.version}</releaseVersion>
 		<releaseManager>Matt Sicker</releaseManager>
 		<releaseKey>B62BABE8</releaseKey>
-        <windowsArchitecture>x64</windowsArchitecture>
+		<windowsArchitecture>x64</windowsArchitecture>
 	</properties>
 
 	<organization>
@@ -180,56 +180,62 @@
 
 	<build>
 		<plugins>
-            <plugin>
-              <groupId>com.googlecode.cmake-maven-project</groupId>
-              <artifactId>cmake-maven-plugin</artifactId>
-              <version>3.16.3-b1</version>
-              <executions>
-                <execution>
-                  <id>cmake-generate</id>
-                  <goals>
-                    <goal>generate</goal>
-                  </goals>
-                  <configuration>
-                    <sourcePath>${project.basedir}</sourcePath>
-                    <targetPath>${project.build.directory}/${platform}</targetPath>
-                    <classifier>${cmake.classifier}</classifier>
-                    <options>${cmake.options}</options>
-                    <environmentVariables>
-                        <CMAKE_CLASSIFIER>${cmake.classifier}</CMAKE_CLASSIFIER>
-                    </environmentVariables>
-                    <downloadBinaries>${download.cmake}</downloadBinaries>
-                  </configuration>
-                </execution>
-                <execution>
-                    <id>cmake-compile</id>
-                    <phase>process-resources</phase>
-                    <goals>
-                      <goal>compile</goal>
-                    </goals>
-                    <configuration>
-                        <projectDirectory>${project.build.directory}/${platform}</projectDirectory>
-                        <classifier>${cmake.classifier}</classifier>
-                        <config>${cmake.config}</config>
-                        <downloadBinaries>true</downloadBinaries>
-                    </configuration>
-                </execution>
-                <execution>
-                  <phase>test</phase>
-                  <id>cmake-run-tests</id>
-                  <goals>
-                    <goal>test</goal>
-                  </goals>
-                  <configuration>
-                    <buildDirectory>${project.build.directory}/${platform}</buildDirectory>
-                    <testFailureIgnore>true</testFailureIgnore>
-                    <ctest.skip.tests>${maven.test.skip}</ctest.skip.tests>
-                    <config>${cmake.config}</config>
-                    <threadCount>1</threadCount>
-                  </configuration>
-                </execution>
-              </executions>
-            </plugin>
+			<plugin>
+				<groupId>com.googlecode.cmake-maven-project</groupId>
+				<artifactId>cmake-maven-plugin</artifactId>
+				<version>3.16.3-b1</version>
+
+				<executions>
+					<execution>
+						<id>cmake-generate</id>
+						<goals>
+							<goal>generate</goal>
+						</goals>
+
+						<configuration>
+							<sourcePath>${project.basedir}</sourcePath>
+							<targetPath>${project.build.directory}/${platform}</targetPath>
+							<classifier>${cmake.classifier}</classifier>
+							<options>${cmake.options}</options>
+							<environmentVariables>
+								<CMAKE_CLASSIFIER>${cmake.classifier}</CMAKE_CLASSIFIER>
+							</environmentVariables>
+							<downloadBinaries>${download.cmake}</downloadBinaries>
+						</configuration>
+					</execution>
+
+					<execution>
+						<id>cmake-compile</id>
+						<phase>process-resources</phase>
+						<goals>
+							<goal>compile</goal>
+						</goals>
+
+						<configuration>
+							<projectDirectory>${project.build.directory}/${platform}</projectDirectory>
+							<classifier>${cmake.classifier}</classifier>
+							<config>${cmake.config}</config>
+							<downloadBinaries>true</downloadBinaries>
+						</configuration>
+					</execution>
+
+					<execution>
+						<phase>test</phase>
+						<id>cmake-run-tests</id>
+						<goals>
+							<goal>test</goal>
+						</goals>
+
+						<configuration>
+							<buildDirectory>${project.build.directory}/${platform}</buildDirectory>
+							<testFailureIgnore>true</testFailureIgnore>
+							<ctest.skip.tests>${maven.test.skip}</ctest.skip.tests>
+							<config>${cmake.config}</config>
+							<threadCount>1</threadCount>
+						</configuration>
+					</execution>
+				</executions>
+			</plugin>
 			<plugin>
 				<artifactId>maven-antrun-plugin</artifactId>
 				<version>1.7</version>
@@ -480,5 +486,5 @@
 				<cmake.config>${build.type}</cmake.config>
 			</properties>
 		</profile>
-    </profiles>
+	</profiles>
 </project>
diff --git a/src/changes/changes.xml b/src/changes/changes.xml
index 52605a3..824b08e 100644
--- a/src/changes/changes.xml
+++ b/src/changes/changes.xml
@@ -30,8 +30,8 @@
 			<action issue="LOGCXX-503" type="update">Checksums/Signatures don't match for log4cxx binaries</action>
 			<action issue="LOGCXX-502" type="update">appenderattachable.h function doc formatted "incorrectly"</action>
 			<action issue="LOGCXX-500" type="update">Logging in Timing-Critical Applications</action>
-			<action issue="LOGCXX-493" type="fix">Wrong usage of milli- vs. micro- and non- vs. milliseconds in some docs.</action>
 			<action issue="LOGCXX-494" type="fix">Provide a windows build environment for the project by replacing the ant build with a CMake build</action>
+			<action issue="LOGCXX-493" type="fix">Wrong usage of milli- vs. micro- and non- vs. milliseconds in some docs.</action>
 			<action issue="LOGCXX-488" type="fix">Space after log level hides messages</action>
 			<action issue="LOGCXX-484" type="fix">Spelling error s/excute/execute</action>
 			<action issue="LOGCXX-482" type="fix">Build failure with GCC-6</action>
diff --git a/src/site/apt/building/cmake.apt b/src/site/apt/building/cmake.apt
index 3585ea8..250324b 100644
--- a/src/site/apt/building/cmake.apt
+++ b/src/site/apt/building/cmake.apt
@@ -46,6 +46,8 @@
 *------------------------+---------------------------------------------------------------------------------------------+
 | -DLOG4CXX_CFSTRING=yes | Enable CFString API methods, requires Mac OS/X CoreFoundation, choice of yes, no (default). |
 *------------------------+---------------------------------------------------------------------------------------------+
+| -DBUILD_TESTING=off    | Disable tests.  Tests are enabled by default                                                |
+*------------------------+---------------------------------------------------------------------------------------------+
 
    Building and testing log4cxx on a Microsoft Windows with APR, Expat and APR-Util built from source
    extracted into apr-1.7.0, libexpat(from github) and apr-util-1.6.1 in %HOMEPATH%\Libraries.
diff --git a/src/test/cpp/abts.cpp b/src/test/cpp/abts.cpp
index 489e5dc..5524c9b 100644
--- a/src/test/cpp/abts.cpp
+++ b/src/test/cpp/abts.cpp
@@ -30,422 +30,584 @@
 static int quiet = 0;
 static int list_tests = 0;
 
-const char **testlist = NULL;
+const char** testlist = NULL;
 //  defined in logunit.cpp
 abts_suite* abts_run_suites(abts_suite*);
 
-static int find_test_name(const char *testname) {
-    int i;
-    for (i = 0; testlist[i] != NULL; i++) {
-        if (!strcmp(testlist[i], testname)) {
-            return 1;
-        }
-    }
-    return 0;
+static int find_test_name(const char* testname)
+{
+	int i;
+
+	for (i = 0; testlist[i] != NULL; i++)
+	{
+		if (!strcmp(testlist[i], testname))
+		{
+			return 1;
+		}
+	}
+
+	return 0;
 }
 
 /* Determine if the test should be run at all */
-static int should_test_run(const char *testname) {
-    int found = 0;
-    if (list_tests == 1) {
-        return 0;
-    }
-    if (testlist == NULL) {
-        return 1;
-    }
-    found = find_test_name(testname);
-    if ((found && !exclude) || (!found && exclude)) {
-        return 1;
-    }
-    return 0;
+static int should_test_run(const char* testname)
+{
+	int found = 0;
+
+	if (list_tests == 1)
+	{
+		return 0;
+	}
+
+	if (testlist == NULL)
+	{
+		return 1;
+	}
+
+	found = find_test_name(testname);
+
+	if ((found && !exclude) || (!found && exclude))
+	{
+		return 1;
+	}
+
+	return 0;
 }
 
 static void reset_status(void)
 {
-    curr_char = 0;
+	curr_char = 0;
 }
 
 static void update_status(void)
 {
-    if (!quiet) {
-        curr_char = (curr_char + 1) % ABTS_STAT_SIZE;
-        fprintf(stdout, "\b%c", status[curr_char]);
-        fflush(stdout);
-    }
+	if (!quiet)
+	{
+		curr_char = (curr_char + 1) % ABTS_STAT_SIZE;
+		fprintf(stdout, "\b%c", status[curr_char]);
+		fflush(stdout);
+	}
 }
 
-static void end_suite(abts_suite *suite)
+static void end_suite(abts_suite* suite)
 {
-    if (suite != NULL) {
-        sub_suite *last = suite->tail;
-        if (!quiet) {
-            fprintf(stdout, "\b");
-            fflush(stdout);
-        }
-        if (last->failed == 0) {
-            fprintf(stdout, "SUCCESS\n");
-            fflush(stdout);
-        }
-        else {
-            fprintf(stdout, "FAILED %d of %d\n", last->failed, last->num_test);
-            fflush(stdout);
-        }
-    }
+	if (suite != NULL)
+	{
+		sub_suite* last = suite->tail;
+
+		if (!quiet)
+		{
+			fprintf(stdout, "\b");
+			fflush(stdout);
+		}
+
+		if (last->failed == 0)
+		{
+			fprintf(stdout, "SUCCESS\n");
+			fflush(stdout);
+		}
+		else
+		{
+			fprintf(stdout, "FAILED %d of %d\n", last->failed, last->num_test);
+			fflush(stdout);
+		}
+	}
 }
 
-abts_suite *abts_add_suite(abts_suite *suite, const char *suite_name_full)
+abts_suite* abts_add_suite(abts_suite* suite, const char* suite_name_full)
 {
-    sub_suite *subsuite;
-    const char *p;
-    const char *suite_name;
-    curr_char = 0;
-    
-    /* Only end the suite if we actually ran it */
-    if (suite && suite->tail &&!suite->tail->not_run) {
-        end_suite(suite);
-    }
+	sub_suite* subsuite;
+	const char* p;
+	const char* suite_name;
+	curr_char = 0;
 
-    subsuite = (sub_suite*) malloc(sizeof(*subsuite));
-    subsuite->num_test = 0;
-    subsuite->failed = 0;
-    subsuite->next = NULL;
-    /* suite_name_full may be an absolute path depending on __FILE__ 
-     * expansion */
-    suite_name = strrchr(suite_name_full, '/');
-    if (suite_name) {
-        suite_name++;
-    } else {
-        suite_name = suite_name_full;
-    }
-    p = strrchr(suite_name, '.');
-    if (p) {
-        subsuite->name = (const char*) memcpy(calloc(p - suite_name + 1, 1),
-                                suite_name, p - suite_name);
-    }
-    else {
-        subsuite->name = suite_name;
-    }
+	/* Only end the suite if we actually ran it */
+	if (suite && suite->tail && !suite->tail->not_run)
+	{
+		end_suite(suite);
+	}
 
-    if (list_tests) {
-        fprintf(stdout, "%s\n", subsuite->name);
-    }
-    
-    subsuite->not_run = 0;
+	subsuite = (sub_suite*) malloc(sizeof(*subsuite));
+	subsuite->num_test = 0;
+	subsuite->failed = 0;
+	subsuite->next = NULL;
+	/* suite_name_full may be an absolute path depending on __FILE__
+	 * expansion */
+	suite_name = strrchr(suite_name_full, '/');
 
-    if (suite == NULL) {
-        suite = (abts_suite*) malloc(sizeof(*suite));
-        suite->head = subsuite;
-        suite->tail = subsuite;
-    }
-    else {
-        suite->tail->next = subsuite;
-        suite->tail = subsuite;
-    }
+	if (suite_name)
+	{
+		suite_name++;
+	}
+	else
+	{
+		suite_name = suite_name_full;
+	}
 
-    if (!should_test_run(subsuite->name)) {
-        subsuite->not_run = 1;
-        return suite;
-    }
+	p = strrchr(suite_name, '.');
 
-    reset_status();
-    fprintf(stdout, "%-20s:  ", subsuite->name);
-    update_status();
-    fflush(stdout);
+	if (p)
+	{
+		subsuite->name = (const char*) memcpy(calloc(p - suite_name + 1, 1),
+				suite_name, p - suite_name);
+	}
+	else
+	{
+		subsuite->name = suite_name;
+	}
 
-    return suite;
+	if (list_tests)
+	{
+		fprintf(stdout, "%s\n", subsuite->name);
+	}
+
+	subsuite->not_run = 0;
+
+	if (suite == NULL)
+	{
+		suite = (abts_suite*) malloc(sizeof(*suite));
+		suite->head = subsuite;
+		suite->tail = subsuite;
+	}
+	else
+	{
+		suite->tail->next = subsuite;
+		suite->tail = subsuite;
+	}
+
+	if (!should_test_run(subsuite->name))
+	{
+		subsuite->not_run = 1;
+		return suite;
+	}
+
+	reset_status();
+	fprintf(stdout, "%-20s:  ", subsuite->name);
+	update_status();
+	fflush(stdout);
+
+	return suite;
 }
 
-void abts_run_test(abts_suite *ts, test_func f, void *value)
+void abts_run_test(abts_suite* ts, test_func f, void* value)
 {
-    abts_case tc;
-    sub_suite *ss;
+	abts_case tc;
+	sub_suite* ss;
 
-    if (!should_test_run(ts->tail->name)) {
-        return;
-    }
-    ss = ts->tail;
+	if (!should_test_run(ts->tail->name))
+	{
+		return;
+	}
 
-    tc.failed = 0;
-    tc.suite = ss;
-    
-    ss->num_test++;
-    update_status();
+	ss = ts->tail;
 
-    f(&tc, value);
-    
-    if (tc.failed) {
-        ss->failed++;
-    }
+	tc.failed = 0;
+	tc.suite = ss;
+
+	ss->num_test++;
+	update_status();
+
+	f(&tc, value);
+
+	if (tc.failed)
+	{
+		ss->failed++;
+	}
 }
 
-static int report(abts_suite *suite)
+static int report(abts_suite* suite)
 {
-    int count = 0;
-    sub_suite *dptr;
+	int count = 0;
+	sub_suite* dptr;
 
-    if (suite && suite->tail &&!suite->tail->not_run) {
-        end_suite(suite);
-    }
+	if (suite && suite->tail && !suite->tail->not_run)
+	{
+		end_suite(suite);
+	}
 
-    for (dptr = suite->head; dptr; dptr = dptr->next) {
-        count += dptr->failed;
-    }
+	for (dptr = suite->head; dptr; dptr = dptr->next)
+	{
+		count += dptr->failed;
+	}
 
-    if (list_tests) {
-        return 0;
-    }
+	if (list_tests)
+	{
+		return 0;
+	}
 
-    if (count == 0) {
-        printf("All tests passed.\n");
-        return 0;
-    }
+	if (count == 0)
+	{
+		printf("All tests passed.\n");
+		return 0;
+	}
 
-    dptr = suite->head;
-    fprintf(stdout, "%-15s\t\tTotal\tFail\tFailed %%\n", "Failed Tests");
-    fprintf(stdout, "===================================================\n");
-    while (dptr != NULL) {
-        if (dptr->failed != 0) {
-            float percent = ((float)dptr->failed / (float)dptr->num_test);
-            fprintf(stdout, "%-15s\t\t%5d\t%4d\t%6.2f%%\n", dptr->name, 
-                    dptr->num_test, dptr->failed, percent * 100);
-        }
-        dptr = dptr->next;
-    }
-    return 1;
+	dptr = suite->head;
+	fprintf(stdout, "%-15s\t\tTotal\tFail\tFailed %%\n", "Failed Tests");
+	fprintf(stdout, "===================================================\n");
+
+	while (dptr != NULL)
+	{
+		if (dptr->failed != 0)
+		{
+			float percent = ((float)dptr->failed / (float)dptr->num_test);
+			fprintf(stdout, "%-15s\t\t%5d\t%4d\t%6.2f%%\n", dptr->name,
+				dptr->num_test, dptr->failed, percent * 100);
+		}
+
+		dptr = dptr->next;
+	}
+
+	return 1;
 }
 
-void abts_log_message(const char *fmt, ...)
+void abts_log_message(const char* fmt, ...)
 {
-    va_list args;
-    update_status();
+	va_list args;
+	update_status();
 
-    if (verbose) {
-        va_start(args, fmt);
-        vfprintf(stderr, fmt, args);
-        va_end(args);
-        fprintf(stderr, "\n");
-        fflush(stderr);
-    }
+	if (verbose)
+	{
+		va_start(args, fmt);
+		vfprintf(stderr, fmt, args);
+		va_end(args);
+		fprintf(stderr, "\n");
+		fflush(stderr);
+	}
 }
 
-void abts_int_equal(abts_case *tc, const int expected, const int actual, int lineno)
+void abts_int_equal(abts_case* tc, const int expected, const int actual, int lineno)
 {
-    update_status();
-    if (tc->failed) return;
+	update_status();
 
-    if (expected == actual) return;
+	if (tc->failed)
+	{
+		return;
+	}
 
-    tc->failed = TRUE;
-    if (verbose) {
-        fprintf(stderr, "Line %d: expected <%d>, but saw <%d>\n", lineno, expected, actual);
-        fflush(stderr);
-    }
+	if (expected == actual)
+	{
+		return;
+	}
+
+	tc->failed = TRUE;
+
+	if (verbose)
+	{
+		fprintf(stderr, "Line %d: expected <%d>, but saw <%d>\n", lineno, expected, actual);
+		fflush(stderr);
+	}
 }
 
-void abts_int_nequal(abts_case *tc, const int expected, const int actual, int lineno)
+void abts_int_nequal(abts_case* tc, const int expected, const int actual, int lineno)
 {
-    update_status();
-    if (tc->failed) return;
+	update_status();
 
-    if (expected != actual) return;
+	if (tc->failed)
+	{
+		return;
+	}
 
-    tc->failed = TRUE;
-    if (verbose) {
-        fprintf(stderr, "Line %d: expected <%d>, but saw <%d>\n", lineno, expected, actual);
-        fflush(stderr);
-    }
+	if (expected != actual)
+	{
+		return;
+	}
+
+	tc->failed = TRUE;
+
+	if (verbose)
+	{
+		fprintf(stderr, "Line %d: expected <%d>, but saw <%d>\n", lineno, expected, actual);
+		fflush(stderr);
+	}
 }
 
-void abts_size_equal(abts_case *tc, size_t expected, size_t actual, int lineno)
+void abts_size_equal(abts_case* tc, size_t expected, size_t actual, int lineno)
 {
-    update_status();
-    if (tc->failed) return;
+	update_status();
 
-    if (expected == actual) return;
+	if (tc->failed)
+	{
+		return;
+	}
 
-    tc->failed = TRUE;
-    if (verbose) {
-        /* Note that the comparison is type-exact, reporting must be a best-fit */
-        fprintf(stderr, "Line %d: expected %lu, but saw %lu\n", lineno, 
-                (unsigned long)expected, (unsigned long)actual);
-        fflush(stderr);
-    }
+	if (expected == actual)
+	{
+		return;
+	}
+
+	tc->failed = TRUE;
+
+	if (verbose)
+	{
+		/* Note that the comparison is type-exact, reporting must be a best-fit */
+		fprintf(stderr, "Line %d: expected %lu, but saw %lu\n", lineno,
+			(unsigned long)expected, (unsigned long)actual);
+		fflush(stderr);
+	}
 }
 
-void abts_str_equal(abts_case *tc, const char *expected, const char *actual, int lineno)
+void abts_str_equal(abts_case* tc, const char* expected, const char* actual, int lineno)
 {
-    update_status();
-    if (tc->failed) return;
+	update_status();
 
-    if (!expected && !actual) return;
-    if (expected && actual)
-        if (!strcmp(expected, actual)) return;
+	if (tc->failed)
+	{
+		return;
+	}
 
-    tc->failed = TRUE;
-    if (verbose) {
-        fprintf(stderr, "Line %d: expected <%s>, but saw <%s>\n", lineno, expected, actual);
-        fflush(stderr);
-    }
+	if (!expected && !actual)
+	{
+		return;
+	}
+
+	if (expected && actual)
+		if (!strcmp(expected, actual))
+		{
+			return;
+		}
+
+	tc->failed = TRUE;
+
+	if (verbose)
+	{
+		fprintf(stderr, "Line %d: expected <%s>, but saw <%s>\n", lineno, expected, actual);
+		fflush(stderr);
+	}
 }
 
-void abts_str_nequal(abts_case *tc, const char *expected, const char *actual,
-                       size_t n, int lineno)
+void abts_str_nequal(abts_case* tc, const char* expected, const char* actual,
+	size_t n, int lineno)
 {
-    update_status();
-    if (tc->failed) return;
+	update_status();
 
-    if (!strncmp(expected, actual, n)) return;
+	if (tc->failed)
+	{
+		return;
+	}
 
-    tc->failed = TRUE;
-    if (verbose) {
-        fprintf(stderr, "Line %d: expected <%s>, but saw <%s>\n", lineno, expected, actual);
-        fflush(stderr);
-    }
+	if (!strncmp(expected, actual, n))
+	{
+		return;
+	}
+
+	tc->failed = TRUE;
+
+	if (verbose)
+	{
+		fprintf(stderr, "Line %d: expected <%s>, but saw <%s>\n", lineno, expected, actual);
+		fflush(stderr);
+	}
 }
 
-void abts_ptr_notnull(abts_case *tc, const void *ptr, int lineno)
+void abts_ptr_notnull(abts_case* tc, const void* ptr, int lineno)
 {
-    update_status();
-    if (tc->failed) return;
+	update_status();
 
-    if (ptr != NULL) return;
+	if (tc->failed)
+	{
+		return;
+	}
 
-    tc->failed = TRUE;
-    if (verbose) {
-        fprintf(stderr, "Line %d: Expected NULL, but saw <%p>\n", lineno, ptr);
-        fflush(stderr);
-    }
+	if (ptr != NULL)
+	{
+		return;
+	}
+
+	tc->failed = TRUE;
+
+	if (verbose)
+	{
+		fprintf(stderr, "Line %d: Expected NULL, but saw <%p>\n", lineno, ptr);
+		fflush(stderr);
+	}
 }
- 
-void abts_ptr_equal(abts_case *tc, const void *expected, const void *actual, int lineno)
+
+void abts_ptr_equal(abts_case* tc, const void* expected, const void* actual, int lineno)
 {
-    update_status();
-    if (tc->failed) return;
+	update_status();
 
-    if (expected == actual) return;
+	if (tc->failed)
+	{
+		return;
+	}
 
-    tc->failed = TRUE;
-    if (verbose) {
-        fprintf(stderr, "Line %d: expected <%p>, but saw <%p>\n", lineno, expected, actual);
-        fflush(stderr);
-    }
+	if (expected == actual)
+	{
+		return;
+	}
+
+	tc->failed = TRUE;
+
+	if (verbose)
+	{
+		fprintf(stderr, "Line %d: expected <%p>, but saw <%p>\n", lineno, expected, actual);
+		fflush(stderr);
+	}
 }
 
-void abts_fail(abts_case *tc, const char *message, int lineno)
+void abts_fail(abts_case* tc, const char* message, int lineno)
 {
-    update_status();
-    if (tc->failed) return;
+	update_status();
 
-    tc->failed = TRUE;
-    if (verbose) {
-        fprintf(stderr, "Line %d: %s\n", lineno, message);
-        fflush(stderr);
-    }
+	if (tc->failed)
+	{
+		return;
+	}
+
+	tc->failed = TRUE;
+
+	if (verbose)
+	{
+		fprintf(stderr, "Line %d: %s\n", lineno, message);
+		fflush(stderr);
+	}
 }
- 
-void abts_assert(abts_case *tc, const char *message, int condition, int lineno)
+
+void abts_assert(abts_case* tc, const char* message, int condition, int lineno)
 {
-    update_status();
-    if (tc->failed) return;
+	update_status();
 
-    if (condition) return;
+	if (tc->failed)
+	{
+		return;
+	}
 
-    tc->failed = TRUE;
-    if (verbose) {
-        fprintf(stderr, "Line %d: %s\n", lineno, message);
-        fflush(stderr);
-    }
+	if (condition)
+	{
+		return;
+	}
+
+	tc->failed = TRUE;
+
+	if (verbose)
+	{
+		fprintf(stderr, "Line %d: %s\n", lineno, message);
+		fflush(stderr);
+	}
 }
 
-void abts_true(abts_case *tc, int condition, int lineno)
+void abts_true(abts_case* tc, int condition, int lineno)
 {
-    update_status();
-    if (tc->failed) return;
+	update_status();
 
-    if (condition) return;
+	if (tc->failed)
+	{
+		return;
+	}
 
-    tc->failed = TRUE;
-    if (verbose) {
-        fprintf(stderr, "Line %d: Condition is false, but expected true\n", lineno);
-        fflush(stderr);
-    }
+	if (condition)
+	{
+		return;
+	}
+
+	tc->failed = TRUE;
+
+	if (verbose)
+	{
+		fprintf(stderr, "Line %d: Condition is false, but expected true\n", lineno);
+		fflush(stderr);
+	}
 }
 
-void abts_not_impl(abts_case *tc, const char *message, int lineno)
+void abts_not_impl(abts_case* tc, const char* message, int lineno)
 {
-    update_status();
+	update_status();
 
-    tc->suite->not_impl++;
-    if (verbose) {
-        fprintf(stderr, "Line %d: %s\n", lineno, message);
-        fflush(stderr);
-    }
+	tc->suite->not_impl++;
+
+	if (verbose)
+	{
+		fprintf(stderr, "Line %d: %s\n", lineno, message);
+		fflush(stderr);
+	}
 }
 
-int main(int argc, const char *const argv[]) {
-    int i;
-    int rv;
-    int list_provided = 0;
-    abts_suite *suite = NULL;
-   
-    initialize();
+int main(int argc, const char* const argv[])
+{
+	int i;
+	int rv;
+	int list_provided = 0;
+	abts_suite* suite = NULL;
+
+	initialize();
 
 #if defined(_MSC_VER)
-   quiet = 1;
+	quiet = 1;
 #else
-    quiet = !isatty(STDOUT_FILENO);
+	quiet = !isatty(STDOUT_FILENO);
 #endif
 
-    for (i = 1; i < argc; i++) {
-        if (!strcmp(argv[i], "-v")) {
-            verbose = 1;
-            continue;
-        }
-        if (!strcmp(argv[i], "-x")) {
-            exclude = 1;
-            continue;
-        }
-        if (!strcmp(argv[i], "-l")) {
-            list_tests = 1;
-            continue;
-        }
-        if (!strcmp(argv[i], "-q")) {
-            quiet = 1;
-            continue;
-        }
-        if (argv[i][0] == '-') {
-            fprintf(stderr, "Invalid option: `%s'\n", argv[i]);
-            exit(1);
-        }
-        list_provided = 1;
-    }
+	for (i = 1; i < argc; i++)
+	{
+		if (!strcmp(argv[i], "-v"))
+		{
+			verbose = 1;
+			continue;
+		}
 
-    if (list_provided) {
-        /* Waste a little space here, because it is easier than counting the
-         * number of tests listed.  Besides it is at most three char *.
-         */
-        testlist = (const char**) calloc(argc + 1, sizeof(char *));
-        for (i = 1; i < argc; i++) {
-            testlist[i - 1] = argv[i];
-        }
-    }
+		if (!strcmp(argv[i], "-x"))
+		{
+			exclude = 1;
+			continue;
+		}
 
-    suite = abts_run_suites(suite);
+		if (!strcmp(argv[i], "-l"))
+		{
+			list_tests = 1;
+			continue;
+		}
 
-    if (suite == 0) {
-        fputs("No tests selected\n", stderr);
-    } else {
-        rv = report(suite);
-        //
-        //    clean up suite
-        //
-        sub_suite* next;
-        for(sub_suite* head = suite->head; head != NULL; head = next) {
-      next = head->next;
-           free((void*) head->name);
-      free(head);
-         }
-         free(suite);
-    }
-    return rv;
+		if (!strcmp(argv[i], "-q"))
+		{
+			quiet = 1;
+			continue;
+		}
+
+		if (argv[i][0] == '-')
+		{
+			fprintf(stderr, "Invalid option: `%s'\n", argv[i]);
+			exit(1);
+		}
+
+		list_provided = 1;
+	}
+
+	if (list_provided)
+	{
+		/* Waste a little space here, because it is easier than counting the
+		 * number of tests listed.  Besides it is at most three char *.
+		 */
+		testlist = (const char**) calloc(argc + 1, sizeof(char*));
+
+		for (i = 1; i < argc; i++)
+		{
+			testlist[i - 1] = argv[i];
+		}
+	}
+
+	suite = abts_run_suites(suite);
+
+	if (suite == 0)
+	{
+		fputs("No tests selected\n", stderr);
+	}
+	else
+	{
+		rv = report(suite);
+		//
+		//    clean up suite
+		//
+		sub_suite* next;
+
+		for (sub_suite* head = suite->head; head != NULL; head = next)
+		{
+			next = head->next;
+			free((void*) head->name);
+			free(head);
+		}
+
+		free(suite);
+	}
+
+	return rv;
 }
diff --git a/src/test/cpp/abts.h b/src/test/cpp/abts.h
index 340ab8a..616250b 100644
--- a/src/test/cpp/abts.h
+++ b/src/test/cpp/abts.h
@@ -21,63 +21,66 @@
 #include <apr.h>
 
 #ifdef WIN32
-#include <io.h>
+	#include <io.h>
 #else
-#include <unistd.h>
+	#include <unistd.h>
 #endif
 
 #ifndef ABTS_H
 #define ABTS_H
 
 #ifndef FALSE
-#define FALSE 0
+	#define FALSE 0
 #endif
 #ifndef TRUE
-#define TRUE  1
+	#define TRUE  1
 #endif
 
-struct sub_suite {
-    const char *name;
-    int num_test;
-    int failed;
-    int not_run;
-    int not_impl;
-    struct sub_suite *next;
+struct sub_suite
+{
+	const char* name;
+	int num_test;
+	int failed;
+	int not_run;
+	int not_impl;
+	struct sub_suite* next;
 };
 typedef struct sub_suite sub_suite;
 
-struct abts_suite {
-    sub_suite *head;
-    sub_suite *tail;
+struct abts_suite
+{
+	sub_suite* head;
+	sub_suite* tail;
 };
 typedef struct abts_suite abts_suite;
 
-struct abts_case {
-    int failed;
-    sub_suite *suite;
+struct abts_case
+{
+	int failed;
+	sub_suite* suite;
 };
 typedef struct abts_case abts_case;
 
-typedef void (*test_func)(abts_case *tc, void *data);
+typedef void (*test_func)(abts_case* tc, void* data);
 
 #define ADD_SUITE(suite) abts_add_suite(suite, __FILE__);
 
-abts_suite *abts_add_suite(abts_suite *suite, const char *suite_name);
-void abts_run_test(abts_suite *ts, test_func f, void *value);
-void abts_log_message(const char *fmt, ...);
+abts_suite* abts_add_suite(abts_suite* suite, const char* suite_name);
+void abts_run_test(abts_suite* ts, test_func f, void* value);
+void abts_log_message(const char* fmt, ...);
 
-void abts_int_equal(abts_case *tc, const int expected, const int actual, int lineno);
-void abts_int_nequal(abts_case *tc, const int expected, const int actual, int lineno);
-void abts_str_equal(abts_case *tc, const char *expected, const char *actual, int lineno);
-void abts_str_nequal(abts_case *tc, const char *expected, const char *actual,
-                       size_t n, int lineno);
-void abts_ptr_notnull(abts_case *tc, const void *ptr, int lineno);
-void abts_ptr_equal(abts_case *tc, const void *expected, const void *actual, int lineno);
-void abts_true(abts_case *tc, int condition, int lineno);
-void abts_fail(abts_case *tc, const char *message, int lineno);
-void abts_not_impl(abts_case *tc, const char *message, int lineno);
-void abts_assert(abts_case *tc, const char *message, int condition, int lineno);
-void abts_size_equal(abts_case *tc, size_t expected, size_t actual, int lineno);
+void abts_int_equal(abts_case* tc, const int expected, const int actual, int lineno);
+void abts_int_nequal(abts_case* tc, const int expected, const int actual, int lineno);
+void abts_str_equal(abts_case* tc, const char* expected, const char* actual, int lineno);
+void abts_str_nequal(abts_case* tc, const char* expected, const char* actual,
+	size_t n, int lineno);
+void abts_ptr_notnull(abts_case* tc, const void* ptr, int lineno);
+void abts_ptr_equal(abts_case* tc, const void* expected, const void* actual, int lineno);
+void abts_true(abts_case* tc, int condition, int lineno);
+void abts_fail(abts_case* tc, const char* message, int lineno);
+void abts_not_impl(abts_case* tc, const char* message, int lineno);
+void abts_assert(abts_case* tc, const char* message, int condition, int lineno);
+void abts_size_equal(abts_case* tc, size_t expected, size_t actual, int lineno);
 
 /* Convenience macros. Ryan hates these! */
 #define ABTS_INT_EQUAL(a, b, c)     abts_int_equal(a, b, c, __LINE__)
@@ -94,8 +97,8 @@
 #define ABTS_SIZE_EQUAL(a, b, c)    abts_size_equal(a, b, c, __LINE__)
 
 
-abts_suite *run_tests(abts_suite *suite);
-abts_suite *run_tests1(abts_suite *suite);
+abts_suite* run_tests(abts_suite* suite);
+abts_suite* run_tests1(abts_suite* suite);
 
 
 #endif
diff --git a/src/test/cpp/appenderskeletontestcase.cpp b/src/test/cpp/appenderskeletontestcase.cpp
index 6406c42..631d633 100644
--- a/src/test/cpp/appenderskeletontestcase.cpp
+++ b/src/test/cpp/appenderskeletontestcase.cpp
@@ -25,15 +25,17 @@
 using namespace log4cxx::helpers;
 
 
-void AppenderSkeletonTestCase::testDefaultThreshold() {
-   ObjectPtrT<AppenderSkeleton> appender(createAppenderSkeleton());
-   LevelPtr threshold(appender->getThreshold());
-   LOGUNIT_ASSERT_EQUAL(Level::getAll()->toInt(), threshold->toInt());
+void AppenderSkeletonTestCase::testDefaultThreshold()
+{
+	ObjectPtrT<AppenderSkeleton> appender(createAppenderSkeleton());
+	LevelPtr threshold(appender->getThreshold());
+	LOGUNIT_ASSERT_EQUAL(Level::getAll()->toInt(), threshold->toInt());
 }
 
-void AppenderSkeletonTestCase::testSetOptionThreshold() {
-    ObjectPtrT<AppenderSkeleton> appender(createAppenderSkeleton());
-    appender->setOption(LOG4CXX_STR("threshold"), LOG4CXX_STR("debug"));
-    LevelPtr threshold(appender->getThreshold());
-    LOGUNIT_ASSERT_EQUAL(Level::getDebug()->toInt(), threshold->toInt());
+void AppenderSkeletonTestCase::testSetOptionThreshold()
+{
+	ObjectPtrT<AppenderSkeleton> appender(createAppenderSkeleton());
+	appender->setOption(LOG4CXX_STR("threshold"), LOG4CXX_STR("debug"));
+	LevelPtr threshold(appender->getThreshold());
+	LOGUNIT_ASSERT_EQUAL(Level::getDebug()->toInt(), threshold->toInt());
 }
diff --git a/src/test/cpp/appenderskeletontestcase.h b/src/test/cpp/appenderskeletontestcase.h
index 23b8b46..40b01d2 100644
--- a/src/test/cpp/appenderskeletontestcase.h
+++ b/src/test/cpp/appenderskeletontestcase.h
@@ -26,9 +26,9 @@
 {
 
 public:
-        virtual log4cxx::AppenderSkeleton* createAppenderSkeleton() const = 0;
+	virtual log4cxx::AppenderSkeleton* createAppenderSkeleton() const = 0;
 
-        void testDefaultThreshold();
+	void testDefaultThreshold();
 
-        void testSetOptionThreshold();
+	void testSetOptionThreshold();
 };
diff --git a/src/test/cpp/asyncappendertestcase.cpp b/src/test/cpp/asyncappendertestcase.cpp
index 61853d4..d2b4b41 100644
--- a/src/test/cpp/asyncappendertestcase.cpp
+++ b/src/test/cpp/asyncappendertestcase.cpp
@@ -36,63 +36,74 @@
 using namespace log4cxx::helpers;
 using namespace log4cxx::spi;
 
-class NullPointerAppender : public AppenderSkeleton {
-public:
-    NullPointerAppender() {
-    }
+class NullPointerAppender : public AppenderSkeleton
+{
+	public:
+		NullPointerAppender()
+		{
+		}
 
 
-    /**
-     * @{inheritDoc}
-     */
-    void append(const spi::LoggingEventPtr&, log4cxx::helpers::Pool&) {
-         throw NullPointerException(LOG4CXX_STR("Intentional NullPointerException"));
-    }
+		/**
+		 * @{inheritDoc}
+		 */
+		void append(const spi::LoggingEventPtr&, log4cxx::helpers::Pool&)
+		{
+			throw NullPointerException(LOG4CXX_STR("Intentional NullPointerException"));
+		}
 
-    void close() {
-    }
+		void close()
+		{
+		}
 
-    bool requiresLayout() const {
-            return false;
-    }
+		bool requiresLayout() const
+		{
+			return false;
+		}
 };
 
-    /**
-     * Vector appender that can be explicitly blocked.
-     */
-class BlockableVectorAppender : public VectorAppender {
-private:
-      Mutex blocker;
-public:
-      /**
-       * Create new instance.
-       */
-      BlockableVectorAppender() : blocker(pool) {
-      }
+/**
+ * Vector appender that can be explicitly blocked.
+ */
+class BlockableVectorAppender : public VectorAppender
+{
+	private:
+		Mutex blocker;
+	public:
+		/**
+		 * Create new instance.
+		 */
+		BlockableVectorAppender() : blocker(pool)
+		{
+		}
 
-      /**
-       * {@inheritDoc}
-       */
-    void append(const spi::LoggingEventPtr& event, log4cxx::helpers::Pool& p) {
-          synchronized sync(blocker);
-          VectorAppender::append(event, p);
-            //
-            //   if fatal, echo messages for testLoggingInDispatcher
-            //
-            if (event->getLevel() == Level::getInfo()) {
-                LoggerPtr logger = Logger::getLoggerLS(event->getLoggerName());
-                LOG4CXX_LOGLS(logger, Level::getError(), event->getMessage());
-                LOG4CXX_LOGLS(logger, Level::getWarn(), event->getMessage());
-                LOG4CXX_LOGLS(logger, Level::getInfo(), event->getMessage());
-                LOG4CXX_LOGLS(logger, Level::getDebug(), event->getMessage());
-            }
-      }
-      
-      Mutex& getBlocker() {
-          return blocker;
-      }
+		/**
+		 * {@inheritDoc}
+		 */
+		void append(const spi::LoggingEventPtr& event, log4cxx::helpers::Pool& p)
+		{
+			synchronized sync(blocker);
+			VectorAppender::append(event, p);
 
-    };
+			//
+			//   if fatal, echo messages for testLoggingInDispatcher
+			//
+			if (event->getLevel() == Level::getInfo())
+			{
+				LoggerPtr logger = Logger::getLoggerLS(event->getLoggerName());
+				LOG4CXX_LOGLS(logger, Level::getError(), event->getMessage());
+				LOG4CXX_LOGLS(logger, Level::getWarn(), event->getMessage());
+				LOG4CXX_LOGLS(logger, Level::getInfo(), event->getMessage());
+				LOG4CXX_LOGLS(logger, Level::getDebug(), event->getMessage());
+			}
+		}
+
+		Mutex& getBlocker()
+		{
+			return blocker;
+		}
+
+};
 
 typedef helpers::ObjectPtrT<BlockableVectorAppender> BlockableVectorAppenderPtr;
 
@@ -102,186 +113,201 @@
  */
 class AsyncAppenderTestCase : public AppenderSkeletonTestCase
 {
-        LOGUNIT_TEST_SUITE(AsyncAppenderTestCase);
-                //
-                //    tests inherited from AppenderSkeletonTestCase
-                //
-                LOGUNIT_TEST(testDefaultThreshold);
-                LOGUNIT_TEST(testSetOptionThreshold);
+		LOGUNIT_TEST_SUITE(AsyncAppenderTestCase);
+		//
+		//    tests inherited from AppenderSkeletonTestCase
+		//
+		LOGUNIT_TEST(testDefaultThreshold);
+		LOGUNIT_TEST(testSetOptionThreshold);
 
-                LOGUNIT_TEST(closeTest);
-                LOGUNIT_TEST(test2);
-                LOGUNIT_TEST(test3);
-                //
-                //   TODO: test fails on Linux.
-                //LOGUNIT_TEST(testBadAppender);
-                LOGUNIT_TEST(testLocationInfoTrue);
-                LOGUNIT_TEST(testConfiguration);
-        LOGUNIT_TEST_SUITE_END();
+		LOGUNIT_TEST(closeTest);
+		LOGUNIT_TEST(test2);
+		LOGUNIT_TEST(test3);
+		//
+		//   TODO: test fails on Linux.
+		//LOGUNIT_TEST(testBadAppender);
+		LOGUNIT_TEST(testLocationInfoTrue);
+		LOGUNIT_TEST(testConfiguration);
+		LOGUNIT_TEST_SUITE_END();
 
 
-public:
-        void setUp() {
-           AppenderSkeletonTestCase::setUp();
-        }
+	public:
+		void setUp()
+		{
+			AppenderSkeletonTestCase::setUp();
+		}
 
-        void tearDown()
-        {
-                LogManager::shutdown();
-                AppenderSkeletonTestCase::tearDown();
-        }
+		void tearDown()
+		{
+			LogManager::shutdown();
+			AppenderSkeletonTestCase::tearDown();
+		}
 
-        AppenderSkeleton* createAppenderSkeleton() const {
-          return new AsyncAppender();
-        }
+		AppenderSkeleton* createAppenderSkeleton() const
+		{
+			return new AsyncAppender();
+		}
 
-        // this test checks whether it is possible to write to a closed AsyncAppender
-        void closeTest() 
-        {
-                LoggerPtr root = Logger::getRootLogger();
-                LayoutPtr layout = new SimpleLayout();
-                VectorAppenderPtr vectorAppender = new VectorAppender();
-                AsyncAppenderPtr asyncAppender = new AsyncAppender();
-                asyncAppender->setName(LOG4CXX_STR("async-CloseTest"));
-                asyncAppender->addAppender(vectorAppender);
-                root->addAppender(asyncAppender);
+		// this test checks whether it is possible to write to a closed AsyncAppender
+		void closeTest()
+		{
+			LoggerPtr root = Logger::getRootLogger();
+			LayoutPtr layout = new SimpleLayout();
+			VectorAppenderPtr vectorAppender = new VectorAppender();
+			AsyncAppenderPtr asyncAppender = new AsyncAppender();
+			asyncAppender->setName(LOG4CXX_STR("async-CloseTest"));
+			asyncAppender->addAppender(vectorAppender);
+			root->addAppender(asyncAppender);
 
-                root->debug(LOG4CXX_TEST_STR("m1"));
-                asyncAppender->close();
-                root->debug(LOG4CXX_TEST_STR("m2"));
+			root->debug(LOG4CXX_TEST_STR("m1"));
+			asyncAppender->close();
+			root->debug(LOG4CXX_TEST_STR("m2"));
 
-                const std::vector<spi::LoggingEventPtr>& v = vectorAppender->getVector();
-                LOGUNIT_ASSERT_EQUAL((size_t) 1, v.size());
-        }
+			const std::vector<spi::LoggingEventPtr>& v = vectorAppender->getVector();
+			LOGUNIT_ASSERT_EQUAL((size_t) 1, v.size());
+		}
 
-        // this test checks whether appenders embedded within an AsyncAppender are also
-        // closed
-        void test2()
-        {
-                LoggerPtr root = Logger::getRootLogger();
-                LayoutPtr layout = new SimpleLayout();
-                VectorAppenderPtr vectorAppender = new VectorAppender();
-                AsyncAppenderPtr asyncAppender = new AsyncAppender();
-                asyncAppender->setName(LOG4CXX_STR("async-test2"));
-                asyncAppender->addAppender(vectorAppender);
-                root->addAppender(asyncAppender);
+		// this test checks whether appenders embedded within an AsyncAppender are also
+		// closed
+		void test2()
+		{
+			LoggerPtr root = Logger::getRootLogger();
+			LayoutPtr layout = new SimpleLayout();
+			VectorAppenderPtr vectorAppender = new VectorAppender();
+			AsyncAppenderPtr asyncAppender = new AsyncAppender();
+			asyncAppender->setName(LOG4CXX_STR("async-test2"));
+			asyncAppender->addAppender(vectorAppender);
+			root->addAppender(asyncAppender);
 
-                root->debug(LOG4CXX_TEST_STR("m1"));
-                asyncAppender->close();
-                root->debug(LOG4CXX_TEST_STR("m2"));
+			root->debug(LOG4CXX_TEST_STR("m1"));
+			asyncAppender->close();
+			root->debug(LOG4CXX_TEST_STR("m2"));
 
-                const std::vector<spi::LoggingEventPtr>& v = vectorAppender->getVector();
-                LOGUNIT_ASSERT_EQUAL((size_t) 1, v.size());
-                LOGUNIT_ASSERT(vectorAppender->isClosed());
-        }
+			const std::vector<spi::LoggingEventPtr>& v = vectorAppender->getVector();
+			LOGUNIT_ASSERT_EQUAL((size_t) 1, v.size());
+			LOGUNIT_ASSERT(vectorAppender->isClosed());
+		}
 
-        // this test checks whether appenders embedded within an AsyncAppender are also
-        // closed
-        void test3()
-        {
-                size_t LEN = 200;
-                LoggerPtr root = Logger::getRootLogger();
-                VectorAppenderPtr vectorAppender = new VectorAppender();
-                AsyncAppenderPtr asyncAppender = new AsyncAppender();
-                asyncAppender->setName(LOG4CXX_STR("async-test3"));
-                asyncAppender->addAppender(vectorAppender);
-                root->addAppender(asyncAppender);
+		// this test checks whether appenders embedded within an AsyncAppender are also
+		// closed
+		void test3()
+		{
+			size_t LEN = 200;
+			LoggerPtr root = Logger::getRootLogger();
+			VectorAppenderPtr vectorAppender = new VectorAppender();
+			AsyncAppenderPtr asyncAppender = new AsyncAppender();
+			asyncAppender->setName(LOG4CXX_STR("async-test3"));
+			asyncAppender->addAppender(vectorAppender);
+			root->addAppender(asyncAppender);
 
-                for (size_t i = 0; i < LEN; i++) {
-                        LOG4CXX_DEBUG(root, "message" << i);
-                }
+			for (size_t i = 0; i < LEN; i++)
+			{
+				LOG4CXX_DEBUG(root, "message" << i);
+			}
 
-                asyncAppender->close();
-                root->debug(LOG4CXX_TEST_STR("m2"));
+			asyncAppender->close();
+			root->debug(LOG4CXX_TEST_STR("m2"));
 
-                const std::vector<spi::LoggingEventPtr>& v = vectorAppender->getVector();
-                LOGUNIT_ASSERT_EQUAL(LEN, v.size());
-                LOGUNIT_ASSERT_EQUAL(true, vectorAppender->isClosed());
-        }
-        
-    /**
-     * Tests that a bad appender will switch async back to sync.
-     */
-    void testBadAppender() {
-        AppenderPtr nullPointerAppender = new NullPointerAppender();
-        AsyncAppenderPtr asyncAppender = new AsyncAppender();
-        asyncAppender->addAppender(nullPointerAppender);
-        asyncAppender->setBufferSize(5);
-        Pool p;
-        asyncAppender->activateOptions(p);
-        LoggerPtr root = Logger::getRootLogger();
-        root->addAppender(asyncAppender);
-        LOG4CXX_INFO(root, "Message");
-        Thread::sleep(10);
-        try {
-           LOG4CXX_INFO(root, "Message");
-           LOGUNIT_FAIL("Should have thrown exception");
-        } catch(NullPointerException& ex) {
-        }
-    }
-    
-    /**
-     * Tests non-blocking behavior.
-     */
-    void testLocationInfoTrue() {
-        BlockableVectorAppenderPtr blockableAppender = new BlockableVectorAppender();
-        AsyncAppenderPtr async = new AsyncAppender();
-        async->addAppender(blockableAppender);
-        async->setBufferSize(5);
-        async->setLocationInfo(true);
-        async->setBlocking(false);
-        Pool p;
-        async->activateOptions(p);
-        LoggerPtr rootLogger = Logger::getRootLogger();
-        rootLogger->addAppender(async);
-        {
-            synchronized sync(blockableAppender->getBlocker());
-            for (int i = 0; i < 140; i++) {
-                   LOG4CXX_INFO(rootLogger, "Hello, World");
-                   Thread::sleep(1);
-            }
-            LOG4CXX_ERROR(rootLogger, "That's all folks.");
-        }
-        async->close();
-        const std::vector<spi::LoggingEventPtr>& events = blockableAppender->getVector();
-        LOGUNIT_ASSERT(events.size() > 0);
-        LoggingEventPtr initialEvent = events[0];
-        LoggingEventPtr discardEvent = events[events.size() - 1];
-        LOGUNIT_ASSERT(initialEvent->getMessage() == LOG4CXX_STR("Hello, World"));
-        LOGUNIT_ASSERT(discardEvent->getMessage().substr(0,10) == LOG4CXX_STR("Discarded "));
-        LOGUNIT_ASSERT_EQUAL(log4cxx::spi::LocationInfo::getLocationUnavailable().getClassName(), 
-            discardEvent->getLocationInformation().getClassName()); 
-    }
-    
-        void testConfiguration() {
-              log4cxx::xml::DOMConfigurator::configure("input/xml/asyncAppender1.xml");
-              AsyncAppenderPtr asyncAppender(Logger::getRootLogger()->getAppender(LOG4CXX_STR("ASYNC")));
-              LOGUNIT_ASSERT(!(asyncAppender == 0));
-              LOGUNIT_ASSERT_EQUAL(100, asyncAppender->getBufferSize());
-              LOGUNIT_ASSERT_EQUAL(false, asyncAppender->getBlocking());
-              LOGUNIT_ASSERT_EQUAL(true, asyncAppender->getLocationInfo());
-              AppenderList nestedAppenders(asyncAppender->getAllAppenders());
-              //   TODO:
-              //   test seems to work okay, but have not found a working way to 
-              //      get a reference to the nested vector appender 
-              //
-//              LOGUNIT_ASSERT_EQUAL((size_t) 1, nestedAppenders.size());
-//              VectorAppenderPtr vectorAppender(nestedAppenders[0]);
-//              LOGUNIT_ASSERT(0 != vectorAppender);
-              LoggerPtr root(Logger::getRootLogger()); 
-              
-              size_t LEN = 20;
-              for (size_t i = 0; i < LEN; i++) {
-                        LOG4CXX_DEBUG(root, "message" << i);
-              }
-              
-              asyncAppender->close();
-//              const std::vector<spi::LoggingEventPtr>& v = vectorAppender->getVector();
-//              LOGUNIT_ASSERT_EQUAL(LEN, v.size());
-//              LOGUNIT_ASSERT_EQUAL(true, vectorAppender->isClosed());
-        }
+			const std::vector<spi::LoggingEventPtr>& v = vectorAppender->getVector();
+			LOGUNIT_ASSERT_EQUAL(LEN, v.size());
+			LOGUNIT_ASSERT_EQUAL(true, vectorAppender->isClosed());
+		}
 
-        
+		/**
+		 * Tests that a bad appender will switch async back to sync.
+		 */
+		void testBadAppender()
+		{
+			AppenderPtr nullPointerAppender = new NullPointerAppender();
+			AsyncAppenderPtr asyncAppender = new AsyncAppender();
+			asyncAppender->addAppender(nullPointerAppender);
+			asyncAppender->setBufferSize(5);
+			Pool p;
+			asyncAppender->activateOptions(p);
+			LoggerPtr root = Logger::getRootLogger();
+			root->addAppender(asyncAppender);
+			LOG4CXX_INFO(root, "Message");
+			Thread::sleep(10);
+
+			try
+			{
+				LOG4CXX_INFO(root, "Message");
+				LOGUNIT_FAIL("Should have thrown exception");
+			}
+			catch (NullPointerException& ex)
+			{
+			}
+		}
+
+		/**
+		 * Tests non-blocking behavior.
+		 */
+		void testLocationInfoTrue()
+		{
+			BlockableVectorAppenderPtr blockableAppender = new BlockableVectorAppender();
+			AsyncAppenderPtr async = new AsyncAppender();
+			async->addAppender(blockableAppender);
+			async->setBufferSize(5);
+			async->setLocationInfo(true);
+			async->setBlocking(false);
+			Pool p;
+			async->activateOptions(p);
+			LoggerPtr rootLogger = Logger::getRootLogger();
+			rootLogger->addAppender(async);
+			{
+				synchronized sync(blockableAppender->getBlocker());
+
+				for (int i = 0; i < 140; i++)
+				{
+					LOG4CXX_INFO(rootLogger, "Hello, World");
+					Thread::sleep(1);
+				}
+
+				LOG4CXX_ERROR(rootLogger, "That's all folks.");
+			}
+			async->close();
+			const std::vector<spi::LoggingEventPtr>& events = blockableAppender->getVector();
+			LOGUNIT_ASSERT(events.size() > 0);
+			LoggingEventPtr initialEvent = events[0];
+			LoggingEventPtr discardEvent = events[events.size() - 1];
+			LOGUNIT_ASSERT(initialEvent->getMessage() == LOG4CXX_STR("Hello, World"));
+			LOGUNIT_ASSERT(discardEvent->getMessage().substr(0, 10) == LOG4CXX_STR("Discarded "));
+			LOGUNIT_ASSERT_EQUAL(log4cxx::spi::LocationInfo::getLocationUnavailable().getClassName(),
+				discardEvent->getLocationInformation().getClassName());
+		}
+
+		void testConfiguration()
+		{
+			log4cxx::xml::DOMConfigurator::configure("input/xml/asyncAppender1.xml");
+			AsyncAppenderPtr asyncAppender(Logger::getRootLogger()->getAppender(LOG4CXX_STR("ASYNC")));
+			LOGUNIT_ASSERT(!(asyncAppender == 0));
+			LOGUNIT_ASSERT_EQUAL(100, asyncAppender->getBufferSize());
+			LOGUNIT_ASSERT_EQUAL(false, asyncAppender->getBlocking());
+			LOGUNIT_ASSERT_EQUAL(true, asyncAppender->getLocationInfo());
+			AppenderList nestedAppenders(asyncAppender->getAllAppenders());
+			//   TODO:
+			//   test seems to work okay, but have not found a working way to
+			//      get a reference to the nested vector appender
+			//
+			//              LOGUNIT_ASSERT_EQUAL((size_t) 1, nestedAppenders.size());
+			//              VectorAppenderPtr vectorAppender(nestedAppenders[0]);
+			//              LOGUNIT_ASSERT(0 != vectorAppender);
+			LoggerPtr root(Logger::getRootLogger());
+
+			size_t LEN = 20;
+
+			for (size_t i = 0; i < LEN; i++)
+			{
+				LOG4CXX_DEBUG(root, "message" << i);
+			}
+
+			asyncAppender->close();
+			//              const std::vector<spi::LoggingEventPtr>& v = vectorAppender->getVector();
+			//              LOGUNIT_ASSERT_EQUAL(LEN, v.size());
+			//              LOGUNIT_ASSERT_EQUAL(true, vectorAppender->isClosed());
+		}
+
+
 };
 
 LOGUNIT_TEST_SUITE_REGISTRATION(AsyncAppenderTestCase);
diff --git a/src/test/cpp/consoleappendertestcase.cpp b/src/test/cpp/consoleappendertestcase.cpp
index 2e7522e..5138386 100644
--- a/src/test/cpp/consoleappendertestcase.cpp
+++ b/src/test/cpp/consoleappendertestcase.cpp
@@ -27,31 +27,33 @@
  */
 class ConsoleAppenderTestCase : public WriterAppenderTestCase
 {
-   LOGUNIT_TEST_SUITE(ConsoleAppenderTestCase);
-                //
-                //    tests inherited from AppenderSkeletonTestCase
-                //
-                LOGUNIT_TEST(testDefaultThreshold);
-                LOGUNIT_TEST(testSetOptionThreshold);
-                LOGUNIT_TEST(testNoLayout);
-   LOGUNIT_TEST_SUITE_END();
+		LOGUNIT_TEST_SUITE(ConsoleAppenderTestCase);
+		//
+		//    tests inherited from AppenderSkeletonTestCase
+		//
+		LOGUNIT_TEST(testDefaultThreshold);
+		LOGUNIT_TEST(testSetOptionThreshold);
+		LOGUNIT_TEST(testNoLayout);
+		LOGUNIT_TEST_SUITE_END();
 
 
-public:
+	public:
 
-        WriterAppender* createWriterAppender() const {
-          return new log4cxx::ConsoleAppender();
-        }
-        
-        void testNoLayout() {
-            Pool p;
-            ConsoleAppenderPtr appender(new ConsoleAppender());
-            appender->activateOptions(p);
-            LoggerPtr logger(Logger::getRootLogger());
-            logger->addAppender(appender);
-            LOG4CXX_INFO(logger, "No layout specified for ConsoleAppender");
-            logger->removeAppender(appender);
-        }
+		WriterAppender* createWriterAppender() const
+		{
+			return new log4cxx::ConsoleAppender();
+		}
+
+		void testNoLayout()
+		{
+			Pool p;
+			ConsoleAppenderPtr appender(new ConsoleAppender());
+			appender->activateOptions(p);
+			LoggerPtr logger(Logger::getRootLogger());
+			logger->addAppender(appender);
+			LOG4CXX_INFO(logger, "No layout specified for ConsoleAppender");
+			logger->removeAppender(appender);
+		}
 };
 
 LOGUNIT_TEST_SUITE_REGISTRATION(ConsoleAppenderTestCase);
diff --git a/src/test/cpp/customlogger/xlogger.cpp b/src/test/cpp/customlogger/xlogger.cpp
index a837509..84722b8 100644
--- a/src/test/cpp/customlogger/xlogger.cpp
+++ b/src/test/cpp/customlogger/xlogger.cpp
@@ -32,72 +32,72 @@
 
 void XLogger::lethal(const LogString& message, const LocationInfo& locationInfo)
 {
-        if (repository->isDisabled(XLevel::LETHAL_INT))
-        {
-                return;
-        }
+	if (repository->isDisabled(XLevel::LETHAL_INT))
+	{
+		return;
+	}
 
-        if (XLevel::getLethal()->isGreaterOrEqual(this->getEffectiveLevel()))
-        {
-                forcedLog(XLevel::getLethal(), message, locationInfo);
-        }
+	if (XLevel::getLethal()->isGreaterOrEqual(this->getEffectiveLevel()))
+	{
+		forcedLog(XLevel::getLethal(), message, locationInfo);
+	}
 }
 
 void XLogger::lethal(const LogString& message)
 {
-        if (repository->isDisabled(XLevel::LETHAL_INT))
-        {
-                return;
-        }
+	if (repository->isDisabled(XLevel::LETHAL_INT))
+	{
+		return;
+	}
 
-        if (XLevel::getLethal()->isGreaterOrEqual(this->getEffectiveLevel()))
-        {
-                forcedLog(XLevel::getLethal(), message, LocationInfo::getLocationUnavailable());
-        }
+	if (XLevel::getLethal()->isGreaterOrEqual(this->getEffectiveLevel()))
+	{
+		forcedLog(XLevel::getLethal(), message, LocationInfo::getLocationUnavailable());
+	}
 }
 
 LoggerPtr XLogger::getLogger(const LogString& name)
 {
-        return LogManager::getLogger(name, factory);
+	return LogManager::getLogger(name, factory);
 }
 
 LoggerPtr XLogger::getLogger(const helpers::Class& clazz)
 {
-        return XLogger::getLogger(clazz.getName());
+	return XLogger::getLogger(clazz.getName());
 }
 
 void XLogger::trace(const LogString& message, const LocationInfo& locationInfo)
 {
-        if (repository->isDisabled(XLevel::TRACE_INT))
-        {
-                return;
-        }
+	if (repository->isDisabled(XLevel::TRACE_INT))
+	{
+		return;
+	}
 
-        if (XLevel::getTrace()->isGreaterOrEqual(this->getEffectiveLevel()))
-        {
-                forcedLog(XLevel::getTrace(), message, locationInfo);
-        }
+	if (XLevel::getTrace()->isGreaterOrEqual(this->getEffectiveLevel()))
+	{
+		forcedLog(XLevel::getTrace(), message, locationInfo);
+	}
 }
 
 void XLogger::trace(const LogString& message)
 {
-        if (repository->isDisabled(XLevel::TRACE_INT))
-        {
-                return;
-        }
+	if (repository->isDisabled(XLevel::TRACE_INT))
+	{
+		return;
+	}
 
-        if (XLevel::getTrace()->isGreaterOrEqual(this->getEffectiveLevel()))
-        {
-                forcedLog(XLevel::getTrace(), message, LocationInfo::getLocationUnavailable());
-        }
+	if (XLevel::getTrace()->isGreaterOrEqual(this->getEffectiveLevel()))
+	{
+		forcedLog(XLevel::getTrace(), message, LocationInfo::getLocationUnavailable());
+	}
 }
 
 XFactory::XFactory()
 {
 }
 
-LoggerPtr XFactory::makeNewLoggerInstance(log4cxx::helpers::Pool& pool, 
-       const LogString& name) const
+LoggerPtr XFactory::makeNewLoggerInstance(log4cxx::helpers::Pool& pool,
+	const LogString& name) const
 {
-        return new XLogger(pool, name);
+	return new XLogger(pool, name);
 }
diff --git a/src/test/cpp/customlogger/xlogger.h b/src/test/cpp/customlogger/xlogger.h
index 0080f48..896e0bc 100644
--- a/src/test/cpp/customlogger/xlogger.h
+++ b/src/test/cpp/customlogger/xlogger.h
@@ -22,94 +22,100 @@
 
 namespace log4cxx
 {
-        namespace spi {
-          namespace location {
-            class LocationInfo;
-          }
-        }
-        // Any sub-class of Logger must also have its own implementation of
-        // LoggerFactory.
-        class XFactory :
-                public virtual spi::LoggerFactory,
-                public virtual helpers::ObjectImpl
-        {
-        public:
-                DECLARE_ABSTRACT_LOG4CXX_OBJECT(XFactory)
-                BEGIN_LOG4CXX_CAST_MAP()
-                        LOG4CXX_CAST_ENTRY(XFactory)
-                        LOG4CXX_CAST_ENTRY(spi::LoggerFactory)
-                END_LOG4CXX_CAST_MAP()
+namespace spi
+{
+namespace location
+{
+class LocationInfo;
+}
+}
+// Any sub-class of Logger must also have its own implementation of
+// LoggerFactory.
+class XFactory :
+	public virtual spi::LoggerFactory,
+	public virtual helpers::ObjectImpl
+{
+	public:
+		DECLARE_ABSTRACT_LOG4CXX_OBJECT(XFactory)
+		BEGIN_LOG4CXX_CAST_MAP()
+		LOG4CXX_CAST_ENTRY(XFactory)
+		LOG4CXX_CAST_ENTRY(spi::LoggerFactory)
+		END_LOG4CXX_CAST_MAP()
 
-                XFactory();
-                virtual LoggerPtr makeNewLoggerInstance(
-                   log4cxx::helpers::Pool& pool,
-                   const LogString& name) const;
-        };
+		XFactory();
+		virtual LoggerPtr makeNewLoggerInstance(
+			log4cxx::helpers::Pool& pool,
+			const LogString& name) const;
+};
 
-        typedef helpers::ObjectPtrT<XFactory> XFactoryPtr;
+typedef helpers::ObjectPtrT<XFactory> XFactoryPtr;
 
-        /**
-        A simple example showing Logger sub-classing. It shows the
-        minimum steps necessary to implement one's {@link LoggerFactory}.
-        Note that sub-classes follow the hierarchy even if its loggers
-        belong to different classes.
-        */
-        class XLogger : public Logger
-        {
-        // It's enough to instantiate a factory once and for all.
-        static XFactoryPtr factory;
-        LogString suffix;
+/**
+A simple example showing Logger sub-classing. It shows the
+minimum steps necessary to implement one's {@link LoggerFactory}.
+Note that sub-classes follow the hierarchy even if its loggers
+belong to different classes.
+*/
+class XLogger : public Logger
+{
+		// It's enough to instantiate a factory once and for all.
+		static XFactoryPtr factory;
+		LogString suffix;
 
-        public:
-                DECLARE_ABSTRACT_LOG4CXX_OBJECT(XLogger)
-                BEGIN_LOG4CXX_CAST_MAP()
-                        LOG4CXX_CAST_ENTRY(XLogger)
-                        LOG4CXX_CAST_ENTRY_CHAIN(Logger)
-                END_LOG4CXX_CAST_MAP()
+	public:
+		DECLARE_ABSTRACT_LOG4CXX_OBJECT(XLogger)
+		BEGIN_LOG4CXX_CAST_MAP()
+		LOG4CXX_CAST_ENTRY(XLogger)
+		LOG4CXX_CAST_ENTRY_CHAIN(Logger)
+		END_LOG4CXX_CAST_MAP()
 
-                /**
-                        Just calls the parent constuctor.
-                */
-                XLogger(log4cxx::helpers::Pool& pool,
-                        const LogString& name1) : Logger(pool, name1) {}
+		/**
+		        Just calls the parent constuctor.
+		*/
+		XLogger(log4cxx::helpers::Pool& pool,
+			const LogString& name1) : Logger(pool, name1) {}
 
-                /**
-                        Nothing to activate.
-                */
-                void activateOptions() {}
+		/**
+		        Nothing to activate.
+		*/
+		void activateOptions() {}
 
 
-                /**
-                        We introduce a new printing method in order to support {@link
-                        XLevel#LETHAL}.  */
-                void lethal(const LogString& message, const log4cxx::spi::LocationInfo& location);
+		/**
+		        We introduce a new printing method in order to support {@link
+		        XLevel#LETHAL}.  */
+		void lethal(const LogString& message, const log4cxx::spi::LocationInfo& location);
 
-                /**
-                        We introduce a new printing method in order to support {@link
-                        XLevel#LETHAL}.  */
-                void lethal(const LogString& message);
+		/**
+		        We introduce a new printing method in order to support {@link
+		        XLevel#LETHAL}.  */
+		void lethal(const LogString& message);
 
-                static LoggerPtr getLogger(const LogString& name);
+		static LoggerPtr getLogger(const LogString& name);
 
-                static LoggerPtr getLogger(const helpers::Class& clazz);
+		static LoggerPtr getLogger(const helpers::Class& clazz);
 
-                LogString getSuffix() const
-                        { return suffix; }
+		LogString getSuffix() const
+		{
+			return suffix;
+		}
 
-                void setSuffix(const LogString& suffix1)
-                        { this->suffix = suffix1; }
+		void setSuffix(const LogString& suffix1)
+		{
+			this->suffix = suffix1;
+		}
 
-                /**
-                        We introduce a new printing method that takes the TRACE level.
-                */
-                void trace(const LogString& message, const log4cxx::spi::LocationInfo& location);
+		/**
+		        We introduce a new printing method that takes the TRACE level.
+		*/
+		void trace(const LogString& message, const log4cxx::spi::LocationInfo& location);
 
-                /**
-                        We introduce a new printing method that takes the TRACE level.
-                */
-                void trace(const LogString& message);
-        };
+		/**
+		        We introduce a new printing method that takes the TRACE level.
+		*/
+		void trace(const LogString& message);
+};
 
-        typedef helpers::ObjectPtrT<XLogger> XLoggerPtr;
+typedef helpers::ObjectPtrT<XLogger> XLoggerPtr;
 }
 
diff --git a/src/test/cpp/customlogger/xloggertestcase.cpp b/src/test/cpp/customlogger/xloggertestcase.cpp
index 15c3bcf..500820d 100644
--- a/src/test/cpp/customlogger/xloggertestcase.cpp
+++ b/src/test/cpp/customlogger/xloggertestcase.cpp
@@ -36,55 +36,61 @@
 */
 LOGUNIT_CLASS(XLoggerTestCase)
 {
-   LOGUNIT_TEST_SUITE(XLoggerTestCase);
-      LOGUNIT_TEST(test1);
-      LOGUNIT_TEST(test2);
-   LOGUNIT_TEST_SUITE_END();
+	LOGUNIT_TEST_SUITE(XLoggerTestCase);
+	LOGUNIT_TEST(test1);
+	LOGUNIT_TEST(test2);
+	LOGUNIT_TEST_SUITE_END();
 
-   XLoggerPtr logger;
+	XLoggerPtr logger;
 
 public:
-   void setUp()
-   {
-      logger = XLogger::getLogger(
-            LOG4CXX_STR("org.apache.log4j.customLogger.XLoggerTestCase"));
-   }
+	void setUp()
+	{
+		logger = XLogger::getLogger(
+				LOG4CXX_STR("org.apache.log4j.customLogger.XLoggerTestCase"));
+	}
 
-   void tearDown()
-   {
-      logger->getLoggerRepository()->resetConfiguration();
-   }
+	void tearDown()
+	{
+		logger->getLoggerRepository()->resetConfiguration();
+	}
 
-   void test1() { common("1"); }
-   void test2() { common("2"); }
+	void test1()
+	{
+		common("1");
+	}
+	void test2()
+	{
+		common("2");
+	}
 
-   void common(const char* number)
-   {
-        std::string fn("input/xml/customLogger");
-        fn.append(number);
-        fn.append(".xml");
-        DOMConfigurator::configure(fn);
+	void common(const char* number)
+	{
+		std::string fn("input/xml/customLogger");
+		fn.append(number);
+		fn.append(".xml");
+		DOMConfigurator::configure(fn);
 
-        int i = 0;
-        LOG4CXX_LOG(logger, log4cxx::XLevel::getTrace(), "Message " << i);
+		int i = 0;
+		LOG4CXX_LOG(logger, log4cxx::XLevel::getTrace(), "Message " << i);
 
-        i++;
-        LOG4CXX_DEBUG(logger, "Message " << i);
-        i++;
-        LOG4CXX_WARN(logger, "Message " << i);
-        i++;
-        LOG4CXX_ERROR(logger, "Message " << i);
-        i++;
-        LOG4CXX_FATAL(logger, "Message " << i);
-        i++;
-        LOG4CXX_DEBUG(logger, "Message " << i);
+		i++;
+		LOG4CXX_DEBUG(logger, "Message " << i);
+		i++;
+		LOG4CXX_WARN(logger, "Message " << i);
+		i++;
+		LOG4CXX_ERROR(logger, "Message " << i);
+		i++;
+		LOG4CXX_FATAL(logger, "Message " << i);
+		i++;
+		LOG4CXX_DEBUG(logger, "Message " << i);
 
-        const File OUTPUT("output/temp");
-        std::string witness("witness/customLogger.");
-        witness.append(number);
-        const File WITNESS(witness);
-      LOGUNIT_ASSERT(Compare::compare(OUTPUT, WITNESS));
-    }
+		const File OUTPUT("output/temp");
+		std::string witness("witness/customLogger.");
+		witness.append(number);
+		const File WITNESS(witness);
+		LOGUNIT_ASSERT(Compare::compare(OUTPUT, WITNESS));
+	}
 };
 
 LOGUNIT_TEST_SUITE_REGISTRATION(XLoggerTestCase);
diff --git a/src/test/cpp/db/odbcappendertestcase.cpp b/src/test/cpp/db/odbcappendertestcase.cpp
index d0bef0a..155b393 100644
--- a/src/test/cpp/db/odbcappendertestcase.cpp
+++ b/src/test/cpp/db/odbcappendertestcase.cpp
@@ -32,21 +32,22 @@
  */
 class ODBCAppenderTestCase : public AppenderSkeletonTestCase
 {
-   LOGUNIT_TEST_SUITE(ODBCAppenderTestCase);
-                //
-                //    tests inherited from AppenderSkeletonTestCase
-                //
-                LOGUNIT_TEST(testDefaultThreshold);
-                LOGUNIT_TEST(testSetOptionThreshold);
+		LOGUNIT_TEST_SUITE(ODBCAppenderTestCase);
+		//
+		//    tests inherited from AppenderSkeletonTestCase
+		//
+		LOGUNIT_TEST(testDefaultThreshold);
+		LOGUNIT_TEST(testSetOptionThreshold);
 
-   LOGUNIT_TEST_SUITE_END();
+		LOGUNIT_TEST_SUITE_END();
 
 
-public:
+	public:
 
-        AppenderSkeleton* createAppenderSkeleton() const {
-         return new log4cxx::db::ODBCAppender();
-        }
+		AppenderSkeleton* createAppenderSkeleton() const
+		{
+			return new log4cxx::db::ODBCAppender();
+		}
 };
 
 LOGUNIT_TEST_SUITE_REGISTRATION(ODBCAppenderTestCase);
diff --git a/src/test/cpp/decodingtest.cpp b/src/test/cpp/decodingtest.cpp
index 61f90b7..37c00a4 100644
--- a/src/test/cpp/decodingtest.cpp
+++ b/src/test/cpp/decodingtest.cpp
@@ -51,98 +51,106 @@
  * @see LOGCXX-369
  * @see LOGCXX-399
  */
-LOGUNIT_CLASS(DecodingTest) {
-  LOGUNIT_TEST_SUITE(DecodingTest);
+LOGUNIT_CLASS(DecodingTest)
+{
+	LOGUNIT_TEST_SUITE(DecodingTest);
 #if LOG4CXX_CHARSET_USASCII
-          LOGUNIT_TEST(testASCII);
+	LOGUNIT_TEST(testASCII);
 #elif LOG4CXX_CHARSET_ISO88591 || defined(_WIN32_WCE)
-          LOGUNIT_TEST(testLatin1);
+	LOGUNIT_TEST(testLatin1);
 #elif LOG4CXX_CHARSET_UTF8
-          LOGUNIT_TEST(testUtf8);
+	LOGUNIT_TEST(testUtf8);
 #elif LOG4CXX_LOGCHAR_IS_WCHAR && LOG4CXX_HAS_MBSRTOWCS
-          LOGUNIT_TEST(testUtf16);
-          LOGUNIT_TEST(testUtf16LE);
-          LOGUNIT_TEST(testUtf16BE);
+	LOGUNIT_TEST(testUtf16);
+	LOGUNIT_TEST(testUtf16LE);
+	LOGUNIT_TEST(testUtf16BE);
 #else
-          // LocaleCharsetDecoder, so it's difficult to provide a file working for e.g. windows-1252
-          // as well as something completely different.
-          LOGUNIT_TEST(testASCII);
+	// LocaleCharsetDecoder, so it's difficult to provide a file working for e.g. windows-1252
+	// as well as something completely different.
+	LOGUNIT_TEST(testASCII);
 #endif
-  LOGUNIT_TEST_SUITE_END();
+	LOGUNIT_TEST_SUITE_END();
 public:
-    /**
-     * Test us-ascii decoding.
-     */
-  void testASCII() {
-      const wchar_t witness[] = { L'A', 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x0020, 0x003F, 0 };
+	/**
+	 * Test us-ascii decoding.
+	 */
+	void testASCII()
+	{
+		const wchar_t witness[] = { L'A', 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x0020, 0x003F, 0 };
 
-      testImpl(LOG4CXX_STR("ascii.txt"), witness);
+		testImpl(LOG4CXX_STR("ascii.txt"), witness);
 
-  }
+	}
 
-    /**
-     * Test iso-8859-1 decoding.
-     */
-    void testLatin1() {
-      const wchar_t witness[] = { L'A', 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x0020, 0x00B9, 0 };
+	/**
+	 * Test iso-8859-1 decoding.
+	 */
+	void testLatin1()
+	{
+		const wchar_t witness[] = { L'A', 0x003F, 0x003F, 0x003F, 0x003F, 0x003F, 0x0020, 0x00B9, 0 };
 
-        testImpl(LOG4CXX_STR("latin1.txt"), witness);
-    }
+		testImpl(LOG4CXX_STR("latin1.txt"), witness);
+	}
 
-    /**
-     * Test utf-8 decoding.
-     */
-    void testUtf8() {
-        const wchar_t witness[] = { L'A', 0x0605, 0x0530, 0x986, 0x4E03, 0x0400, 0x0020, 0x00B9, 0 };
+	/**
+	 * Test utf-8 decoding.
+	 */
+	void testUtf8()
+	{
+		const wchar_t witness[] = { L'A', 0x0605, 0x0530, 0x986, 0x4E03, 0x0400, 0x0020, 0x00B9, 0 };
 
-        testImpl(LOG4CXX_STR("UTF-8.txt"), witness);
-    }
+		testImpl(LOG4CXX_STR("UTF-8.txt"), witness);
+	}
 
-    /**
-     * Test utf-16 decoding.
-     */
-    void testUtf16() {
-        const wchar_t witness[] = { L'A', 0x0605, 0x0530, 0x986, 0x4E03, 0x0400, 0x0020, 0x00B9, 0 };
+	/**
+	 * Test utf-16 decoding.
+	 */
+	void testUtf16()
+	{
+		const wchar_t witness[] = { L'A', 0x0605, 0x0530, 0x986, 0x4E03, 0x0400, 0x0020, 0x00B9, 0 };
 
-        testImpl(LOG4CXX_STR("UTF-16.txt"), witness);
-    }
+		testImpl(LOG4CXX_STR("UTF-16.txt"), witness);
+	}
 
-    /**
-     * Test utf-16be decoding.
-     */
-    void testUtf16BE() {
-        const wchar_t witness[] = { L'A', 0x0605, 0x0530, 0x986, 0x4E03, 0x0400, 0x0020, 0x00B9, 0 };
+	/**
+	 * Test utf-16be decoding.
+	 */
+	void testUtf16BE()
+	{
+		const wchar_t witness[] = { L'A', 0x0605, 0x0530, 0x986, 0x4E03, 0x0400, 0x0020, 0x00B9, 0 };
 
-        testImpl(LOG4CXX_STR("UTF-16BE.txt"), witness);
-    }
+		testImpl(LOG4CXX_STR("UTF-16BE.txt"), witness);
+	}
 
-    /**
-     * Test utf16-le decoding.
-     */
-    void testUtf16LE() {
-        const wchar_t witness[] = { L'A', 0x0605, 0x0530, 0x986, 0x4E03, 0x0400, 0x0020, 0x00B9, 0 };
+	/**
+	 * Test utf16-le decoding.
+	 */
+	void testUtf16LE()
+	{
+		const wchar_t witness[] = { L'A', 0x0605, 0x0530, 0x986, 0x4E03, 0x0400, 0x0020, 0x00B9, 0 };
 
-        testImpl(LOG4CXX_STR("UTF-16LE.txt"), witness);
-    }
+		testImpl(LOG4CXX_STR("UTF-16LE.txt"), witness);
+	}
 
-    private:
-      void testImpl(
-               const LogString& fileName,
-               const wchar_t*   witness) {
-          CharsetDecoderPtr decoder(CharsetDecoder::getDefaultDecoder());
-          LogString         lsContent;
-          std::wstring      wsContent;
-          LogString         path(LOG4CXX_STR("input/decoding/") + fileName);
-          Pool              pool;
+private:
+	void testImpl(
+		const LogString & fileName,
+		const wchar_t*   witness)
+	{
+		CharsetDecoderPtr decoder(CharsetDecoder::getDefaultDecoder());
+		LogString         lsContent;
+		std::wstring      wsContent;
+		LogString         path(LOG4CXX_STR("input/decoding/") + fileName);
+		Pool              pool;
 
-          FileInputStreamPtr   fis(     new FileInputStream(path));
-          InputStreamReaderPtr isReader(new InputStreamReader(fis, decoder));
+		FileInputStreamPtr   fis(     new FileInputStream(path));
+		InputStreamReaderPtr isReader(new InputStreamReader(fis, decoder));
 
-          lsContent.assign(isReader->read(pool));
-          Transcoder::encode(lsContent, wsContent);
+		lsContent.assign(isReader->read(pool));
+		Transcoder::encode(lsContent, wsContent);
 
-          LOGUNIT_ASSERT_EQUAL((std::wstring) witness, wsContent);
-      }
+		LOGUNIT_ASSERT_EQUAL((std::wstring) witness, wsContent);
+	}
 };
 
 LOGUNIT_TEST_SUITE_REGISTRATION(DecodingTest);
diff --git a/src/test/cpp/defaultinit/testcase1.cpp b/src/test/cpp/defaultinit/testcase1.cpp
index b0059a4..2b56af6 100644
--- a/src/test/cpp/defaultinit/testcase1.cpp
+++ b/src/test/cpp/defaultinit/testcase1.cpp
@@ -5,9 +5,9 @@
  * 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.
@@ -24,27 +24,27 @@
 
 LOGUNIT_CLASS(TestCase1)
 {
-   LOGUNIT_TEST_SUITE(TestCase1);
-      LOGUNIT_TEST(noneTest);
-   LOGUNIT_TEST_SUITE_END();
-   
-public:
-   void setUp()
-   {
-   }
+	LOGUNIT_TEST_SUITE(TestCase1);
+	LOGUNIT_TEST(noneTest);
+	LOGUNIT_TEST_SUITE_END();
 
-   void tearDown()
-   {
-      LogManager::shutdown();
-   }
-   
-   void noneTest()
-   {
-      LoggerPtr root = Logger::getRootLogger();
-     LOG4CXX_DEBUG(root, "Hello, world");
-      bool rootIsConfigured = !root->getAllAppenders().empty();
-      LOGUNIT_ASSERT(!rootIsConfigured);
-   }
+public:
+	void setUp()
+	{
+	}
+
+	void tearDown()
+	{
+		LogManager::shutdown();
+	}
+
+	void noneTest()
+	{
+		LoggerPtr root = Logger::getRootLogger();
+		LOG4CXX_DEBUG(root, "Hello, world");
+		bool rootIsConfigured = !root->getAllAppenders().empty();
+		LOGUNIT_ASSERT(!rootIsConfigured);
+	}
 };
 
 
diff --git a/src/test/cpp/defaultinit/testcase2.cpp b/src/test/cpp/defaultinit/testcase2.cpp
index 1c362c2..c6de497 100644
--- a/src/test/cpp/defaultinit/testcase2.cpp
+++ b/src/test/cpp/defaultinit/testcase2.cpp
@@ -30,35 +30,35 @@
 
 LOGUNIT_CLASS(TestCase2)
 {
-   LOGUNIT_TEST_SUITE(TestCase2);
-      LOGUNIT_TEST(xmlTest);
-   LOGUNIT_TEST_SUITE_END();
+	LOGUNIT_TEST_SUITE(TestCase2);
+	LOGUNIT_TEST(xmlTest);
+	LOGUNIT_TEST_SUITE_END();
 
 public:
-   void setUp()
-   {
-      helpers::Pool p;
-      apr_file_copy("input/xml/defaultInit.xml", "log4cxx.xml", APR_FPROT_UREAD|APR_FPROT_UWRITE, p.getAPRPool());
-   }
+	void setUp()
+	{
+		helpers::Pool p;
+		apr_file_copy("input/xml/defaultInit.xml", "log4cxx.xml", APR_FPROT_UREAD | APR_FPROT_UWRITE, p.getAPRPool());
+	}
 
-   void tearDown()
-   {
-      helpers::Pool p;
-      apr_file_remove("log4cxx.xml", p.getAPRPool());
-      LogManager::shutdown();
-   }
+	void tearDown()
+	{
+		helpers::Pool p;
+		apr_file_remove("log4cxx.xml", p.getAPRPool());
+		LogManager::shutdown();
+	}
 
-   void xmlTest()
-   {
-      LoggerPtr root = Logger::getRootLogger();
-      LOG4CXX_DEBUG(root, "Hello, world");
-      bool rootIsConfigured = !root->getAllAppenders().empty();
-      LOGUNIT_ASSERT(rootIsConfigured);
+	void xmlTest()
+	{
+		LoggerPtr root = Logger::getRootLogger();
+		LOG4CXX_DEBUG(root, "Hello, world");
+		bool rootIsConfigured = !root->getAllAppenders().empty();
+		LOGUNIT_ASSERT(rootIsConfigured);
 
-      AppenderList list = root->getAllAppenders();
-      AppenderPtr appender = list.front();
-      LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("D1"), appender->getName());
-   }
+		AppenderList list = root->getAllAppenders();
+		AppenderPtr appender = list.front();
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("D1"), appender->getName());
+	}
 
 };
 
diff --git a/src/test/cpp/defaultinit/testcase3.cpp b/src/test/cpp/defaultinit/testcase3.cpp
index 2b36f28..fd9a9ab 100644
--- a/src/test/cpp/defaultinit/testcase3.cpp
+++ b/src/test/cpp/defaultinit/testcase3.cpp
@@ -26,35 +26,35 @@
 
 LOGUNIT_CLASS(TestCase3)
 {
-   LOGUNIT_TEST_SUITE(TestCase3);
-      LOGUNIT_TEST(testProperties);
-   LOGUNIT_TEST_SUITE_END();
+	LOGUNIT_TEST_SUITE(TestCase3);
+	LOGUNIT_TEST(testProperties);
+	LOGUNIT_TEST_SUITE_END();
 
 public:
-   void setUp()
-   {
-      helpers::Pool p;
-      apr_file_copy("input/defaultInit3.properties", "log4cxx.properties", APR_FPROT_UREAD|APR_FPROT_UWRITE, p.getAPRPool());
-   }
+	void setUp()
+	{
+		helpers::Pool p;
+		apr_file_copy("input/defaultInit3.properties", "log4cxx.properties", APR_FPROT_UREAD | APR_FPROT_UWRITE, p.getAPRPool());
+	}
 
-   void tearDown()
-   {
-      helpers::Pool p;
-      apr_file_remove("log4cxx.properties", p.getAPRPool());
-      LogManager::shutdown();
-   }
+	void tearDown()
+	{
+		helpers::Pool p;
+		apr_file_remove("log4cxx.properties", p.getAPRPool());
+		LogManager::shutdown();
+	}
 
-   void testProperties()
-   {
-      LoggerPtr root = Logger::getRootLogger();
-     LOG4CXX_DEBUG(root, "Hello, world");
-      bool rootIsConfigured = !root->getAllAppenders().empty();
-      LOGUNIT_ASSERT(rootIsConfigured);
+	void testProperties()
+	{
+		LoggerPtr root = Logger::getRootLogger();
+		LOG4CXX_DEBUG(root, "Hello, world");
+		bool rootIsConfigured = !root->getAllAppenders().empty();
+		LOGUNIT_ASSERT(rootIsConfigured);
 
-      AppenderList list = root->getAllAppenders();
-      AppenderPtr appender = list.front();
-      LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("D3"), appender->getName());
-   }
+		AppenderList list = root->getAllAppenders();
+		AppenderPtr appender = list.front();
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("D3"), appender->getName());
+	}
 
 };
 
diff --git a/src/test/cpp/defaultinit/testcase4.cpp b/src/test/cpp/defaultinit/testcase4.cpp
index d22806a..21e7f37 100644
--- a/src/test/cpp/defaultinit/testcase4.cpp
+++ b/src/test/cpp/defaultinit/testcase4.cpp
@@ -30,36 +30,36 @@
 
 LOGUNIT_CLASS(TestCase4)
 {
-   LOGUNIT_TEST_SUITE(TestCase4);
-      LOGUNIT_TEST(combinedTest);
-   LOGUNIT_TEST_SUITE_END();
+	LOGUNIT_TEST_SUITE(TestCase4);
+	LOGUNIT_TEST(combinedTest);
+	LOGUNIT_TEST_SUITE_END();
 
 public:
-   void setUp()
-   {
-      helpers::Pool p;
-      apr_file_copy("input/xml/defaultInit.xml", "log4cxx.xml", APR_FPROT_UREAD|APR_FPROT_UWRITE, p.getAPRPool());
-   }
+	void setUp()
+	{
+		helpers::Pool p;
+		apr_file_copy("input/xml/defaultInit.xml", "log4cxx.xml", APR_FPROT_UREAD | APR_FPROT_UWRITE, p.getAPRPool());
+	}
 
-   void tearDown()
-   {
-      helpers::Pool p;
-      apr_file_remove("log4cxx.xml", p.getAPRPool());
-      LogManager::shutdown();
-   }
+	void tearDown()
+	{
+		helpers::Pool p;
+		apr_file_remove("log4cxx.xml", p.getAPRPool());
+		LogManager::shutdown();
+	}
 
-   void combinedTest()
-   {
-      LoggerPtr root = Logger::getRootLogger();
-     LOG4CXX_DEBUG(root, "Hello, world");
-      bool rootIsConfigured = !root->getAllAppenders().empty();
-      LOGUNIT_ASSERT(rootIsConfigured);
+	void combinedTest()
+	{
+		LoggerPtr root = Logger::getRootLogger();
+		LOG4CXX_DEBUG(root, "Hello, world");
+		bool rootIsConfigured = !root->getAllAppenders().empty();
+		LOGUNIT_ASSERT(rootIsConfigured);
 
-      AppenderList list = root->getAllAppenders();
-      LOGUNIT_ASSERT_EQUAL((size_t) 1, list.size());
-      AppenderPtr appender = list.front();
-      LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("D1"), appender->getName());
-   }
+		AppenderList list = root->getAllAppenders();
+		LOGUNIT_ASSERT_EQUAL((size_t) 1, list.size());
+		AppenderPtr appender = list.front();
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("D1"), appender->getName());
+	}
 
 };
 
diff --git a/src/test/cpp/encodingtest.cpp b/src/test/cpp/encodingtest.cpp
index 3b04011..b2db84c 100644
--- a/src/test/cpp/encodingtest.cpp
+++ b/src/test/cpp/encodingtest.cpp
@@ -42,151 +42,161 @@
  *
  *
  */
-LOGUNIT_CLASS(EncodingTest) {
-  LOGUNIT_TEST_SUITE(EncodingTest);
-          LOGUNIT_TEST(testASCII);
-          LOGUNIT_TEST(testLatin1);
-          LOGUNIT_TEST(testUtf8);
-          LOGUNIT_TEST(testUtf16);
-          LOGUNIT_TEST(testUtf16LE);
-          LOGUNIT_TEST(testUtf16BE);
-  LOGUNIT_TEST_SUITE_END();
+LOGUNIT_CLASS(EncodingTest)
+{
+	LOGUNIT_TEST_SUITE(EncodingTest);
+	LOGUNIT_TEST(testASCII);
+	LOGUNIT_TEST(testLatin1);
+	LOGUNIT_TEST(testUtf8);
+	LOGUNIT_TEST(testUtf16);
+	LOGUNIT_TEST(testUtf16LE);
+	LOGUNIT_TEST(testUtf16BE);
+	LOGUNIT_TEST_SUITE_END();
 public:
-    /**
-     * Resets configuration after each test.
-     */
-    void tearDown() {
-      Logger::getRootLogger()->getLoggerRepository()->resetConfiguration();
-    }
+	/**
+	 * Resets configuration after each test.
+	 */
+	void tearDown()
+	{
+		Logger::getRootLogger()->getLoggerRepository()->resetConfiguration();
+	}
 
 
-    /**
-     * Test us-ascii encoding.
-     */
-  void testASCII() {
-      LoggerPtr root(Logger::getRootLogger());
+	/**
+	 * Test us-ascii encoding.
+	 */
+	void testASCII()
+	{
+		LoggerPtr root(Logger::getRootLogger());
 
-      configure(root, LOG4CXX_STR("output/encoding/ascii.log"),
-                      LOG4CXX_STR("US-ASCII"));
-      common(root);
+		configure(root, LOG4CXX_STR("output/encoding/ascii.log"),
+			LOG4CXX_STR("US-ASCII"));
+		common(root);
 
-      BinaryCompare::compare( "output/encoding/ascii.log",
-                              "witness/encoding/ascii.log");
-  }
+		BinaryCompare::compare( "output/encoding/ascii.log",
+			"witness/encoding/ascii.log");
+	}
 
-    /**
-     * Test iso-8859-1 encoding.
-     */
-    void testLatin1() {
-        LoggerPtr root(Logger::getRootLogger());
+	/**
+	 * Test iso-8859-1 encoding.
+	 */
+	void testLatin1()
+	{
+		LoggerPtr root(Logger::getRootLogger());
 
-        configure(root, LOG4CXX_STR("output/encoding/latin1.log"),
-                        LOG4CXX_STR("iso-8859-1"));
-        common(root);
+		configure(root, LOG4CXX_STR("output/encoding/latin1.log"),
+			LOG4CXX_STR("iso-8859-1"));
+		common(root);
 
-        BinaryCompare::compare( "output/encoding/latin1.log",
-                                "witness/encoding/latin1.log");
-    }
+		BinaryCompare::compare( "output/encoding/latin1.log",
+			"witness/encoding/latin1.log");
+	}
 
-    /**
-     * Test utf-8 encoding.
-     */
-    void testUtf8() {
-        LoggerPtr root(Logger::getRootLogger());
+	/**
+	 * Test utf-8 encoding.
+	 */
+	void testUtf8()
+	{
+		LoggerPtr root(Logger::getRootLogger());
 
-        configure(root, LOG4CXX_STR("output/encoding/UTF-8.log"),
-                        LOG4CXX_STR("UTF-8"));
-        common(root);
+		configure(root, LOG4CXX_STR("output/encoding/UTF-8.log"),
+			LOG4CXX_STR("UTF-8"));
+		common(root);
 
-        BinaryCompare::compare( "output/encoding/UTF-8.log",
-                                "witness/encoding/UTF-8.log");
-    }
+		BinaryCompare::compare( "output/encoding/UTF-8.log",
+			"witness/encoding/UTF-8.log");
+	}
 
-    /**
-     * Test utf-16 encoding.
-     */
-    void testUtf16() {
-        LoggerPtr root(Logger::getRootLogger());
+	/**
+	 * Test utf-16 encoding.
+	 */
+	void testUtf16()
+	{
+		LoggerPtr root(Logger::getRootLogger());
 
-        configure(root, LOG4CXX_STR("output/encoding/UTF-16.log"),
-                        LOG4CXX_STR("UTF-16"));
-        common(root);
+		configure(root, LOG4CXX_STR("output/encoding/UTF-16.log"),
+			LOG4CXX_STR("UTF-16"));
+		common(root);
 
-        BinaryCompare::compare( "output/encoding/UTF-16.log",
-                                "witness/encoding/UTF-16.log");
-    }
+		BinaryCompare::compare( "output/encoding/UTF-16.log",
+			"witness/encoding/UTF-16.log");
+	}
 
-    /**
-     * Test utf-16be encoding.
-     */
-    void testUtf16BE() {
-        LoggerPtr root(Logger::getRootLogger());
+	/**
+	 * Test utf-16be encoding.
+	 */
+	void testUtf16BE()
+	{
+		LoggerPtr root(Logger::getRootLogger());
 
-        configure(root, LOG4CXX_STR("output/encoding/UTF-16BE.log"),
-                        LOG4CXX_STR("UTF-16BE"));
-        common(root);
+		configure(root, LOG4CXX_STR("output/encoding/UTF-16BE.log"),
+			LOG4CXX_STR("UTF-16BE"));
+		common(root);
 
-        BinaryCompare::compare( "output/encoding/UTF-16BE.log",
-                                "witness/encoding/UTF-16BE.log");
-    }
+		BinaryCompare::compare( "output/encoding/UTF-16BE.log",
+			"witness/encoding/UTF-16BE.log");
+	}
 
-    /**
-     * Test utf16-le encoding.
-     */
-    void testUtf16LE() {
-        LoggerPtr root(Logger::getRootLogger());
+	/**
+	 * Test utf16-le encoding.
+	 */
+	void testUtf16LE()
+	{
+		LoggerPtr root(Logger::getRootLogger());
 
-        configure(root, LOG4CXX_STR("output/encoding/UTF-16LE.log"),
-                        LOG4CXX_STR("UTF-16LE"));
-        common(root);
+		configure(root, LOG4CXX_STR("output/encoding/UTF-16LE.log"),
+			LOG4CXX_STR("UTF-16LE"));
+		common(root);
 
-        BinaryCompare::compare( "output/encoding/UTF-16LE.log",
-                                "witness/encoding/UTF-16LE.log");
-    }
+		BinaryCompare::compare( "output/encoding/UTF-16LE.log",
+			"witness/encoding/UTF-16LE.log");
+	}
 
-    /**
-     * Configure logging.
-     * @param logger logger
-     * @param filename logging file name
-     * @param encoding encoding
-     */
-    private:
-    void configure(      LoggerPtr& logger,
-                   const LogString& filename,
-                   const LogString& encoding) {
-        FileAppenderPtr  appender(new FileAppender());
-        PatternLayoutPtr layout(new PatternLayout());
-        Pool             p;
+	/**
+	 * Configure logging.
+	 * @param logger logger
+	 * @param filename logging file name
+	 * @param encoding encoding
+	 */
+private:
+	void configure(      LoggerPtr & logger,
+		const LogString & filename,
+		const LogString & encoding)
+	{
+		FileAppenderPtr  appender(new FileAppender());
+		PatternLayoutPtr layout(new PatternLayout());
+		Pool             p;
 
-        layout->setConversionPattern(LOG4CXX_STR("%p - %m\n"));
-        layout->activateOptions(p);
+		layout->setConversionPattern(LOG4CXX_STR("%p - %m\n"));
+		layout->activateOptions(p);
 
-        appender->setAppend(false);
-        appender->setEncoding(encoding);
-        appender->setFile(filename);
-        appender->setLayout(layout);
-        appender->activateOptions(p);
+		appender->setAppend(false);
+		appender->setEncoding(encoding);
+		appender->setFile(filename);
+		appender->setLayout(layout);
+		appender->activateOptions(p);
 
-        logger->addAppender(appender);
-        logger->setLevel(Level::getInfo());
-    }
+		logger->addAppender(appender);
+		logger->setLevel(Level::getInfo());
+	}
 
-    /**
-     * Common logging requests.
-     * @param logger logger
-     */
-    void common(LoggerPtr& logger) {
-        logger->info("Hello, World");
+	/**
+	 * Common logging requests.
+	 * @param logger logger
+	 */
+	void common(LoggerPtr & logger)
+	{
+		logger->info("Hello, World");
 
-        // pi can be encoded in iso-8859-1
-        const wchar_t pi[] = { 0x00B9, 0 };
-        logger->info(pi);
+		// pi can be encoded in iso-8859-1
+		const wchar_t pi[] = { 0x00B9, 0 };
+		logger->info(pi);
 
-        //   arbitrary, hopefully meaningless, characters from
-        //     Latin, Arabic, Armenian, Bengali, CJK and Cyrillic
-        const wchar_t greeting[] = { L'A', 0x0605, 0x0530, 0x986, 0x4E03, 0x400, 0 };
-        logger->info(greeting);
-    }
+		//   arbitrary, hopefully meaningless, characters from
+		//     Latin, Arabic, Armenian, Bengali, CJK and Cyrillic
+		const wchar_t greeting[] = { L'A', 0x0605, 0x0530, 0x986, 0x4E03, 0x400, 0 };
+		logger->info(greeting);
+	}
 };
 
 LOGUNIT_TEST_SUITE_REGISTRATION(EncodingTest);
diff --git a/src/test/cpp/fileappendertest.cpp b/src/test/cpp/fileappendertest.cpp
index e16355a..30b99bf 100644
--- a/src/test/cpp/fileappendertest.cpp
+++ b/src/test/cpp/fileappendertest.cpp
@@ -27,56 +27,60 @@
  *
  * FileAppender tests.
  */
-LOGUNIT_CLASS(FileAppenderTest) {
-  LOGUNIT_TEST_SUITE(FileAppenderTest);
-          LOGUNIT_TEST(testDirectoryCreation);
-          LOGUNIT_TEST(testgetSetThreshold);
-          LOGUNIT_TEST(testIsAsSevereAsThreshold);
-  LOGUNIT_TEST_SUITE_END();
+LOGUNIT_CLASS(FileAppenderTest)
+{
+	LOGUNIT_TEST_SUITE(FileAppenderTest);
+	LOGUNIT_TEST(testDirectoryCreation);
+	LOGUNIT_TEST(testgetSetThreshold);
+	LOGUNIT_TEST(testIsAsSevereAsThreshold);
+	LOGUNIT_TEST_SUITE_END();
 public:
-  /**
-   * Tests that any necessary directories are attempted to
-   * be created if they don't exist.  See bug 9150.
-   *
-   */
-  void testDirectoryCreation() {
-      File newFile(LOG4CXX_STR("output/newdir/temp.log"));
-      Pool p;
-      newFile.deleteFile(p);
+	/**
+	 * Tests that any necessary directories are attempted to
+	 * be created if they don't exist.  See bug 9150.
+	 *
+	 */
+	void testDirectoryCreation()
+	{
+		File newFile(LOG4CXX_STR("output/newdir/temp.log"));
+		Pool p;
+		newFile.deleteFile(p);
 
-      File newDir(LOG4CXX_STR("output/newdir"));
-      newDir.deleteFile(p);
+		File newDir(LOG4CXX_STR("output/newdir"));
+		newDir.deleteFile(p);
 
-      FileAppenderPtr wa(new FileAppender());
-      wa->setFile(LOG4CXX_STR("output/newdir/temp.log"));
-      wa->setLayout(new PatternLayout(LOG4CXX_STR("%m%n")));
-      wa->activateOptions(p);
+		FileAppenderPtr wa(new FileAppender());
+		wa->setFile(LOG4CXX_STR("output/newdir/temp.log"));
+		wa->setLayout(new PatternLayout(LOG4CXX_STR("%m%n")));
+		wa->activateOptions(p);
 
-      LOGUNIT_ASSERT(File(LOG4CXX_STR("output/newdir/temp.log")).exists(p));
-  }
+		LOGUNIT_ASSERT(File(LOG4CXX_STR("output/newdir/temp.log")).exists(p));
+	}
 
-  /**
-   * Tests getThreshold and setThreshold.
-   */
-  void testgetSetThreshold() {
-    FileAppenderPtr appender = new FileAppender();
-    LevelPtr debug = Level::getDebug();
-    //
-    //  different from log4j where threshold is null.
-    //
-    LOGUNIT_ASSERT_EQUAL(Level::getAll(), appender->getThreshold());
-    appender->setThreshold(debug);
-    LOGUNIT_ASSERT_EQUAL(debug, appender->getThreshold());
-  }
+	/**
+	 * Tests getThreshold and setThreshold.
+	 */
+	void testgetSetThreshold()
+	{
+		FileAppenderPtr appender = new FileAppender();
+		LevelPtr debug = Level::getDebug();
+		//
+		//  different from log4j where threshold is null.
+		//
+		LOGUNIT_ASSERT_EQUAL(Level::getAll(), appender->getThreshold());
+		appender->setThreshold(debug);
+		LOGUNIT_ASSERT_EQUAL(debug, appender->getThreshold());
+	}
 
-  /**
-   * Tests isAsSevereAsThreshold.
-   */
-  void testIsAsSevereAsThreshold() {
-    FileAppenderPtr appender = new FileAppender();
-    LevelPtr debug = Level::getDebug();
-    LOGUNIT_ASSERT(appender->isAsSevereAsThreshold(debug));
-  }
+	/**
+	 * Tests isAsSevereAsThreshold.
+	 */
+	void testIsAsSevereAsThreshold()
+	{
+		FileAppenderPtr appender = new FileAppender();
+		LevelPtr debug = Level::getDebug();
+		LOGUNIT_ASSERT(appender->isAsSevereAsThreshold(debug));
+	}
 };
 
 LOGUNIT_TEST_SUITE_REGISTRATION(FileAppenderTest);
diff --git a/src/test/cpp/fileappendertestcase.cpp b/src/test/cpp/fileappendertestcase.cpp
index dadf034..1e469db 100644
--- a/src/test/cpp/fileappendertestcase.cpp
+++ b/src/test/cpp/fileappendertestcase.cpp
@@ -23,8 +23,9 @@
 using namespace log4cxx;
 using namespace log4cxx::helpers;
 
-WriterAppender* FileAppenderAbstractTestCase::createWriterAppender() const {
-    return createFileAppender();
+WriterAppender* FileAppenderAbstractTestCase::createWriterAppender() const
+{
+	return createFileAppender();
 }
 
 
@@ -33,78 +34,82 @@
  */
 class FileAppenderTestCase : public FileAppenderAbstractTestCase
 {
-   LOGUNIT_TEST_SUITE(FileAppenderTestCase);
-                //
-                //    tests inherited from AppenderSkeletonTestCase
-                //
-                LOGUNIT_TEST(testDefaultThreshold);
-                LOGUNIT_TEST(testSetOptionThreshold);
+		LOGUNIT_TEST_SUITE(FileAppenderTestCase);
+		//
+		//    tests inherited from AppenderSkeletonTestCase
+		//
+		LOGUNIT_TEST(testDefaultThreshold);
+		LOGUNIT_TEST(testSetOptionThreshold);
 
-                //  tests defined here
-                LOGUNIT_TEST(testSetDoubleBackslashes);
-                LOGUNIT_TEST(testStripDuplicateBackslashes);
+		//  tests defined here
+		LOGUNIT_TEST(testSetDoubleBackslashes);
+		LOGUNIT_TEST(testStripDuplicateBackslashes);
 
-   LOGUNIT_TEST_SUITE_END();
+		LOGUNIT_TEST_SUITE_END();
 
 
 
 
-public:
+	public:
 
-        FileAppender* createFileAppender() const {
-          return new log4cxx::FileAppender();
-        }
+		FileAppender* createFileAppender() const
+		{
+			return new log4cxx::FileAppender();
+		}
 
-        void testSetDoubleBackslashes() {
-            FileAppender appender;
-            appender.setOption(LOG4CXX_STR("FILE"), LOG4CXX_STR("output\\\\temp"));
-            const File& file = appender.getFile();
-            LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("output\\temp"), file.getPath()); 
-        }
+		void testSetDoubleBackslashes()
+		{
+			FileAppender appender;
+			appender.setOption(LOG4CXX_STR("FILE"), LOG4CXX_STR("output\\\\temp"));
+			const File& file = appender.getFile();
+			LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("output\\temp"), file.getPath());
+		}
 
-          /**
-           * Tests that double backslashes in filespecs are stripped
-           *  on calls to setOption.
-           * 
-           */
-        void testStripDoubleBackslashes() {
+		/**
+		 * Tests that double backslashes in filespecs are stripped
+		 *  on calls to setOption.
+		 *
+		 */
+		void testStripDoubleBackslashes()
+		{
 
-            FileAppender appender;
-            appender.setOption(LOG4CXX_STR("FILE"), LOG4CXX_STR("output\\\\temp"));
-            const File& file = appender.getFile();
-            LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("output\\temp"), file.getPath()); 
-        }
+			FileAppender appender;
+			appender.setOption(LOG4CXX_STR("FILE"), LOG4CXX_STR("output\\\\temp"));
+			const File& file = appender.getFile();
+			LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("output\\temp"), file.getPath());
+		}
 
-          /**
-           * Tests stripDuplicateBackslashes
-           *
-           * 
-           */
-        void testStripDuplicateBackslashes() {
-             LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("\\foo\\bar\\foo"), 
-                 FileAppender::stripDuplicateBackslashes(LOG4CXX_STR("\\foo\\bar\\foo")));
-             LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("\\foo\\bar\\foo\\"), 
-                FileAppender::stripDuplicateBackslashes(LOG4CXX_STR("\\\\foo\\\\bar\\\\foo\\\\")));
-             LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("\\foo\\bar\\foo\\"), 
-                FileAppender::stripDuplicateBackslashes(LOG4CXX_STR("\\foo\\bar\\foo\\")));
-             //
-             //   UNC's should either start with two backslashes and contain additional singles
-             //       or four back slashes and addition doubles
-             LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("\\\\foo\\bar\\foo"), 
-                FileAppender::stripDuplicateBackslashes(LOG4CXX_STR("\\\\\\\\foo\\\\bar\\\\foo")));
-             LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("\\\\foo\\bar\\foo"), 
-                FileAppender::stripDuplicateBackslashes(LOG4CXX_STR("\\\\foo\\bar\\foo")));
-            //
-            //   it it starts with doubles but has no other path component
-            //      then it is a file path
-             LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("\\foo.log"), 
-                FileAppender::stripDuplicateBackslashes(LOG4CXX_STR("\\\\foo.log")));
-            //
-            //   it it starts with quads but has no other path component
-            //      then it is a UNC
-             LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("\\\\foo.log"), 
-                FileAppender::stripDuplicateBackslashes(LOG4CXX_STR("\\\\\\\\foo.log")));
-          }  
+		/**
+		 * Tests stripDuplicateBackslashes
+		 *
+		 *
+		 */
+		void testStripDuplicateBackslashes()
+		{
+			LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("\\foo\\bar\\foo"),
+				FileAppender::stripDuplicateBackslashes(LOG4CXX_STR("\\foo\\bar\\foo")));
+			LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("\\foo\\bar\\foo\\"),
+				FileAppender::stripDuplicateBackslashes(LOG4CXX_STR("\\\\foo\\\\bar\\\\foo\\\\")));
+			LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("\\foo\\bar\\foo\\"),
+				FileAppender::stripDuplicateBackslashes(LOG4CXX_STR("\\foo\\bar\\foo\\")));
+			//
+			//   UNC's should either start with two backslashes and contain additional singles
+			//       or four back slashes and addition doubles
+			LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("\\\\foo\\bar\\foo"),
+				FileAppender::stripDuplicateBackslashes(LOG4CXX_STR("\\\\\\\\foo\\\\bar\\\\foo")));
+			LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("\\\\foo\\bar\\foo"),
+				FileAppender::stripDuplicateBackslashes(LOG4CXX_STR("\\\\foo\\bar\\foo")));
+			//
+			//   it it starts with doubles but has no other path component
+			//      then it is a file path
+			LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("\\foo.log"),
+				FileAppender::stripDuplicateBackslashes(LOG4CXX_STR("\\\\foo.log")));
+			//
+			//   it it starts with quads but has no other path component
+			//      then it is a UNC
+			LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("\\\\foo.log"),
+				FileAppender::stripDuplicateBackslashes(LOG4CXX_STR("\\\\\\\\foo.log")));
+		}
 
 };
 
diff --git a/src/test/cpp/fileappendertestcase.h b/src/test/cpp/fileappendertestcase.h
index 4eabed3..f8caa49 100644
--- a/src/test/cpp/fileappendertestcase.h
+++ b/src/test/cpp/fileappendertestcase.h
@@ -26,9 +26,9 @@
 class FileAppenderAbstractTestCase : public WriterAppenderTestCase
 {
 
-public:
-        log4cxx::WriterAppender* createWriterAppender() const;
+	public:
+		log4cxx::WriterAppender* createWriterAppender() const;
 
-        virtual log4cxx::FileAppender* createFileAppender() const = 0;
+		virtual log4cxx::FileAppender* createFileAppender() const = 0;
 
 };
diff --git a/src/test/cpp/filetestcase.cpp b/src/test/cpp/filetestcase.cpp
index 06efce2..70009a9 100644
--- a/src/test/cpp/filetestcase.cpp
+++ b/src/test/cpp/filetestcase.cpp
@@ -29,7 +29,7 @@
 #include <log4cxx/helpers/fileinputstream.h>
 
 #if LOG4CXX_CFSTRING_API
-#include <CoreFoundation/CFString.h>
+	#include <CoreFoundation/CFString.h>
 #endif
 
 using namespace log4cxx;
@@ -38,147 +38,164 @@
 
 LOGUNIT_CLASS(FileTestCase)
 {
-        LOGUNIT_TEST_SUITE(FileTestCase);
-                LOGUNIT_TEST(defaultConstructor);
-                LOGUNIT_TEST(defaultExists);
-                LOGUNIT_TEST(defaultRead);
-                LOGUNIT_TEST(propertyRead);
-                LOGUNIT_TEST(propertyExists);
-                LOGUNIT_TEST(fileWrite1);
+	LOGUNIT_TEST_SUITE(FileTestCase);
+	LOGUNIT_TEST(defaultConstructor);
+	LOGUNIT_TEST(defaultExists);
+	LOGUNIT_TEST(defaultRead);
+	LOGUNIT_TEST(propertyRead);
+	LOGUNIT_TEST(propertyExists);
+	LOGUNIT_TEST(fileWrite1);
 #if LOG4CXX_WCHAR_T_API
-                LOGUNIT_TEST(wcharConstructor);
+	LOGUNIT_TEST(wcharConstructor);
 #endif
 #if LOG4CXX_UNICHAR_API
-                LOGUNIT_TEST(unicharConstructor);
+	LOGUNIT_TEST(unicharConstructor);
 #endif
 #if LOG4CXX_CFSTRING_API
-                LOGUNIT_TEST(cfstringConstructor);
+	LOGUNIT_TEST(cfstringConstructor);
 #endif
-                LOGUNIT_TEST(copyConstructor);
-                LOGUNIT_TEST(assignment);
-                LOGUNIT_TEST(deleteBackslashedFileName);
-        LOGUNIT_TEST_SUITE_END();
+	LOGUNIT_TEST(copyConstructor);
+	LOGUNIT_TEST(assignment);
+	LOGUNIT_TEST(deleteBackslashedFileName);
+	LOGUNIT_TEST_SUITE_END();
 
 public:
-        void defaultConstructor() {
-          File defFile;
-          LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR(""), defFile.getPath());
-        }
+	void defaultConstructor()
+	{
+		File defFile;
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR(""), defFile.getPath());
+	}
 
 
 
-        void defaultExists() {
-          File defFile;
-          Pool pool;
-          bool exists = defFile.exists(pool);
-          LOGUNIT_ASSERT_EQUAL(false, exists);
-        }
+	void defaultExists()
+	{
+		File defFile;
+		Pool pool;
+		bool exists = defFile.exists(pool);
+		LOGUNIT_ASSERT_EQUAL(false, exists);
+	}
 
-        // check default constructor. read() throws an exception
-        // if no file name was given.
-        void defaultRead() {
-          File defFile;
-          Pool pool;
-          try {
-            InputStreamPtr defInput = new FileInputStream(defFile);
-            InputStreamReaderPtr inputReader = new InputStreamReader(defInput);
-            LogString contents(inputReader->read(pool));
-            LOGUNIT_ASSERT(false);
-          } catch(IOException &ex) {
-          }
-        }
+	// check default constructor. read() throws an exception
+	// if no file name was given.
+	void defaultRead()
+	{
+		File defFile;
+		Pool pool;
+
+		try
+		{
+			InputStreamPtr defInput = new FileInputStream(defFile);
+			InputStreamReaderPtr inputReader = new InputStreamReader(defInput);
+			LogString contents(inputReader->read(pool));
+			LOGUNIT_ASSERT(false);
+		}
+		catch (IOException& ex)
+		{
+		}
+	}
 
 
 #if LOG4CXX_WCHAR_T_API
-        void wcharConstructor() {
-            File propFile(L"input/patternLayout1.properties");
-            Pool pool;
-            bool exists = propFile.exists(pool);
-            LOGUNIT_ASSERT_EQUAL(true, exists);
-       }
+	void wcharConstructor()
+	{
+		File propFile(L"input/patternLayout1.properties");
+		Pool pool;
+		bool exists = propFile.exists(pool);
+		LOGUNIT_ASSERT_EQUAL(true, exists);
+	}
 #endif
 
 #if LOG4CXX_UNICHAR_API
-        void unicharConstructor() {
-            const log4cxx::UniChar filename[] = { 'i', 'n', 'p', 'u', 't', '/', 
-               'p', 'a', 't', 't', 'e', 'r', 'n', 'L', 'a', 'y', 'o', 'u', 't', '1', '.', 
-               'p', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's', 0 };
-            File propFile(filename);
-            Pool pool;
-            bool exists = propFile.exists(pool);
-            LOGUNIT_ASSERT_EQUAL(true, exists);
-       }
+	void unicharConstructor()
+	{
+		const log4cxx::UniChar filename[] = { 'i', 'n', 'p', 'u', 't', '/',
+				'p', 'a', 't', 't', 'e', 'r', 'n', 'L', 'a', 'y', 'o', 'u', 't', '1', '.',
+				'p', 'r', 'o', 'p', 'e', 'r', 't', 'i', 'e', 's', 0
+			};
+		File propFile(filename);
+		Pool pool;
+		bool exists = propFile.exists(pool);
+		LOGUNIT_ASSERT_EQUAL(true, exists);
+	}
 #endif
 
 #if LOG4CXX_CFSTRING_API
-        void cfstringConstructor() {
-            File propFile(CFSTR("input/patternLayout.properties"));
-            Pool pool;
-            bool exists = propFile.exists(pool);
-            LOGUNIT_ASSERT_EQUAL(true, exists);
-       }
+	void cfstringConstructor()
+	{
+		File propFile(CFSTR("input/patternLayout.properties"));
+		Pool pool;
+		bool exists = propFile.exists(pool);
+		LOGUNIT_ASSERT_EQUAL(true, exists);
+	}
 #endif
 
-        void copyConstructor() {
-            File propFile("input/patternLayout1.properties");
-            File copy(propFile);
-            Pool pool;
-            bool exists = copy.exists(pool);
-            LOGUNIT_ASSERT_EQUAL(true, exists);
-        }
+	void copyConstructor()
+	{
+		File propFile("input/patternLayout1.properties");
+		File copy(propFile);
+		Pool pool;
+		bool exists = copy.exists(pool);
+		LOGUNIT_ASSERT_EQUAL(true, exists);
+	}
 
-        void assignment() {
-            File propFile("input/patternLayout1.properties");
-            File copy = propFile;
-            Pool pool;
-            bool exists = copy.exists(pool);
-            LOGUNIT_ASSERT_EQUAL(true, exists);
-        }
+	void assignment()
+	{
+		File propFile("input/patternLayout1.properties");
+		File copy = propFile;
+		Pool pool;
+		bool exists = copy.exists(pool);
+		LOGUNIT_ASSERT_EQUAL(true, exists);
+	}
 
-        void propertyRead() {
-          File propFile("input/patternLayout1.properties");
-          Pool pool;
-          InputStreamPtr propStream = new FileInputStream(propFile);
-          InputStreamReaderPtr propReader = new InputStreamReader(propStream);
-          LogString props(propReader->read(pool));
-          LogString line1(LOG4CXX_STR("# Licensed to the Apache Software Foundation (ASF) under one or more"));
-          LOGUNIT_ASSERT_EQUAL(line1, props.substr(0, line1.length()));
-        }
+	void propertyRead()
+	{
+		File propFile("input/patternLayout1.properties");
+		Pool pool;
+		InputStreamPtr propStream = new FileInputStream(propFile);
+		InputStreamReaderPtr propReader = new InputStreamReader(propStream);
+		LogString props(propReader->read(pool));
+		LogString line1(LOG4CXX_STR("# Licensed to the Apache Software Foundation (ASF) under one or more"));
+		LOGUNIT_ASSERT_EQUAL(line1, props.substr(0, line1.length()));
+	}
 
-        void propertyExists() {
-          File propFile("input/patternLayout1.properties");
-          Pool pool;
-          bool exists = propFile.exists(pool);
-          LOGUNIT_ASSERT_EQUAL(true, exists);
-        }
+	void propertyExists()
+	{
+		File propFile("input/patternLayout1.properties");
+		Pool pool;
+		bool exists = propFile.exists(pool);
+		LOGUNIT_ASSERT_EQUAL(true, exists);
+	}
 
-        void fileWrite1() {
-          OutputStreamPtr fos =
-                      new FileOutputStream(LOG4CXX_STR("output/fileWrite1.txt"));
-          OutputStreamWriterPtr osw = new OutputStreamWriter(fos);
+	void fileWrite1()
+	{
+		OutputStreamPtr fos =
+			new FileOutputStream(LOG4CXX_STR("output/fileWrite1.txt"));
+		OutputStreamWriterPtr osw = new OutputStreamWriter(fos);
 
-          Pool pool;
-          LogString greeting(LOG4CXX_STR("Hello, World"));
-          greeting.append(LOG4CXX_EOL);
-          osw->write(greeting, pool);
+		Pool pool;
+		LogString greeting(LOG4CXX_STR("Hello, World"));
+		greeting.append(LOG4CXX_EOL);
+		osw->write(greeting, pool);
 
-          InputStreamPtr is =
-                      new FileInputStream(LOG4CXX_STR("output/fileWrite1.txt"));
-          InputStreamReaderPtr isr = new InputStreamReader(is);
-          LogString reply = isr->read(pool);
+		InputStreamPtr is =
+			new FileInputStream(LOG4CXX_STR("output/fileWrite1.txt"));
+		InputStreamReaderPtr isr = new InputStreamReader(is);
+		LogString reply = isr->read(pool);
 
-          LOGUNIT_ASSERT_EQUAL(greeting, reply);
-        }
+		LOGUNIT_ASSERT_EQUAL(greeting, reply);
+	}
 
-        /**
-         *  Tests conversion of backslash containing file names.
-         *  Would cause infinite loop due to bug LOGCXX-105.
-         */
-        void deleteBackslashedFileName() {
-          File file("output\\bogus.txt");
-          Pool pool;
-          /*bool deleted = */file.deleteFile(pool);
-        }
+	/**
+	 *  Tests conversion of backslash containing file names.
+	 *  Would cause infinite loop due to bug LOGCXX-105.
+	 */
+	void deleteBackslashedFileName()
+	{
+		File file("output\\bogus.txt");
+		Pool pool;
+		/*bool deleted = */file.deleteFile(pool);
+	}
 };
 
 
diff --git a/src/test/cpp/filter/andfiltertest.cpp b/src/test/cpp/filter/andfiltertest.cpp
index aaee1cb..96defe4 100644
--- a/src/test/cpp/filter/andfiltertest.cpp
+++ b/src/test/cpp/filter/andfiltertest.cpp
@@ -14,7 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
- 
+
 #include <log4cxx/filter/andfilter.h>
 #include <log4cxx/logger.h>
 #include <log4cxx/spi/filter.h>
@@ -26,152 +26,159 @@
 
 using namespace log4cxx;
 using namespace log4cxx::filter;
-using namespace log4cxx::spi; 
+using namespace log4cxx::spi;
 using namespace log4cxx::helpers;
 
 
 /**
  * Unit tests for AndFilter.
  */
-LOGUNIT_CLASS(AndFilterTest) {
-    LOGUNIT_TEST_SUITE(AndFilterTest);
-       LOGUNIT_TEST(test1);
-       LOGUNIT_TEST(test2);
-       LOGUNIT_TEST(test3);
-       LOGUNIT_TEST(test4);
-       LOGUNIT_TEST(test5);
-       LOGUNIT_TEST(test6);
-    LOGUNIT_TEST_SUITE_END();
-    
+LOGUNIT_CLASS(AndFilterTest)
+{
+	LOGUNIT_TEST_SUITE(AndFilterTest);
+	LOGUNIT_TEST(test1);
+	LOGUNIT_TEST(test2);
+	LOGUNIT_TEST(test3);
+	LOGUNIT_TEST(test4);
+	LOGUNIT_TEST(test5);
+	LOGUNIT_TEST(test6);
+	LOGUNIT_TEST_SUITE_END();
+
 public:
-    
 
-    /**
-     * Check that AndFilter.decide() returns Filter.ACCEPT if no filters added.
-     */
-    void test1() {
-        LoggingEventPtr event(new LoggingEvent(
-                LOG4CXX_STR("org.apache.log4j.filter.AndFilterTest"),
-                Level::getInfo(), 
-                LOG4CXX_STR("Hello, World"), 
-                LOG4CXX_LOCATION));
-        FilterPtr filter(new AndFilter());
-        Pool p;
-        filter->activateOptions(p);
-        LOGUNIT_ASSERT_EQUAL(Filter::ACCEPT, filter->decide(event));
-    }
-    
-    /**
-     * Check that AndFilter.decide() returns Filter.ACCEPT if
-     *    only nested filter returns Filter.ACCEPT.
-     */
-    void test2() {
-        LoggingEventPtr event(new LoggingEvent(
-                LOG4CXX_STR("org.apache.log4j.filter.AndFilterTest"),
-                Level::getInfo(), 
-                LOG4CXX_STR("Hello, World"), 
-                LOG4CXX_LOCATION));
-        AndFilterPtr filter(new AndFilter());
-        LevelMatchFilterPtr filter1(new LevelMatchFilter());
-        filter1->setLevelToMatch(LOG4CXX_STR("info"));
-        Pool p;
-        filter1->activateOptions(p);
-        filter->addFilter(filter1);
-        filter->activateOptions(p);
-        LOGUNIT_ASSERT_EQUAL(Filter::ACCEPT, filter->decide(event));
-    }
 
-    /**
-     * Check that AndFilter.decide() returns Filter.ACCEPT if
-     *    two nested filters return Filter.ACCEPT.
-     */
-    void test3() {
-        LoggingEventPtr event(new LoggingEvent(
-                LOG4CXX_STR("org.apache.log4j.filter.AndFilterTest"),
-                Level::getInfo(), 
-                LOG4CXX_STR("Hello, World"), 
-                LOG4CXX_LOCATION));
-        AndFilterPtr filter(new AndFilter());
-        LevelMatchFilterPtr filter1(new LevelMatchFilter());
-        filter1->setLevelToMatch(LOG4CXX_STR("info"));
-        Pool p;
-        filter1->activateOptions(p);
-        filter->addFilter(filter1);
-        LevelMatchFilterPtr filter2(new LevelMatchFilter());
-        filter2->setLevelToMatch(LOG4CXX_STR("info"));
-        filter2->activateOptions(p);
-        filter->addFilter(filter2);
-        filter->activateOptions(p);
-        LOGUNIT_ASSERT_EQUAL(Filter::ACCEPT, filter->decide(event));
-    }
+	/**
+	 * Check that AndFilter.decide() returns Filter.ACCEPT if no filters added.
+	 */
+	void test1()
+	{
+		LoggingEventPtr event(new LoggingEvent(
+				LOG4CXX_STR("org.apache.log4j.filter.AndFilterTest"),
+				Level::getInfo(),
+				LOG4CXX_STR("Hello, World"),
+				LOG4CXX_LOCATION));
+		FilterPtr filter(new AndFilter());
+		Pool p;
+		filter->activateOptions(p);
+		LOGUNIT_ASSERT_EQUAL(Filter::ACCEPT, filter->decide(event));
+	}
 
-    /**
-     * Check that AndFilter.decide() returns Filter.DENY if
-     *    only nested filter returns Filter.ACCEPT
-     *    and acceptOnMatch is false.
-     */
-    void test4() {
-        LoggingEventPtr event(new LoggingEvent(
-                LOG4CXX_STR("org.apache.log4j.filter.AndFilterTest"),
-                Level::getInfo(), 
-                LOG4CXX_STR("Hello, World"), 
-                LOG4CXX_LOCATION));
-        AndFilterPtr filter(new AndFilter());
-        LevelMatchFilterPtr filter1(new LevelMatchFilter());
-        filter1->setLevelToMatch(LOG4CXX_STR("info"));
-        Pool p;
-        filter1->activateOptions(p);
-        filter->addFilter(filter1);
-        filter->setAcceptOnMatch(false);
-        filter->activateOptions(p);
-        LOGUNIT_ASSERT_EQUAL(Filter::DENY, filter->decide(event));
-    }
+	/**
+	 * Check that AndFilter.decide() returns Filter.ACCEPT if
+	 *    only nested filter returns Filter.ACCEPT.
+	 */
+	void test2()
+	{
+		LoggingEventPtr event(new LoggingEvent(
+				LOG4CXX_STR("org.apache.log4j.filter.AndFilterTest"),
+				Level::getInfo(),
+				LOG4CXX_STR("Hello, World"),
+				LOG4CXX_LOCATION));
+		AndFilterPtr filter(new AndFilter());
+		LevelMatchFilterPtr filter1(new LevelMatchFilter());
+		filter1->setLevelToMatch(LOG4CXX_STR("info"));
+		Pool p;
+		filter1->activateOptions(p);
+		filter->addFilter(filter1);
+		filter->activateOptions(p);
+		LOGUNIT_ASSERT_EQUAL(Filter::ACCEPT, filter->decide(event));
+	}
 
-    /**
-     * Check that AndFilter.decide() returns Filter.NEUTRAL if
-     *    nested filters return Filter.ACCEPT and Filter.DENY.
-     */
-    void test5() {
-        LoggingEventPtr event(new LoggingEvent(
-                LOG4CXX_STR("org.apache.log4j.filter.AndFilterTest"),
-                Level::getInfo(), 
-                LOG4CXX_STR("Hello, World"), 
-                LOG4CXX_LOCATION));
-        AndFilterPtr filter(new AndFilter());
-        LevelMatchFilterPtr filter1(new LevelMatchFilter());
-        filter1->setLevelToMatch(LOG4CXX_STR("info"));
-        Pool p;
-        filter1->activateOptions(p);
-        filter->addFilter(filter1);
-        FilterPtr filter2(new DenyAllFilter());
-        filter2->activateOptions(p);
-        filter->addFilter(filter2);
-        filter->activateOptions(p);
-        LOGUNIT_ASSERT_EQUAL(Filter::NEUTRAL, filter->decide(event));
-    }
+	/**
+	 * Check that AndFilter.decide() returns Filter.ACCEPT if
+	 *    two nested filters return Filter.ACCEPT.
+	 */
+	void test3()
+	{
+		LoggingEventPtr event(new LoggingEvent(
+				LOG4CXX_STR("org.apache.log4j.filter.AndFilterTest"),
+				Level::getInfo(),
+				LOG4CXX_STR("Hello, World"),
+				LOG4CXX_LOCATION));
+		AndFilterPtr filter(new AndFilter());
+		LevelMatchFilterPtr filter1(new LevelMatchFilter());
+		filter1->setLevelToMatch(LOG4CXX_STR("info"));
+		Pool p;
+		filter1->activateOptions(p);
+		filter->addFilter(filter1);
+		LevelMatchFilterPtr filter2(new LevelMatchFilter());
+		filter2->setLevelToMatch(LOG4CXX_STR("info"));
+		filter2->activateOptions(p);
+		filter->addFilter(filter2);
+		filter->activateOptions(p);
+		LOGUNIT_ASSERT_EQUAL(Filter::ACCEPT, filter->decide(event));
+	}
 
-    /**
-     * Check that AndFilter.decide() returns Filter.NEUTRAL if
-     *    nested filters return Filter.ACCEPT and Filter.NEUTRAL.
-     */
-    void test6() {
-        LoggingEventPtr event(new LoggingEvent(
-                LOG4CXX_STR("org.apache.log4j.filter.AndFilterTest"),
-                Level::getInfo(), 
-                LOG4CXX_STR("Hello, World"), 
-                LOG4CXX_LOCATION));
-        AndFilterPtr filter(new AndFilter());
-        LevelMatchFilterPtr filter1(new LevelMatchFilter());
-        filter1->setLevelToMatch(LOG4CXX_STR("info"));
-        Pool p;
-        filter1->activateOptions(p);
-        filter->addFilter(filter1);
-        FilterPtr filter2(new StringMatchFilter());
-        filter2->activateOptions(p);
-        filter->addFilter(filter2);
-        filter->activateOptions(p);
-        LOGUNIT_ASSERT_EQUAL(Filter::NEUTRAL, filter->decide(event));
-    }
+	/**
+	 * Check that AndFilter.decide() returns Filter.DENY if
+	 *    only nested filter returns Filter.ACCEPT
+	 *    and acceptOnMatch is false.
+	 */
+	void test4()
+	{
+		LoggingEventPtr event(new LoggingEvent(
+				LOG4CXX_STR("org.apache.log4j.filter.AndFilterTest"),
+				Level::getInfo(),
+				LOG4CXX_STR("Hello, World"),
+				LOG4CXX_LOCATION));
+		AndFilterPtr filter(new AndFilter());
+		LevelMatchFilterPtr filter1(new LevelMatchFilter());
+		filter1->setLevelToMatch(LOG4CXX_STR("info"));
+		Pool p;
+		filter1->activateOptions(p);
+		filter->addFilter(filter1);
+		filter->setAcceptOnMatch(false);
+		filter->activateOptions(p);
+		LOGUNIT_ASSERT_EQUAL(Filter::DENY, filter->decide(event));
+	}
+
+	/**
+	 * Check that AndFilter.decide() returns Filter.NEUTRAL if
+	 *    nested filters return Filter.ACCEPT and Filter.DENY.
+	 */
+	void test5()
+	{
+		LoggingEventPtr event(new LoggingEvent(
+				LOG4CXX_STR("org.apache.log4j.filter.AndFilterTest"),
+				Level::getInfo(),
+				LOG4CXX_STR("Hello, World"),
+				LOG4CXX_LOCATION));
+		AndFilterPtr filter(new AndFilter());
+		LevelMatchFilterPtr filter1(new LevelMatchFilter());
+		filter1->setLevelToMatch(LOG4CXX_STR("info"));
+		Pool p;
+		filter1->activateOptions(p);
+		filter->addFilter(filter1);
+		FilterPtr filter2(new DenyAllFilter());
+		filter2->activateOptions(p);
+		filter->addFilter(filter2);
+		filter->activateOptions(p);
+		LOGUNIT_ASSERT_EQUAL(Filter::NEUTRAL, filter->decide(event));
+	}
+
+	/**
+	 * Check that AndFilter.decide() returns Filter.NEUTRAL if
+	 *    nested filters return Filter.ACCEPT and Filter.NEUTRAL.
+	 */
+	void test6()
+	{
+		LoggingEventPtr event(new LoggingEvent(
+				LOG4CXX_STR("org.apache.log4j.filter.AndFilterTest"),
+				Level::getInfo(),
+				LOG4CXX_STR("Hello, World"),
+				LOG4CXX_LOCATION));
+		AndFilterPtr filter(new AndFilter());
+		LevelMatchFilterPtr filter1(new LevelMatchFilter());
+		filter1->setLevelToMatch(LOG4CXX_STR("info"));
+		Pool p;
+		filter1->activateOptions(p);
+		filter->addFilter(filter1);
+		FilterPtr filter2(new StringMatchFilter());
+		filter2->activateOptions(p);
+		filter->addFilter(filter2);
+		filter->activateOptions(p);
+		LOGUNIT_ASSERT_EQUAL(Filter::NEUTRAL, filter->decide(event));
+	}
 };
 
 
diff --git a/src/test/cpp/filter/denyallfiltertest.cpp b/src/test/cpp/filter/denyallfiltertest.cpp
index 785310f..1ff1f7b 100644
--- a/src/test/cpp/filter/denyallfiltertest.cpp
+++ b/src/test/cpp/filter/denyallfiltertest.cpp
@@ -22,33 +22,35 @@
 
 using namespace log4cxx;
 using namespace log4cxx::filter;
-using namespace log4cxx::spi; 
+using namespace log4cxx::spi;
 using namespace log4cxx::helpers;
 
 
 /**
  * Unit tests for DenyAllFilter.
  */
-LOGUNIT_CLASS(DenyAllFilterTest) {
-    LOGUNIT_TEST_SUITE(DenyAllFilterTest);
-       LOGUNIT_TEST(test1);
-    LOGUNIT_TEST_SUITE_END();
-
+LOGUNIT_CLASS(DenyAllFilterTest)
+{
+	LOGUNIT_TEST_SUITE(DenyAllFilterTest);
+	LOGUNIT_TEST(test1);
+	LOGUNIT_TEST_SUITE_END();
+
 public:
-    /**
-     * Check that DenyAllFilter.decide() returns Filter.DENY.
-     */
-    void test1() {
-        LoggingEventPtr event(new LoggingEvent(
-                LOG4CXX_STR("org.apache.log4j.filter.DenyAllFilterTest"),
-                Level::getInfo(), 
-                LOG4CXX_STR("Hello, World"), 
-                LOG4CXX_LOCATION));
-        FilterPtr filter(new DenyAllFilter());
-        Pool p;
-        filter->activateOptions(p);
-        LOGUNIT_ASSERT_EQUAL(Filter::DENY, filter->decide(event));
-    }
+	/**
+	 * Check that DenyAllFilter.decide() returns Filter.DENY.
+	 */
+	void test1()
+	{
+		LoggingEventPtr event(new LoggingEvent(
+				LOG4CXX_STR("org.apache.log4j.filter.DenyAllFilterTest"),
+				Level::getInfo(),
+				LOG4CXX_STR("Hello, World"),
+				LOG4CXX_LOCATION));
+		FilterPtr filter(new DenyAllFilter());
+		Pool p;
+		filter->activateOptions(p);
+		LOGUNIT_ASSERT_EQUAL(Filter::DENY, filter->decide(event));
+	}
 
 };
 
diff --git a/src/test/cpp/filter/levelmatchfiltertest.cpp b/src/test/cpp/filter/levelmatchfiltertest.cpp
index 6dfb685..3acbb8f 100644
--- a/src/test/cpp/filter/levelmatchfiltertest.cpp
+++ b/src/test/cpp/filter/levelmatchfiltertest.cpp
@@ -22,106 +22,112 @@
 
 using namespace log4cxx;
 using namespace log4cxx::filter;
-using namespace log4cxx::spi; 
+using namespace log4cxx::spi;
 using namespace log4cxx::helpers;
 
 
 /**
  * Unit tests for LevelMatchFilter.
  */
-LOGUNIT_CLASS(LevelMatchFilterTest) {
-    LOGUNIT_TEST_SUITE(LevelMatchFilterTest);
-       LOGUNIT_TEST(test1);
-       LOGUNIT_TEST(test2);
-       LOGUNIT_TEST(test3);
-       LOGUNIT_TEST(test4);
-       LOGUNIT_TEST(test5);
-    LOGUNIT_TEST_SUITE_END();
-    
+LOGUNIT_CLASS(LevelMatchFilterTest)
+{
+	LOGUNIT_TEST_SUITE(LevelMatchFilterTest);
+	LOGUNIT_TEST(test1);
+	LOGUNIT_TEST(test2);
+	LOGUNIT_TEST(test3);
+	LOGUNIT_TEST(test4);
+	LOGUNIT_TEST(test5);
+	LOGUNIT_TEST_SUITE_END();
+
 public:
-    /**
-     * Check that LevelMatchFilter.decide() returns Filter.ACCEPT when level matches.
-     */
-    void test1() {
-        LoggingEventPtr event(new LoggingEvent(
-                LOG4CXX_STR("org.apache.log4j.filter.LevelMatchFilterTest"),
-                Level::getInfo(), 
-                LOG4CXX_STR("Hello, World"), 
-                LOG4CXX_LOCATION));
-        LevelMatchFilterPtr filter(new LevelMatchFilter());
-        filter->setLevelToMatch(LOG4CXX_STR("info"));
-        Pool p;
-        filter->activateOptions(p);
-        LOGUNIT_ASSERT_EQUAL(Filter::ACCEPT, filter->decide(event));
-    }
+	/**
+	 * Check that LevelMatchFilter.decide() returns Filter.ACCEPT when level matches.
+	 */
+	void test1()
+	{
+		LoggingEventPtr event(new LoggingEvent(
+				LOG4CXX_STR("org.apache.log4j.filter.LevelMatchFilterTest"),
+				Level::getInfo(),
+				LOG4CXX_STR("Hello, World"),
+				LOG4CXX_LOCATION));
+		LevelMatchFilterPtr filter(new LevelMatchFilter());
+		filter->setLevelToMatch(LOG4CXX_STR("info"));
+		Pool p;
+		filter->activateOptions(p);
+		LOGUNIT_ASSERT_EQUAL(Filter::ACCEPT, filter->decide(event));
+	}
 
-    /**
-     * Check that LevelMatchFilter.decide() returns Filter.DENY
-     *    when level matches and acceptOnMatch = false.
-     */
-    void test2() {
-        LoggingEventPtr event(new LoggingEvent(
-                LOG4CXX_STR("org.apache.log4j.filter.LevelMatchFilterTest"),
-                Level::getInfo(), 
-                LOG4CXX_STR("Hello, World"), 
-                LOG4CXX_LOCATION));
-        LevelMatchFilterPtr filter(new LevelMatchFilter());
-        filter->setLevelToMatch(LOG4CXX_STR("info"));
-        filter->setAcceptOnMatch(false);
-        Pool p;
-        filter->activateOptions(p);
-        LOGUNIT_ASSERT_EQUAL(Filter::DENY, filter->decide(event));
-    }
+	/**
+	 * Check that LevelMatchFilter.decide() returns Filter.DENY
+	 *    when level matches and acceptOnMatch = false.
+	 */
+	void test2()
+	{
+		LoggingEventPtr event(new LoggingEvent(
+				LOG4CXX_STR("org.apache.log4j.filter.LevelMatchFilterTest"),
+				Level::getInfo(),
+				LOG4CXX_STR("Hello, World"),
+				LOG4CXX_LOCATION));
+		LevelMatchFilterPtr filter(new LevelMatchFilter());
+		filter->setLevelToMatch(LOG4CXX_STR("info"));
+		filter->setAcceptOnMatch(false);
+		Pool p;
+		filter->activateOptions(p);
+		LOGUNIT_ASSERT_EQUAL(Filter::DENY, filter->decide(event));
+	}
 
-    /**
-     * Check that LevelMatchFilter.decide() returns Filter.NEUTRAL
-     *    when levelToMatch is unspecified.
-     */
-    void test3() {
-        LoggingEventPtr event(new LoggingEvent(
-                LOG4CXX_STR("org.apache.log4j.filter.LevelMatchFilterTest"),
-                Level::getInfo(), 
-                LOG4CXX_STR("Hello, World"), 
-                LOG4CXX_LOCATION));
-        LevelMatchFilterPtr filter(new LevelMatchFilter());
-        Pool p;
-        filter->activateOptions(p);
-        LOGUNIT_ASSERT_EQUAL(Filter::NEUTRAL, filter->decide(event));
-    }
+	/**
+	 * Check that LevelMatchFilter.decide() returns Filter.NEUTRAL
+	 *    when levelToMatch is unspecified.
+	 */
+	void test3()
+	{
+		LoggingEventPtr event(new LoggingEvent(
+				LOG4CXX_STR("org.apache.log4j.filter.LevelMatchFilterTest"),
+				Level::getInfo(),
+				LOG4CXX_STR("Hello, World"),
+				LOG4CXX_LOCATION));
+		LevelMatchFilterPtr filter(new LevelMatchFilter());
+		Pool p;
+		filter->activateOptions(p);
+		LOGUNIT_ASSERT_EQUAL(Filter::NEUTRAL, filter->decide(event));
+	}
 
-    /**
-     * Check that LevelMatchFilter.decide() returns Filter.NEUTRAL
-     *    when event level is higher than level to match.
-     */
-    void test4() {
-        LoggingEventPtr event(new LoggingEvent(
-                LOG4CXX_STR("org.apache.log4j.filter.LevelMatchFilterTest"),
-                Level::getInfo(), 
-                LOG4CXX_STR("Hello, World"), 
-                LOG4CXX_LOCATION));
-        LevelMatchFilterPtr filter(new LevelMatchFilter());
-        filter->setLevelToMatch(LOG4CXX_STR("debug"));
-        Pool p;
-        filter->activateOptions(p);
-        LOGUNIT_ASSERT_EQUAL(Filter::NEUTRAL, filter->decide(event));
-    }
+	/**
+	 * Check that LevelMatchFilter.decide() returns Filter.NEUTRAL
+	 *    when event level is higher than level to match.
+	 */
+	void test4()
+	{
+		LoggingEventPtr event(new LoggingEvent(
+				LOG4CXX_STR("org.apache.log4j.filter.LevelMatchFilterTest"),
+				Level::getInfo(),
+				LOG4CXX_STR("Hello, World"),
+				LOG4CXX_LOCATION));
+		LevelMatchFilterPtr filter(new LevelMatchFilter());
+		filter->setLevelToMatch(LOG4CXX_STR("debug"));
+		Pool p;
+		filter->activateOptions(p);
+		LOGUNIT_ASSERT_EQUAL(Filter::NEUTRAL, filter->decide(event));
+	}
 
-    /**
-     * Check that LevelMatchFilter.decide() returns Filter.NEUTRAL
-     *    when event level is lower than level to match.
-     */
-    void test5() {
-        LoggingEventPtr event(new LoggingEvent(
-                LOG4CXX_STR("org.apache.log4j.filter.LevelMatchFilterTest"),
-                Level::getInfo(), 
-                LOG4CXX_STR("Hello, World"), 
-                LOG4CXX_LOCATION));
-        LevelMatchFilterPtr filter(new LevelMatchFilter());
-        filter->setLevelToMatch(LOG4CXX_STR("warn"));
-        Pool p;
-        filter->activateOptions(p);
-        LOGUNIT_ASSERT_EQUAL(Filter::NEUTRAL, filter->decide(event));
-    }
+	/**
+	 * Check that LevelMatchFilter.decide() returns Filter.NEUTRAL
+	 *    when event level is lower than level to match.
+	 */
+	void test5()
+	{
+		LoggingEventPtr event(new LoggingEvent(
+				LOG4CXX_STR("org.apache.log4j.filter.LevelMatchFilterTest"),
+				Level::getInfo(),
+				LOG4CXX_STR("Hello, World"),
+				LOG4CXX_LOCATION));
+		LevelMatchFilterPtr filter(new LevelMatchFilter());
+		filter->setLevelToMatch(LOG4CXX_STR("warn"));
+		Pool p;
+		filter->activateOptions(p);
+		LOGUNIT_ASSERT_EQUAL(Filter::NEUTRAL, filter->decide(event));
+	}
 };
 
 LOGUNIT_TEST_SUITE_REGISTRATION(LevelMatchFilterTest);
diff --git a/src/test/cpp/filter/levelrangefiltertest.cpp b/src/test/cpp/filter/levelrangefiltertest.cpp
index a5c413f..f0971f6 100644
--- a/src/test/cpp/filter/levelrangefiltertest.cpp
+++ b/src/test/cpp/filter/levelrangefiltertest.cpp
@@ -22,127 +22,134 @@
 
 using namespace log4cxx;
 using namespace log4cxx::filter;
-using namespace log4cxx::spi; 
+using namespace log4cxx::spi;
 using namespace log4cxx::helpers;
 
 
 /**
  * Unit tests for LevelRangeFilter.
  */
-LOGUNIT_CLASS(LevelRangeFilterTest) {
-    LOGUNIT_TEST_SUITE(LevelRangeFilterTest);
-       LOGUNIT_TEST(test1);
-       LOGUNIT_TEST(test2);
-       LOGUNIT_TEST(test3);
-       LOGUNIT_TEST(test4);
-       LOGUNIT_TEST(test5);
-       LOGUNIT_TEST(test6);
-    LOGUNIT_TEST_SUITE_END();
-    
+LOGUNIT_CLASS(LevelRangeFilterTest)
+{
+	LOGUNIT_TEST_SUITE(LevelRangeFilterTest);
+	LOGUNIT_TEST(test1);
+	LOGUNIT_TEST(test2);
+	LOGUNIT_TEST(test3);
+	LOGUNIT_TEST(test4);
+	LOGUNIT_TEST(test5);
+	LOGUNIT_TEST(test6);
+	LOGUNIT_TEST_SUITE_END();
+
 public:
-    /**
-     * Check that LevelRangefilter->decide() returns Filter::DENY
-     *     when event level is below min level.
-     */
-    void test1() {
-        LoggingEventPtr event(new LoggingEvent(
-                LOG4CXX_STR("org.apache.log4j.Filter::LevelRangeFilterTest"),
-                Level::getInfo(), 
-                LOG4CXX_STR("Hello, World"), 
-                LOG4CXX_LOCATION));
-        LevelRangeFilterPtr filter(new LevelRangeFilter());
-        filter->setLevelMin(Level::getWarn());
-        Pool p;
-        filter->activateOptions(p);
-        LOGUNIT_ASSERT_EQUAL(Filter::DENY, filter->decide(event));
-    }
+	/**
+	 * Check that LevelRangefilter->decide() returns Filter::DENY
+	 *     when event level is below min level.
+	 */
+	void test1()
+	{
+		LoggingEventPtr event(new LoggingEvent(
+				LOG4CXX_STR("org.apache.log4j.Filter::LevelRangeFilterTest"),
+				Level::getInfo(),
+				LOG4CXX_STR("Hello, World"),
+				LOG4CXX_LOCATION));
+		LevelRangeFilterPtr filter(new LevelRangeFilter());
+		filter->setLevelMin(Level::getWarn());
+		Pool p;
+		filter->activateOptions(p);
+		LOGUNIT_ASSERT_EQUAL(Filter::DENY, filter->decide(event));
+	}
 
-    /**
-     * Check that LevelRangefilter->decide() returns Filter::DENY
-     *    when event level is above max level.
-     */
-    void test2() {
-        LoggingEventPtr event(new LoggingEvent(
-                LOG4CXX_STR("org.apache.log4j.Filter::LevelRangeFilterTest"),
-                Level::getInfo(), 
-                LOG4CXX_STR("Hello, World"), 
-                LOG4CXX_LOCATION));
-        LevelRangeFilterPtr filter(new LevelRangeFilter());
-        filter->setLevelMax(Level::getDebug());
-        Pool p;
-        filter->activateOptions(p);
-        LOGUNIT_ASSERT_EQUAL(Filter::DENY, filter->decide(event));
-    }
+	/**
+	 * Check that LevelRangefilter->decide() returns Filter::DENY
+	 *    when event level is above max level.
+	 */
+	void test2()
+	{
+		LoggingEventPtr event(new LoggingEvent(
+				LOG4CXX_STR("org.apache.log4j.Filter::LevelRangeFilterTest"),
+				Level::getInfo(),
+				LOG4CXX_STR("Hello, World"),
+				LOG4CXX_LOCATION));
+		LevelRangeFilterPtr filter(new LevelRangeFilter());
+		filter->setLevelMax(Level::getDebug());
+		Pool p;
+		filter->activateOptions(p);
+		LOGUNIT_ASSERT_EQUAL(Filter::DENY, filter->decide(event));
+	}
 
-    /**
-     * Check that LevelRangefilter->decide() returns Filter::ACCEPT
-     *    when event level is above min level.
-     */
-    void test3() {
-        LoggingEventPtr event(new LoggingEvent(
-                LOG4CXX_STR("org.apache.log4j.Filter::LevelRangeFilterTest"),
-                Level::getInfo(), 
-                LOG4CXX_STR("Hello, World"), 
-                LOG4CXX_LOCATION));
-        LevelRangeFilterPtr filter(new LevelRangeFilter());
-        filter->setLevelMin(Level::getDebug());
-        filter->setAcceptOnMatch(true);
-        Pool p;
-        filter->activateOptions(p);
-        LOGUNIT_ASSERT_EQUAL(Filter::ACCEPT, filter->decide(event));
-    }
+	/**
+	 * Check that LevelRangefilter->decide() returns Filter::ACCEPT
+	 *    when event level is above min level.
+	 */
+	void test3()
+	{
+		LoggingEventPtr event(new LoggingEvent(
+				LOG4CXX_STR("org.apache.log4j.Filter::LevelRangeFilterTest"),
+				Level::getInfo(),
+				LOG4CXX_STR("Hello, World"),
+				LOG4CXX_LOCATION));
+		LevelRangeFilterPtr filter(new LevelRangeFilter());
+		filter->setLevelMin(Level::getDebug());
+		filter->setAcceptOnMatch(true);
+		Pool p;
+		filter->activateOptions(p);
+		LOGUNIT_ASSERT_EQUAL(Filter::ACCEPT, filter->decide(event));
+	}
 
-    /**
-     * Check that LevelRangefilter->decide() returns Filter::ACCEPT
-     *    when event level is below max level.
-     */
-    void test4() {
-        LoggingEventPtr event(new LoggingEvent(
-                LOG4CXX_STR("org.apache.log4j.Filter::LevelRangeFilterTest"),
-                Level::getInfo(), 
-                LOG4CXX_STR("Hello, World"), 
-                LOG4CXX_LOCATION));
-        LevelRangeFilterPtr filter(new LevelRangeFilter());
-        filter->setLevelMax(Level::getError());
-        filter->setAcceptOnMatch(true);
-        Pool p;
-        filter->activateOptions(p);
-        LOGUNIT_ASSERT_EQUAL(Filter::ACCEPT, filter->decide(event));
-    }
+	/**
+	 * Check that LevelRangefilter->decide() returns Filter::ACCEPT
+	 *    when event level is below max level.
+	 */
+	void test4()
+	{
+		LoggingEventPtr event(new LoggingEvent(
+				LOG4CXX_STR("org.apache.log4j.Filter::LevelRangeFilterTest"),
+				Level::getInfo(),
+				LOG4CXX_STR("Hello, World"),
+				LOG4CXX_LOCATION));
+		LevelRangeFilterPtr filter(new LevelRangeFilter());
+		filter->setLevelMax(Level::getError());
+		filter->setAcceptOnMatch(true);
+		Pool p;
+		filter->activateOptions(p);
+		LOGUNIT_ASSERT_EQUAL(Filter::ACCEPT, filter->decide(event));
+	}
 
-    /**
-     * Check that LevelRangeFilter::decide() returns Filter::NEUTRAL
-     *    when event level is above min level and accept on match is false.
-     */
-    void test5() {
-        LoggingEventPtr event(new LoggingEvent(
-                LOG4CXX_STR("org.apache.log4j.Filter::LevelRangeFilterTest"),
-                Level::getInfo(), 
-                LOG4CXX_STR("Hello, World"), 
-                LOG4CXX_LOCATION));
-        LevelRangeFilterPtr filter(new LevelRangeFilter());
-        filter->setLevelMin(Level::getDebug());
-        Pool p;
-        filter->activateOptions(p);
-        LOGUNIT_ASSERT_EQUAL(Filter::NEUTRAL, filter->decide(event));
-    }
+	/**
+	 * Check that LevelRangeFilter::decide() returns Filter::NEUTRAL
+	 *    when event level is above min level and accept on match is false.
+	 */
+	void test5()
+	{
+		LoggingEventPtr event(new LoggingEvent(
+				LOG4CXX_STR("org.apache.log4j.Filter::LevelRangeFilterTest"),
+				Level::getInfo(),
+				LOG4CXX_STR("Hello, World"),
+				LOG4CXX_LOCATION));
+		LevelRangeFilterPtr filter(new LevelRangeFilter());
+		filter->setLevelMin(Level::getDebug());
+		Pool p;
+		filter->activateOptions(p);
+		LOGUNIT_ASSERT_EQUAL(Filter::NEUTRAL, filter->decide(event));
+	}
 
-    /**
-     * Check that LevelRangeFilter::decide() returns Filter::NEUTRAL
-     *    when event level is below max level and accept on match is false.
-     */
-    void test6() {
-        LoggingEventPtr event(new LoggingEvent(
-                LOG4CXX_STR("org.apache.log4j.Filter::LevelRangeFilterTest"),
-                Level::getInfo(), 
-                LOG4CXX_STR("Hello, World"), 
-                LOG4CXX_LOCATION));
-        LevelRangeFilterPtr filter(new LevelRangeFilter());
-        filter->setLevelMax(Level::getError());
-        Pool p;
-        filter->activateOptions(p);
-        LOGUNIT_ASSERT_EQUAL(Filter::NEUTRAL, filter->decide(event));
-    }
+	/**
+	 * Check that LevelRangeFilter::decide() returns Filter::NEUTRAL
+	 *    when event level is below max level and accept on match is false.
+	 */
+	void test6()
+	{
+		LoggingEventPtr event(new LoggingEvent(
+				LOG4CXX_STR("org.apache.log4j.Filter::LevelRangeFilterTest"),
+				Level::getInfo(),
+				LOG4CXX_STR("Hello, World"),
+				LOG4CXX_LOCATION));
+		LevelRangeFilterPtr filter(new LevelRangeFilter());
+		filter->setLevelMax(Level::getError());
+		Pool p;
+		filter->activateOptions(p);
+		LOGUNIT_ASSERT_EQUAL(Filter::NEUTRAL, filter->decide(event));
+	}
 };
 
 LOGUNIT_TEST_SUITE_REGISTRATION(LevelRangeFilterTest);
diff --git a/src/test/cpp/filter/loggermatchfiltertest.cpp b/src/test/cpp/filter/loggermatchfiltertest.cpp
index 03d7768..88adb06 100644
--- a/src/test/cpp/filter/loggermatchfiltertest.cpp
+++ b/src/test/cpp/filter/loggermatchfiltertest.cpp
@@ -22,87 +22,92 @@
 
 using namespace log4cxx;
 using namespace log4cxx::filter;
-using namespace log4cxx::spi; 
+using namespace log4cxx::spi;
 using namespace log4cxx::helpers;
 
 
 /**
  * Unit tests for LoggerMatchFilter.
  */
-LOGUNIT_CLASS(LoggerMatchFilterTest) {
-    LOGUNIT_TEST_SUITE(LoggerMatchFilterTest);
-       LOGUNIT_TEST(test1);
-       LOGUNIT_TEST(test2);
-       LOGUNIT_TEST(test3);
-       LOGUNIT_TEST(test4);
-    LOGUNIT_TEST_SUITE_END();
-    
+LOGUNIT_CLASS(LoggerMatchFilterTest)
+{
+	LOGUNIT_TEST_SUITE(LoggerMatchFilterTest);
+	LOGUNIT_TEST(test1);
+	LOGUNIT_TEST(test2);
+	LOGUNIT_TEST(test3);
+	LOGUNIT_TEST(test4);
+	LOGUNIT_TEST_SUITE_END();
+
 public:
-    /**
-     * Check that LoggerMatchFilter::decide() with unspecified level
-     *    returns Filter::ACCEPT for root logger.
-     */
-    void test1() {
-        LoggingEventPtr event(new LoggingEvent(
-                LOG4CXX_STR("root"),
-                Level::getInfo(), 
-                LOG4CXX_STR("Hello, World"), 
-                LOG4CXX_LOCATION));
-        FilterPtr filter(new LoggerMatchFilter());
-        Pool p; 
-        filter->activateOptions(p);
-        LOGUNIT_ASSERT_EQUAL(Filter::ACCEPT, filter->decide(event));
-    }
+	/**
+	 * Check that LoggerMatchFilter::decide() with unspecified level
+	 *    returns Filter::ACCEPT for root logger.
+	 */
+	void test1()
+	{
+		LoggingEventPtr event(new LoggingEvent(
+				LOG4CXX_STR("root"),
+				Level::getInfo(),
+				LOG4CXX_STR("Hello, World"),
+				LOG4CXX_LOCATION));
+		FilterPtr filter(new LoggerMatchFilter());
+		Pool p;
+		filter->activateOptions(p);
+		LOGUNIT_ASSERT_EQUAL(Filter::ACCEPT, filter->decide(event));
+	}
 
-    /**
-     * Check that LoggerMatchFilter::decide() with unspecified level
-     *    returns Filter::DENY for root logger when accept on match is false.
-     */
-    void test2() {
-        LoggingEventPtr event(new LoggingEvent(
-                LOG4CXX_STR("root"),
-                Level::getInfo(), 
-                LOG4CXX_STR("Hello, World"), 
-                LOG4CXX_LOCATION));
-        LoggerMatchFilterPtr filter(new LoggerMatchFilter());
-        filter->setAcceptOnMatch(false);
-        Pool p; 
-        filter->activateOptions(p);
-        LOGUNIT_ASSERT_EQUAL(Filter::DENY, filter->decide(event));
-    }
+	/**
+	 * Check that LoggerMatchFilter::decide() with unspecified level
+	 *    returns Filter::DENY for root logger when accept on match is false.
+	 */
+	void test2()
+	{
+		LoggingEventPtr event(new LoggingEvent(
+				LOG4CXX_STR("root"),
+				Level::getInfo(),
+				LOG4CXX_STR("Hello, World"),
+				LOG4CXX_LOCATION));
+		LoggerMatchFilterPtr filter(new LoggerMatchFilter());
+		filter->setAcceptOnMatch(false);
+		Pool p;
+		filter->activateOptions(p);
+		LOGUNIT_ASSERT_EQUAL(Filter::DENY, filter->decide(event));
+	}
 
-    /**
-     * Check that LoggerMatchFilter::decide() with unspecified level
-     *    returns Filter::NEUTRAL for non-root logger.
-     */
-    void test3() {
-        LoggingEventPtr event(new LoggingEvent(
-                LOG4CXX_STR("org.apache.log4j.filter.LoggerMatchFilterTest"),
-                Level::getInfo(), 
-                LOG4CXX_STR("Hello, World"), 
-                LOG4CXX_LOCATION));
-        FilterPtr filter(new LoggerMatchFilter());
-        Pool p; 
-        filter->activateOptions(p);
-        LOGUNIT_ASSERT_EQUAL(Filter::NEUTRAL, filter->decide(event));
-    }
+	/**
+	 * Check that LoggerMatchFilter::decide() with unspecified level
+	 *    returns Filter::NEUTRAL for non-root logger.
+	 */
+	void test3()
+	{
+		LoggingEventPtr event(new LoggingEvent(
+				LOG4CXX_STR("org.apache.log4j.filter.LoggerMatchFilterTest"),
+				Level::getInfo(),
+				LOG4CXX_STR("Hello, World"),
+				LOG4CXX_LOCATION));
+		FilterPtr filter(new LoggerMatchFilter());
+		Pool p;
+		filter->activateOptions(p);
+		LOGUNIT_ASSERT_EQUAL(Filter::NEUTRAL, filter->decide(event));
+	}
 
-    /**
-     * Check that LoggerMatchFilter::decide()
-     *    returns Filter::ACCEPT for matching logger.
-     */
-    void test4() {
-        LoggingEventPtr event(new LoggingEvent(
-                LOG4CXX_STR("org.apache.log4j.filter.LoggerMatchFilterTest"),
-                Level::getInfo(), 
-                LOG4CXX_STR("Hello, World"), 
-                LOG4CXX_LOCATION));
-        LoggerMatchFilterPtr filter(new LoggerMatchFilter());
-        filter->setLoggerToMatch(LOG4CXX_STR("org.apache.log4j.filter.LoggerMatchFilterTest"));
-        Pool p; 
-        filter->activateOptions(p);
-        LOGUNIT_ASSERT_EQUAL(Filter::ACCEPT, filter->decide(event));
-    }
+	/**
+	 * Check that LoggerMatchFilter::decide()
+	 *    returns Filter::ACCEPT for matching logger.
+	 */
+	void test4()
+	{
+		LoggingEventPtr event(new LoggingEvent(
+				LOG4CXX_STR("org.apache.log4j.filter.LoggerMatchFilterTest"),
+				Level::getInfo(),
+				LOG4CXX_STR("Hello, World"),
+				LOG4CXX_LOCATION));
+		LoggerMatchFilterPtr filter(new LoggerMatchFilter());
+		filter->setLoggerToMatch(LOG4CXX_STR("org.apache.log4j.filter.LoggerMatchFilterTest"));
+		Pool p;
+		filter->activateOptions(p);
+		LOGUNIT_ASSERT_EQUAL(Filter::ACCEPT, filter->decide(event));
+	}
 
 };
 
diff --git a/src/test/cpp/filter/stringmatchfiltertest.cpp b/src/test/cpp/filter/stringmatchfiltertest.cpp
index e3a81f5..131d0ed 100644
--- a/src/test/cpp/filter/stringmatchfiltertest.cpp
+++ b/src/test/cpp/filter/stringmatchfiltertest.cpp
@@ -22,108 +22,114 @@
 
 using namespace log4cxx;
 using namespace log4cxx::filter;
-using namespace log4cxx::spi; 
+using namespace log4cxx::spi;
 using namespace log4cxx::helpers;
 
 
 /**
  * Unit tests for StringMatchFilter.
  */
-LOGUNIT_CLASS(StringMatchFilterTest) {
-    LOGUNIT_TEST_SUITE(StringMatchFilterTest);
-       LOGUNIT_TEST(test1);
-       LOGUNIT_TEST(test2);
-       LOGUNIT_TEST(test3);
-       LOGUNIT_TEST(test4);
-    LOGUNIT_TEST_SUITE_END();
-    
+LOGUNIT_CLASS(StringMatchFilterTest)
+{
+	LOGUNIT_TEST_SUITE(StringMatchFilterTest);
+	LOGUNIT_TEST(test1);
+	LOGUNIT_TEST(test2);
+	LOGUNIT_TEST(test3);
+	LOGUNIT_TEST(test4);
+	LOGUNIT_TEST_SUITE_END();
+
 public:
 
-    /**
-     * Check that StringMatchFilter.decide() returns Filter.NEUTRAL
-     *   when string to match is unspecified.
-     */
-    void test1() {
-        LoggingEventPtr event(new LoggingEvent(
-                LOG4CXX_STR("org.apache.log4j.filter.StringMatchFilterTest"),
-                Level::getInfo(), 
-                LOG4CXX_STR("Hello, World"), 
-                LOG4CXX_LOCATION));
-        FilterPtr filter(new StringMatchFilter());
-        Pool p; 
-        filter->activateOptions(p);
-        LOGUNIT_ASSERT_EQUAL(Filter::NEUTRAL, filter->decide(event));
-    }
+	/**
+	 * Check that StringMatchFilter.decide() returns Filter.NEUTRAL
+	 *   when string to match is unspecified.
+	 */
+	void test1()
+	{
+		LoggingEventPtr event(new LoggingEvent(
+				LOG4CXX_STR("org.apache.log4j.filter.StringMatchFilterTest"),
+				Level::getInfo(),
+				LOG4CXX_STR("Hello, World"),
+				LOG4CXX_LOCATION));
+		FilterPtr filter(new StringMatchFilter());
+		Pool p;
+		filter->activateOptions(p);
+		LOGUNIT_ASSERT_EQUAL(Filter::NEUTRAL, filter->decide(event));
+	}
 
-    /**
-     * Check that StringMatchFilter.decide() returns Filter.NEUTRAL
-     *   when string to match does not appear in message.
-     */
-    void test2() {
-        LoggingEventPtr event(new LoggingEvent(
-                LOG4CXX_STR("org.apache.log4j.filter.StringMatchFilterTest"),
-                Level::getInfo(), 
-                LOG4CXX_STR("Hello, World"), 
-                LOG4CXX_LOCATION));
-        StringMatchFilterPtr filter(new StringMatchFilter());
-        filter->setStringToMatch(LOG4CXX_STR("Monde"));
-        Pool p; 
-        filter->activateOptions(p);
-        LOGUNIT_ASSERT_EQUAL(Filter::NEUTRAL, filter->decide(event));
-    }
+	/**
+	 * Check that StringMatchFilter.decide() returns Filter.NEUTRAL
+	 *   when string to match does not appear in message.
+	 */
+	void test2()
+	{
+		LoggingEventPtr event(new LoggingEvent(
+				LOG4CXX_STR("org.apache.log4j.filter.StringMatchFilterTest"),
+				Level::getInfo(),
+				LOG4CXX_STR("Hello, World"),
+				LOG4CXX_LOCATION));
+		StringMatchFilterPtr filter(new StringMatchFilter());
+		filter->setStringToMatch(LOG4CXX_STR("Monde"));
+		Pool p;
+		filter->activateOptions(p);
+		LOGUNIT_ASSERT_EQUAL(Filter::NEUTRAL, filter->decide(event));
+	}
 
-    /**
-     * Check that StringMatchFilter.decide() returns Filter.ACCEPT
-     *   when string to match does appear in message.
-     */
-    void test3() {
-        LoggingEventPtr event(new LoggingEvent(
-                LOG4CXX_STR("org.apache.log4j.filter.StringMatchFilterTest"),
-                Level::getInfo(), 
-                LOG4CXX_STR("Hello, World"), 
-                LOG4CXX_LOCATION));
-        StringMatchFilterPtr filter(new StringMatchFilter());
-        filter->setStringToMatch(LOG4CXX_STR("World"));
-        Pool p; 
-        filter->activateOptions(p);
-        LOGUNIT_ASSERT_EQUAL(Filter::ACCEPT, filter->decide(event));
-    }
+	/**
+	 * Check that StringMatchFilter.decide() returns Filter.ACCEPT
+	 *   when string to match does appear in message.
+	 */
+	void test3()
+	{
+		LoggingEventPtr event(new LoggingEvent(
+				LOG4CXX_STR("org.apache.log4j.filter.StringMatchFilterTest"),
+				Level::getInfo(),
+				LOG4CXX_STR("Hello, World"),
+				LOG4CXX_LOCATION));
+		StringMatchFilterPtr filter(new StringMatchFilter());
+		filter->setStringToMatch(LOG4CXX_STR("World"));
+		Pool p;
+		filter->activateOptions(p);
+		LOGUNIT_ASSERT_EQUAL(Filter::ACCEPT, filter->decide(event));
+	}
 
-    /**
-     * Check that StringMatchFilter.decide() returns Filter.DENY
-     *   when string to match does appear in message and
-     *   accept on match is false.
-     */
-    void test4() {
-        LoggingEventPtr event(new LoggingEvent(
-                LOG4CXX_STR("org.apache.log4j.filter.StringMatchFilterTest"),
-                Level::getInfo(), 
-                LOG4CXX_STR("Hello, World"), 
-                LOG4CXX_LOCATION));
-        StringMatchFilterPtr filter(new StringMatchFilter());
-        filter->setStringToMatch(LOG4CXX_STR("World"));
-        filter->setAcceptOnMatch(false);
-        Pool p; 
-        filter->activateOptions(p);
-        LOGUNIT_ASSERT_EQUAL(Filter::DENY, filter->decide(event));
-    }
+	/**
+	 * Check that StringMatchFilter.decide() returns Filter.DENY
+	 *   when string to match does appear in message and
+	 *   accept on match is false.
+	 */
+	void test4()
+	{
+		LoggingEventPtr event(new LoggingEvent(
+				LOG4CXX_STR("org.apache.log4j.filter.StringMatchFilterTest"),
+				Level::getInfo(),
+				LOG4CXX_STR("Hello, World"),
+				LOG4CXX_LOCATION));
+		StringMatchFilterPtr filter(new StringMatchFilter());
+		filter->setStringToMatch(LOG4CXX_STR("World"));
+		filter->setAcceptOnMatch(false);
+		Pool p;
+		filter->activateOptions(p);
+		LOGUNIT_ASSERT_EQUAL(Filter::DENY, filter->decide(event));
+	}
 
-    /**
-     * Check that StringMatchFilter.decide() returns Filter.NEUTRAL
-     *   when string to match does appear in message but differs in case.
-     */
-    void test5() {
-        LoggingEventPtr event(new LoggingEvent(
-                LOG4CXX_STR("org.apache.log4j.filter.StringMatchFilterTest"),
-                Level::getInfo(), 
-                LOG4CXX_STR("Hello, World"), 
-                LOG4CXX_LOCATION));
-        StringMatchFilterPtr filter(new StringMatchFilter());
-        filter->setStringToMatch(LOG4CXX_STR("world"));
-        Pool p; 
-        filter->activateOptions(p);
-        LOGUNIT_ASSERT_EQUAL(Filter::NEUTRAL, filter->decide(event));
-    }
+	/**
+	 * Check that StringMatchFilter.decide() returns Filter.NEUTRAL
+	 *   when string to match does appear in message but differs in case.
+	 */
+	void test5()
+	{
+		LoggingEventPtr event(new LoggingEvent(
+				LOG4CXX_STR("org.apache.log4j.filter.StringMatchFilterTest"),
+				Level::getInfo(),
+				LOG4CXX_STR("Hello, World"),
+				LOG4CXX_LOCATION));
+		StringMatchFilterPtr filter(new StringMatchFilter());
+		filter->setStringToMatch(LOG4CXX_STR("world"));
+		Pool p;
+		filter->activateOptions(p);
+		LOGUNIT_ASSERT_EQUAL(Filter::NEUTRAL, filter->decide(event));
+	}
 
 };
 
diff --git a/src/test/cpp/helpers/absolutetimedateformattestcase.cpp b/src/test/cpp/helpers/absolutetimedateformattestcase.cpp
index 8f19117..d88b0a5 100644
--- a/src/test/cpp/helpers/absolutetimedateformattestcase.cpp
+++ b/src/test/cpp/helpers/absolutetimedateformattestcase.cpp
@@ -14,7 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "../logunit.h" 
+#include "../logunit.h"
 #include <log4cxx/logstring.h>
 #include <log4cxx/helpers/absolutetimedateformat.h>
 #include "../insertwide.h"
@@ -24,7 +24,7 @@
 
 //Define INT64_C for compilers that don't have it
 #if (!defined(INT64_C))
-#define INT64_C(value)  value ## LL
+	#define INT64_C(value)  value ## LL
 #endif
 
 
@@ -35,143 +35,153 @@
 
 /**
    Unit test {@link AbsoluteTimeDateFormat}.
-   
-   */
-LOGUNIT_CLASS(AbsoluteTimeDateFormatTestCase) {
-  LOGUNIT_TEST_SUITE(AbsoluteTimeDateFormatTestCase);
-          LOGUNIT_TEST(test1);
-          LOGUNIT_TEST(test2);
-          LOGUNIT_TEST(test3);
-          LOGUNIT_TEST(test4);
-          LOGUNIT_TEST(test5);
-          LOGUNIT_TEST(test6);
-          LOGUNIT_TEST(test7);
-          LOGUNIT_TEST(test8);
-  LOGUNIT_TEST_SUITE_END();
 
-  public:
-
-  /**
-   * Asserts that formatting the provided date results
-   * in the expected string.
-   *
-   * @param date Date date
-   * @param timeZone TimeZone timezone for conversion
-   * @param expected String expected string
    */
-  private:
-  void assertFormattedTime(apr_time_t date,
-                           const TimeZonePtr& timeZone,
-                           const LogString& expected) {
-    AbsoluteTimeDateFormat formatter;
-    formatter.setTimeZone(timeZone);
-    LogString actual;
-    Pool p;
-    formatter.format(actual, date, p);
-    LOGUNIT_ASSERT_EQUAL(expected, actual);
-  }
+LOGUNIT_CLASS(AbsoluteTimeDateFormatTestCase)
+{
+	LOGUNIT_TEST_SUITE(AbsoluteTimeDateFormatTestCase);
+	LOGUNIT_TEST(test1);
+	LOGUNIT_TEST(test2);
+	LOGUNIT_TEST(test3);
+	LOGUNIT_TEST(test4);
+	LOGUNIT_TEST(test5);
+	LOGUNIT_TEST(test6);
+	LOGUNIT_TEST(test7);
+	LOGUNIT_TEST(test8);
+	LOGUNIT_TEST_SUITE_END();
+
+public:
+
+	/**
+	 * Asserts that formatting the provided date results
+	 * in the expected string.
+	 *
+	 * @param date Date date
+	 * @param timeZone TimeZone timezone for conversion
+	 * @param expected String expected string
+	 */
+private:
+	void assertFormattedTime(apr_time_t date,
+		const TimeZonePtr & timeZone,
+		const LogString & expected)
+	{
+		AbsoluteTimeDateFormat formatter;
+		formatter.setTimeZone(timeZone);
+		LogString actual;
+		Pool p;
+		formatter.format(actual, date, p);
+		LOGUNIT_ASSERT_EQUAL(expected, actual);
+	}
 
 #define MICROSECONDS_PER_DAY APR_INT64_C(86400000000)
 
-  public:
-  /**
-   * Convert 02 Jan 2004 00:00:00 GMT for GMT.
-   */
-  void test1() {
-    //
-    //   02 Jan 2004 00:00 GMT
-    //
-    apr_time_t jan2 = MICROSECONDS_PER_DAY * 12419;
-    assertFormattedTime(jan2, TimeZone::getGMT(), LOG4CXX_STR("00:00:00,000"));
-  }
+public:
+	/**
+	 * Convert 02 Jan 2004 00:00:00 GMT for GMT.
+	 */
+	void test1()
+	{
+		//
+		//   02 Jan 2004 00:00 GMT
+		//
+		apr_time_t jan2 = MICROSECONDS_PER_DAY * 12419;
+		assertFormattedTime(jan2, TimeZone::getGMT(), LOG4CXX_STR("00:00:00,000"));
+	}
 
-  /**
-   * Convert 03 Jan 2004 00:00:00 GMT for America/Chicago.
-   */
-  void test2() {
-    //
-    //   03 Jan 2004 00:00 GMT
-    //       (asking for the same time at a different timezone
-    //          will ignore the change of timezone)
-    apr_time_t jan2 = MICROSECONDS_PER_DAY * 12420;
-    assertFormattedTime(jan2, TimeZone::getTimeZone(LOG4CXX_STR("GMT-6")), LOG4CXX_STR("18:00:00,000"));
-  }
+	/**
+	 * Convert 03 Jan 2004 00:00:00 GMT for America/Chicago.
+	 */
+	void test2()
+	{
+		//
+		//   03 Jan 2004 00:00 GMT
+		//       (asking for the same time at a different timezone
+		//          will ignore the change of timezone)
+		apr_time_t jan2 = MICROSECONDS_PER_DAY * 12420;
+		assertFormattedTime(jan2, TimeZone::getTimeZone(LOG4CXX_STR("GMT-6")), LOG4CXX_STR("18:00:00,000"));
+	}
 
-  /**
-   * Convert 29 Jun 2004 00:00:00 GMT for GMT.
-   */
-  void test3() {
-    apr_time_t jun29 = MICROSECONDS_PER_DAY * 12599;
-    assertFormattedTime(jun29, TimeZone::getGMT(), LOG4CXX_STR("00:00:00,000"));
-  }
+	/**
+	 * Convert 29 Jun 2004 00:00:00 GMT for GMT.
+	 */
+	void test3()
+	{
+		apr_time_t jun29 = MICROSECONDS_PER_DAY * 12599;
+		assertFormattedTime(jun29, TimeZone::getGMT(), LOG4CXX_STR("00:00:00,000"));
+	}
 
-  /**
-   * Convert 29 Jun 2004 00:00:00 GMT for Chicago, daylight savings in effect.
-   */
-  void test4() {
-    apr_time_t jun30 = MICROSECONDS_PER_DAY * 12600;
-    //
-    //   log4cxx doesn't support non-fixed timezones at this time
-    //      passing the fixed equivalent to Chicago's Daylight Savings Time
-    //
-    assertFormattedTime(jun30, TimeZone::getTimeZone(LOG4CXX_STR("GMT-5")), LOG4CXX_STR("19:00:00,000"));
-  }
+	/**
+	 * Convert 29 Jun 2004 00:00:00 GMT for Chicago, daylight savings in effect.
+	 */
+	void test4()
+	{
+		apr_time_t jun30 = MICROSECONDS_PER_DAY * 12600;
+		//
+		//   log4cxx doesn't support non-fixed timezones at this time
+		//      passing the fixed equivalent to Chicago's Daylight Savings Time
+		//
+		assertFormattedTime(jun30, TimeZone::getTimeZone(LOG4CXX_STR("GMT-5")), LOG4CXX_STR("19:00:00,000"));
+	}
 
-  /**
-   * Test multiple calls in close intervals.
-   */
-  void test5() {
-    //   subsequent calls within one minute
-    //     are optimized to reuse previous formatted value
-    //     make a couple of nearly spaced calls
-    apr_time_t ticks = MICROSECONDS_PER_DAY * 12601;
-    assertFormattedTime(ticks, TimeZone::getGMT(), LOG4CXX_STR("00:00:00,000"));
-    assertFormattedTime(ticks + 8000, TimeZone::getGMT(), LOG4CXX_STR("00:00:00,008"));
-    assertFormattedTime(ticks + 17000, TimeZone::getGMT(), LOG4CXX_STR("00:00:00,017"));
-    assertFormattedTime(ticks + 237000, TimeZone::getGMT(), LOG4CXX_STR("00:00:00,237"));
-    assertFormattedTime(ticks + 1415000, TimeZone::getGMT(), LOG4CXX_STR("00:00:01,415"));
-  }
+	/**
+	 * Test multiple calls in close intervals.
+	 */
+	void test5()
+	{
+		//   subsequent calls within one minute
+		//     are optimized to reuse previous formatted value
+		//     make a couple of nearly spaced calls
+		apr_time_t ticks = MICROSECONDS_PER_DAY * 12601;
+		assertFormattedTime(ticks, TimeZone::getGMT(), LOG4CXX_STR("00:00:00,000"));
+		assertFormattedTime(ticks + 8000, TimeZone::getGMT(), LOG4CXX_STR("00:00:00,008"));
+		assertFormattedTime(ticks + 17000, TimeZone::getGMT(), LOG4CXX_STR("00:00:00,017"));
+		assertFormattedTime(ticks + 237000, TimeZone::getGMT(), LOG4CXX_STR("00:00:00,237"));
+		assertFormattedTime(ticks + 1415000, TimeZone::getGMT(), LOG4CXX_STR("00:00:01,415"));
+	}
 
-  /**
-   *  Check that caching does not disregard timezone.
-   * This test would fail for revision 1.4 of AbsoluteTimeDateFormat.java.
-   */
-  void test6() {
-    apr_time_t jul2 = MICROSECONDS_PER_DAY * 12602;
-    assertFormattedTime(jul2, TimeZone::getGMT(), LOG4CXX_STR("00:00:00,000"));
-    assertFormattedTime(jul2, TimeZone::getTimeZone(LOG4CXX_STR("GMT-5")), LOG4CXX_STR("19:00:00,000"));
-  }
+	/**
+	 *  Check that caching does not disregard timezone.
+	 * This test would fail for revision 1.4 of AbsoluteTimeDateFormat.java.
+	 */
+	void test6()
+	{
+		apr_time_t jul2 = MICROSECONDS_PER_DAY * 12602;
+		assertFormattedTime(jul2, TimeZone::getGMT(), LOG4CXX_STR("00:00:00,000"));
+		assertFormattedTime(jul2, TimeZone::getTimeZone(LOG4CXX_STR("GMT-5")), LOG4CXX_STR("19:00:00,000"));
+	}
 
-  /**
-   * Test multiple calls in close intervals predating 1 Jan 1970.
-   */
-  void test7() {
-    //   subsequent calls within one minute
-    //     are optimized to reuse previous formatted value
-    //     make a couple of nearly spaced calls
-    apr_time_t ticks = MICROSECONDS_PER_DAY * -7;
-    assertFormattedTime(ticks, TimeZone::getGMT(), LOG4CXX_STR("00:00:00,000"));
+	/**
+	 * Test multiple calls in close intervals predating 1 Jan 1970.
+	 */
+	void test7()
+	{
+		//   subsequent calls within one minute
+		//     are optimized to reuse previous formatted value
+		//     make a couple of nearly spaced calls
+		apr_time_t ticks = MICROSECONDS_PER_DAY * -7;
+		assertFormattedTime(ticks, TimeZone::getGMT(), LOG4CXX_STR("00:00:00,000"));
 #if defined(_WIN32)
-    //
-    //   These tests fail on Unix due to bug in APR's explode_time
-    //
-//    assertFormattedTime(ticks + 8000, TimeZone::getGMT(), LOG4CXX_STR("00:00:00,008"));
-//    assertFormattedTime(ticks + 17000, TimeZone::getGMT(), LOG4CXX_STR("00:00:00,017"));
-//    assertFormattedTime(ticks + 237000, TimeZone::getGMT(), LOG4CXX_STR("00:00:00,237"));
-//    assertFormattedTime(ticks + 1415000, TimeZone::getGMT(), LOG4CXX_STR("00:00:01,415"));
+		//
+		//   These tests fail on Unix due to bug in APR's explode_time
+		//
+		//    assertFormattedTime(ticks + 8000, TimeZone::getGMT(), LOG4CXX_STR("00:00:00,008"));
+		//    assertFormattedTime(ticks + 17000, TimeZone::getGMT(), LOG4CXX_STR("00:00:00,017"));
+		//    assertFormattedTime(ticks + 237000, TimeZone::getGMT(), LOG4CXX_STR("00:00:00,237"));
+		//    assertFormattedTime(ticks + 1415000, TimeZone::getGMT(), LOG4CXX_STR("00:00:01,415"));
 #endif
-  }
+	}
 
-  /**
-   * Checks that numberFormat works as expected.
-   */
-  void test8() {
-    Pool p;
-    LogString numb;
-    AbsoluteTimeDateFormat formatter;
-    formatter.numberFormat(numb, 87, p);
-    LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("87"), numb);
-  }
+	/**
+	 * Checks that numberFormat works as expected.
+	 */
+	void test8()
+	{
+		Pool p;
+		LogString numb;
+		AbsoluteTimeDateFormat formatter;
+		formatter.numberFormat(numb, 87, p);
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("87"), numb);
+	}
 
 };
 
diff --git a/src/test/cpp/helpers/cacheddateformattestcase.cpp b/src/test/cpp/helpers/cacheddateformattestcase.cpp
index 74d180e..d29ff51 100644
--- a/src/test/cpp/helpers/cacheddateformattestcase.cpp
+++ b/src/test/cpp/helpers/cacheddateformattestcase.cpp
@@ -33,15 +33,15 @@
 
 #define LOCALE_US "C"
 #if defined(_WIN32)
-#define LOCALE_JP "Japanese_japan"
+	#define LOCALE_JP "Japanese_japan"
 #else
-#define LOCALE_JP "ja_JP"
+	#define LOCALE_JP "ja_JP"
 #endif
 
 
 //Define INT64_C for compilers that don't have it
 #if (!defined(INT64_C))
-#define INT64_C(value)  value ##LL
+	#define INT64_C(value)  value ##LL
 #endif
 
 #define LOG4CXX_TEST 1
@@ -52,625 +52,649 @@
  * Unit test {@link CachedDateFormat}.
  */
 LOGUNIT_CLASS(CachedDateFormatTestCase)
-   {
-     LOGUNIT_TEST_SUITE( CachedDateFormatTestCase );
-     LOGUNIT_TEST(test1);
-     LOGUNIT_TEST(test2);
-     LOGUNIT_TEST(test3);
-     LOGUNIT_TEST(test4);
+{
+	LOGUNIT_TEST_SUITE( CachedDateFormatTestCase );
+	LOGUNIT_TEST(test1);
+	LOGUNIT_TEST(test2);
+	LOGUNIT_TEST(test3);
+	LOGUNIT_TEST(test4);
 #if LOG4CXX_HAS_STD_LOCALE
-     LOGUNIT_TEST(test5);
+	LOGUNIT_TEST(test5);
 #endif
-     LOGUNIT_TEST(test6);
-     LOGUNIT_TEST(test8);
-//   Gump doesn't like this test
-//     LOGUNIT_TEST(test9);
-     LOGUNIT_TEST(test10);
-     LOGUNIT_TEST(test11);
-     LOGUNIT_TEST(test12);
-     LOGUNIT_TEST(test13);
-     LOGUNIT_TEST(test14);
-     LOGUNIT_TEST(test15);
-     LOGUNIT_TEST(test16);
-     LOGUNIT_TEST(test17);
-     LOGUNIT_TEST(test18);
-     LOGUNIT_TEST(test19);
-     LOGUNIT_TEST(test20);
-     LOGUNIT_TEST(test21);
-     LOGUNIT_TEST(test22);
-     LOGUNIT_TEST_SUITE_END();
+	LOGUNIT_TEST(test6);
+	LOGUNIT_TEST(test8);
+	//   Gump doesn't like this test
+	//     LOGUNIT_TEST(test9);
+	LOGUNIT_TEST(test10);
+	LOGUNIT_TEST(test11);
+	LOGUNIT_TEST(test12);
+	LOGUNIT_TEST(test13);
+	LOGUNIT_TEST(test14);
+	LOGUNIT_TEST(test15);
+	LOGUNIT_TEST(test16);
+	LOGUNIT_TEST(test17);
+	LOGUNIT_TEST(test18);
+	LOGUNIT_TEST(test19);
+	LOGUNIT_TEST(test20);
+	LOGUNIT_TEST(test21);
+	LOGUNIT_TEST(test22);
+	LOGUNIT_TEST_SUITE_END();
 
 #define MICROSECONDS_PER_DAY APR_INT64_C(86400000000)
 
-   public:
+public:
 
-  /**
-   * Test multiple calls in close intervals.
-   */
-  void test1() {
-    //   subsequent calls within one minute
-    //     are optimized to reuse previous formatted value
-    //     make a couple of nearly spaced calls
-    DateFormatPtr baseFormatter(new AbsoluteTimeDateFormat());
-    CachedDateFormat gmtFormat(baseFormatter, 1000000);
-    gmtFormat.setTimeZone(TimeZone::getGMT());
+	/**
+	 * Test multiple calls in close intervals.
+	 */
+	void test1()
+	{
+		//   subsequent calls within one minute
+		//     are optimized to reuse previous formatted value
+		//     make a couple of nearly spaced calls
+		DateFormatPtr baseFormatter(new AbsoluteTimeDateFormat());
+		CachedDateFormat gmtFormat(baseFormatter, 1000000);
+		gmtFormat.setTimeZone(TimeZone::getGMT());
 
-    apr_time_t jul1 = MICROSECONDS_PER_DAY * 12601L;
-    Pool p;
+		apr_time_t jul1 = MICROSECONDS_PER_DAY * 12601L;
+		Pool p;
 
-    LogString actual;
+		LogString actual;
 
-    gmtFormat.format(actual, jul1, p);
-    LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("00:00:00,000"), actual);
-    actual.erase(actual.begin(), actual.end());
+		gmtFormat.format(actual, jul1, p);
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("00:00:00,000"), actual);
+		actual.erase(actual.begin(), actual.end());
 
-    gmtFormat.format(actual, jul1 + 8000, p);
-    LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("00:00:00,008"), actual);
-    actual.erase(actual.begin(), actual.end());
+		gmtFormat.format(actual, jul1 + 8000, p);
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("00:00:00,008"), actual);
+		actual.erase(actual.begin(), actual.end());
 
-    gmtFormat.format(actual, jul1 + 17000, p);
-    LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("00:00:00,017"), actual);
-    actual.erase(actual.begin(), actual.end());
+		gmtFormat.format(actual, jul1 + 17000, p);
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("00:00:00,017"), actual);
+		actual.erase(actual.begin(), actual.end());
 
-    gmtFormat.format(actual, jul1 + 237000, p);
-    LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("00:00:00,237"), actual);
-    actual.erase(actual.begin(), actual.end());
+		gmtFormat.format(actual, jul1 + 237000, p);
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("00:00:00,237"), actual);
+		actual.erase(actual.begin(), actual.end());
 
-    gmtFormat.format(actual, jul1 + 1415000, p);
-    LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("00:00:01,415"), actual);
-    actual.erase(actual.begin(), actual.end());
+		gmtFormat.format(actual, jul1 + 1415000, p);
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("00:00:01,415"), actual);
+		actual.erase(actual.begin(), actual.end());
 
-  }
+	}
 
-  /**
-   *  Check for interaction between caches.
-   */
+	/**
+	 *  Check for interaction between caches.
+	 */
 
-  void test2() {
-      apr_time_t jul2 = MICROSECONDS_PER_DAY * 12602;
-      DateFormatPtr baseFormatter(new AbsoluteTimeDateFormat());
-      CachedDateFormat gmtFormat(baseFormatter, 1000000);
-      gmtFormat.setTimeZone(TimeZone::getGMT());
+	void test2()
+	{
+		apr_time_t jul2 = MICROSECONDS_PER_DAY * 12602;
+		DateFormatPtr baseFormatter(new AbsoluteTimeDateFormat());
+		CachedDateFormat gmtFormat(baseFormatter, 1000000);
+		gmtFormat.setTimeZone(TimeZone::getGMT());
 
-     DateFormatPtr chicagoBase(new AbsoluteTimeDateFormat());
-     CachedDateFormat chicagoFormat(chicagoBase, 1000000);
-     chicagoFormat.setTimeZone(TimeZone::getTimeZone(LOG4CXX_STR("GMT-5")));
+		DateFormatPtr chicagoBase(new AbsoluteTimeDateFormat());
+		CachedDateFormat chicagoFormat(chicagoBase, 1000000);
+		chicagoFormat.setTimeZone(TimeZone::getTimeZone(LOG4CXX_STR("GMT-5")));
 
-     Pool p;
-     LogString actual;
-     gmtFormat.format(actual, jul2, p);
-     LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("00:00:00,000"), actual);
+		Pool p;
+		LogString actual;
+		gmtFormat.format(actual, jul2, p);
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("00:00:00,000"), actual);
 
-     actual.erase(actual.begin(), actual.end());
-     chicagoFormat.format(actual, jul2, p);
-     LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("19:00:00,000"), actual);
+		actual.erase(actual.begin(), actual.end());
+		chicagoFormat.format(actual, jul2, p);
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("19:00:00,000"), actual);
 
-     actual.erase(actual.begin(), actual.end());
-     gmtFormat.format(actual, jul2, p);
-     LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("00:00:00,000"), actual);
-  }
+		actual.erase(actual.begin(), actual.end());
+		gmtFormat.format(actual, jul2, p);
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("00:00:00,000"), actual);
+	}
 
-  /**
-   * Test multiple calls in close intervals prior to 1 Jan 1970.
-   */
-  void test3() {
-    //   subsequent calls within one minute
-    //     are optimized to reuse previous formatted value
-    //     make a couple of nearly spaced calls
-    DateFormatPtr baseFormatter(new AbsoluteTimeDateFormat());
-    CachedDateFormat gmtFormat(baseFormatter, 1000000);
-    gmtFormat.setTimeZone(TimeZone::getGMT());
+	/**
+	 * Test multiple calls in close intervals prior to 1 Jan 1970.
+	 */
+	void test3()
+	{
+		//   subsequent calls within one minute
+		//     are optimized to reuse previous formatted value
+		//     make a couple of nearly spaced calls
+		DateFormatPtr baseFormatter(new AbsoluteTimeDateFormat());
+		CachedDateFormat gmtFormat(baseFormatter, 1000000);
+		gmtFormat.setTimeZone(TimeZone::getGMT());
 
-    apr_time_t ticks = MICROSECONDS_PER_DAY * -7;
+		apr_time_t ticks = MICROSECONDS_PER_DAY * -7;
 
-    Pool p;
+		Pool p;
 
-    LogString actual;
+		LogString actual;
 
 
-    gmtFormat.format(actual, ticks, p);
-    LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("00:00:00,000"), actual);
-    actual.erase(actual.begin(), actual.end());
+		gmtFormat.format(actual, ticks, p);
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("00:00:00,000"), actual);
+		actual.erase(actual.begin(), actual.end());
 
-   //
-   //   APR's explode_time method does not properly calculate tm_usec
-   //     prior to 1 Jan 1970 on Unix
-   gmtFormat.format(actual, ticks + 8000, p);
-   LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("00:00:00,008"), actual);
-   actual.erase(actual.begin(), actual.end());
+		//
+		//   APR's explode_time method does not properly calculate tm_usec
+		//     prior to 1 Jan 1970 on Unix
+		gmtFormat.format(actual, ticks + 8000, p);
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("00:00:00,008"), actual);
+		actual.erase(actual.begin(), actual.end());
 
-   gmtFormat.format(actual, ticks + 17000, p);
-   LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("00:00:00,017"), actual);
-   actual.erase(actual.begin(), actual.end());
+		gmtFormat.format(actual, ticks + 17000, p);
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("00:00:00,017"), actual);
+		actual.erase(actual.begin(), actual.end());
 
-    gmtFormat.format(actual, ticks + 237000, p);
-    LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("00:00:00,237"), actual);
-    actual.erase(actual.begin(), actual.end());
+		gmtFormat.format(actual, ticks + 237000, p);
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("00:00:00,237"), actual);
+		actual.erase(actual.begin(), actual.end());
 
-    gmtFormat.format(actual, ticks + 1423000, p);
-    LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("00:00:01,423"), actual);
-  }
+		gmtFormat.format(actual, ticks + 1423000, p);
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("00:00:01,423"), actual);
+	}
 
-  void assertFormattedEquals(
-      const DateFormatPtr& baseFormat,
-      const CachedDateFormat& cachedFormat,
-      apr_time_t date,
-      Pool& p) {
-        LogString expected;
-        LogString actual;
+	void assertFormattedEquals(
+		const DateFormatPtr & baseFormat,
+		const CachedDateFormat & cachedFormat,
+		apr_time_t date,
+		Pool & p)
+	{
+		LogString expected;
+		LogString actual;
 
-        baseFormat->format(expected, date, p);
-        cachedFormat.format(actual, date, p);
+		baseFormat->format(expected, date, p);
+		cachedFormat.format(actual, date, p);
 
 
-        LOGUNIT_ASSERT_EQUAL(expected, actual);
-  }
+		LOGUNIT_ASSERT_EQUAL(expected, actual);
+	}
 
-  void test4() {
-    //   subsequent calls within one minute
-    //     are optimized to reuse previous formatted value
-    //     make a couple of nearly spaced calls
+	void test4()
+	{
+		//   subsequent calls within one minute
+		//     are optimized to reuse previous formatted value
+		//     make a couple of nearly spaced calls
 #if LOG4CXX_HAS_STD_LOCALE
-    std::locale loco(LOCALE_US);
-    std::locale* localeEN = &loco;
+		std::locale loco(LOCALE_US);
+		std::locale* localeEN = &loco;
 #else
-    std::locale* localeEN = NULL;
+		std::locale* localeEN = NULL;
 #endif
-    DateFormatPtr baseFormat(
-         new SimpleDateFormat(LOG4CXX_STR("EEE, MMM dd, HH:mm:ss.SSS Z"), localeEN));
-    CachedDateFormat cachedFormat(baseFormat, 1000000);
-    //
-    //   use a date in 2000 to attempt to confuse the millisecond locator
-    apr_time_t ticks = MICROSECONDS_PER_DAY * 11141;
+		DateFormatPtr baseFormat(
+			new SimpleDateFormat(LOG4CXX_STR("EEE, MMM dd, HH:mm:ss.SSS Z"), localeEN));
+		CachedDateFormat cachedFormat(baseFormat, 1000000);
+		//
+		//   use a date in 2000 to attempt to confuse the millisecond locator
+		apr_time_t ticks = MICROSECONDS_PER_DAY * 11141;
 
-    Pool p;
+		Pool p;
 
-    assertFormattedEquals(baseFormat, cachedFormat, ticks, p);
-    assertFormattedEquals(baseFormat, cachedFormat, ticks + 8000, p);
-    assertFormattedEquals(baseFormat, cachedFormat, ticks + 17000, p);
-    assertFormattedEquals(baseFormat, cachedFormat, ticks + 237000, p);
-    assertFormattedEquals(baseFormat, cachedFormat, ticks + 1415000, p);
-  }
+		assertFormattedEquals(baseFormat, cachedFormat, ticks, p);
+		assertFormattedEquals(baseFormat, cachedFormat, ticks + 8000, p);
+		assertFormattedEquals(baseFormat, cachedFormat, ticks + 17000, p);
+		assertFormattedEquals(baseFormat, cachedFormat, ticks + 237000, p);
+		assertFormattedEquals(baseFormat, cachedFormat, ticks + 1415000, p);
+	}
 
 
 #if LOG4CXX_HAS_STD_LOCALE
-  void test5() {
-    //   subsequent calls within one minute
-    //     are optimized to reuse previous formatted value
-    //     make a couple of nearly spaced calls
-    LocaleChanger localeChange(LOCALE_JP);
-    if (localeChange.isEffective()) {
-        DateFormatPtr baseFormat(new SimpleDateFormat(
-                   LOG4CXX_STR("EEE, MMM dd, HH:mm:ss.SSS Z")));
-        CachedDateFormat cachedFormat(baseFormat, 1000000);
-        //
-        //   use a date in 2000 to attempt to confuse the millisecond locator
-        apr_time_t ticks = MICROSECONDS_PER_DAY * 11141;
+	void test5()
+	{
+		//   subsequent calls within one minute
+		//     are optimized to reuse previous formatted value
+		//     make a couple of nearly spaced calls
+		LocaleChanger localeChange(LOCALE_JP);
 
-        Pool p;
+		if (localeChange.isEffective())
+		{
+			DateFormatPtr baseFormat(new SimpleDateFormat(
+					LOG4CXX_STR("EEE, MMM dd, HH:mm:ss.SSS Z")));
+			CachedDateFormat cachedFormat(baseFormat, 1000000);
+			//
+			//   use a date in 2000 to attempt to confuse the millisecond locator
+			apr_time_t ticks = MICROSECONDS_PER_DAY * 11141;
 
-        assertFormattedEquals(baseFormat, cachedFormat, ticks, p);
-        assertFormattedEquals(baseFormat, cachedFormat, ticks + 8000, p);
-        assertFormattedEquals(baseFormat, cachedFormat, ticks + 17000, p);
-        assertFormattedEquals(baseFormat, cachedFormat, ticks + 237000, p);
-        assertFormattedEquals(baseFormat, cachedFormat, ticks + 1415000, p);
-    }
-  }
+			Pool p;
+
+			assertFormattedEquals(baseFormat, cachedFormat, ticks, p);
+			assertFormattedEquals(baseFormat, cachedFormat, ticks + 8000, p);
+			assertFormattedEquals(baseFormat, cachedFormat, ticks + 17000, p);
+			assertFormattedEquals(baseFormat, cachedFormat, ticks + 237000, p);
+			assertFormattedEquals(baseFormat, cachedFormat, ticks + 1415000, p);
+		}
+	}
 #endif
 
-  /**
-   * Checks that numberFormat works as expected.
-   */
-  void test6() {
-    LogString numb;
-    Pool p;
-    AbsoluteTimeDateFormat formatter;
-    formatter.numberFormat(numb, 87, p);
-    LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("87"), numb);
-  }
+	/**
+	 * Checks that numberFormat works as expected.
+	 */
+	void test6()
+	{
+		LogString numb;
+		Pool p;
+		AbsoluteTimeDateFormat formatter;
+		formatter.numberFormat(numb, 87, p);
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("87"), numb);
+	}
 
 
-  /**
-   * Set time zone on cached and check that it is effective.
-   */
-  void test8() {
-    DateFormatPtr baseFormat(new SimpleDateFormat(LOG4CXX_STR("yyyy-MM-dd HH:mm:ss,SSS")));
-    baseFormat->setTimeZone(TimeZone::getGMT());
-    CachedDateFormat cachedFormat(baseFormat, 1000000);
-    apr_time_t jul4 = MICROSECONDS_PER_DAY * 12603;
+	/**
+	 * Set time zone on cached and check that it is effective.
+	 */
+	void test8()
+	{
+		DateFormatPtr baseFormat(new SimpleDateFormat(LOG4CXX_STR("yyyy-MM-dd HH:mm:ss,SSS")));
+		baseFormat->setTimeZone(TimeZone::getGMT());
+		CachedDateFormat cachedFormat(baseFormat, 1000000);
+		apr_time_t jul4 = MICROSECONDS_PER_DAY * 12603;
 
-    Pool p;
+		Pool p;
 
-    LogString actual;
-    cachedFormat.format(actual, jul4, p);
-    LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("2004-07-04 00:00:00,000"), actual);
+		LogString actual;
+		cachedFormat.format(actual, jul4, p);
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("2004-07-04 00:00:00,000"), actual);
 
-    cachedFormat.setTimeZone(TimeZone::getTimeZone(LOG4CXX_STR("GMT-6")));
-    actual.erase(actual.begin(), actual.end());
-    cachedFormat.format(actual, jul4, p);
+		cachedFormat.setTimeZone(TimeZone::getTimeZone(LOG4CXX_STR("GMT-6")));
+		actual.erase(actual.begin(), actual.end());
+		cachedFormat.format(actual, jul4, p);
 
-    LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("2004-07-03 18:00:00,000"), actual);
-  }
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("2004-07-03 18:00:00,000"), actual);
+	}
 
 
-/**
- * Test of caching when less than three millisecond digits are specified.
- */
-void test9() {
-  std::locale localeUS(LOCALE_US);
+	/**
+	 * Test of caching when less than three millisecond digits are specified.
+	 */
+	void test9()
+	{
+		std::locale localeUS(LOCALE_US);
 
-  DateFormatPtr baseFormat = new SimpleDateFormat(
-      LOG4CXX_STR("yyyy-MMMM-dd HH:mm:ss,SS Z"), &localeUS);
-  DateFormatPtr cachedFormat = new CachedDateFormat(baseFormat, 1000000);
-  TimeZonePtr cet = TimeZone::getTimeZone(LOG4CXX_STR("GMT+1"));
-  cachedFormat->setTimeZone(cet);
+		DateFormatPtr baseFormat = new SimpleDateFormat(
+			LOG4CXX_STR("yyyy-MMMM-dd HH:mm:ss,SS Z"), &localeUS);
+		DateFormatPtr cachedFormat = new CachedDateFormat(baseFormat, 1000000);
+		TimeZonePtr cet = TimeZone::getTimeZone(LOG4CXX_STR("GMT+1"));
+		cachedFormat->setTimeZone(cet);
 
 
-   apr_time_exp_t c;
-   memset(&c, 0, sizeof(c));
-   c.tm_year = 104;
-   c.tm_mon = 11;
-   c.tm_mday = 12;
-   c.tm_hour = 19;
-   c.tm_sec = 37;
-   c.tm_usec = 23000;
+		apr_time_exp_t c;
+		memset(&c, 0, sizeof(c));
+		c.tm_year = 104;
+		c.tm_mon = 11;
+		c.tm_mday = 12;
+		c.tm_hour = 19;
+		c.tm_sec = 37;
+		c.tm_usec = 23000;
 
-   apr_time_t dec12;
-   apr_status_t stat = apr_time_exp_gmt_get(&dec12, &c);
-   const apr_status_t statOK = 0;
-   LOGUNIT_ASSERT_EQUAL(statOK, stat);
+		apr_time_t dec12;
+		apr_status_t stat = apr_time_exp_gmt_get(&dec12, &c);
+		const apr_status_t statOK = 0;
+		LOGUNIT_ASSERT_EQUAL(statOK, stat);
 
-   Pool p;
+		Pool p;
 
-   LogString s;
-   cachedFormat->format(s, dec12, p);
+		LogString s;
+		cachedFormat->format(s, dec12, p);
 
-   LOGUNIT_ASSERT_EQUAL(
-       (LogString) LOG4CXX_STR("2004-December-12 20:00:37,23 +0100"), s);
+		LOGUNIT_ASSERT_EQUAL(
+			(LogString) LOG4CXX_STR("2004-December-12 20:00:37,23 +0100"), s);
 
-    memset(&c, 0, sizeof(c));
-    c.tm_year = 104;
-    c.tm_mon = 11;
-    c.tm_mday = 31;
-    c.tm_hour = 23;
-    c.tm_sec = 13;
-    c.tm_usec = 905000;
+		memset(&c, 0, sizeof(c));
+		c.tm_year = 104;
+		c.tm_mon = 11;
+		c.tm_mday = 31;
+		c.tm_hour = 23;
+		c.tm_sec = 13;
+		c.tm_usec = 905000;
 
-    apr_time_t jan1;
-    stat = apr_time_exp_gmt_get(&jan1, &c);
-    LOGUNIT_ASSERT_EQUAL(statOK, stat);
+		apr_time_t jan1;
+		stat = apr_time_exp_gmt_get(&jan1, &c);
+		LOGUNIT_ASSERT_EQUAL(statOK, stat);
 
-    s.erase(s.begin(), s.end());
-    cachedFormat->format(s, jan1, p);
+		s.erase(s.begin(), s.end());
+		cachedFormat->format(s, jan1, p);
 
-    LOGUNIT_ASSERT_EQUAL(
-       (LogString) LOG4CXX_STR("2005-January-01 00:00:13,905 +0100"), s);
-}
+		LOGUNIT_ASSERT_EQUAL(
+			(LogString) LOG4CXX_STR("2005-January-01 00:00:13,905 +0100"), s);
+	}
 
 
-/**
- * Test when millisecond position moves but length remains constant.
- */
-void test10() {
+	/**
+	 * Test when millisecond position moves but length remains constant.
+	 */
+	void test10()
+	{
 #if LOG4CXX_HAS_STD_LOCALE
-  std::locale loco("C");
-  std::locale* localeUS = &loco;
+		std::locale loco("C");
+		std::locale* localeUS = &loco;
 #else
-  std::locale* localeUS = NULL;
+		std::locale* localeUS = NULL;
 #endif
-  DateFormatPtr baseFormat = new SimpleDateFormat(
-      LOG4CXX_STR("MMMM SSS EEEEEE"), localeUS);
-  DateFormatPtr cachedFormat = new CachedDateFormat(baseFormat, 1000000);
-  TimeZonePtr cet = TimeZone::getTimeZone(LOG4CXX_STR("GMT+1"));
-  cachedFormat->setTimeZone(cet);
+		DateFormatPtr baseFormat = new SimpleDateFormat(
+			LOG4CXX_STR("MMMM SSS EEEEEE"), localeUS);
+		DateFormatPtr cachedFormat = new CachedDateFormat(baseFormat, 1000000);
+		TimeZonePtr cet = TimeZone::getTimeZone(LOG4CXX_STR("GMT+1"));
+		cachedFormat->setTimeZone(cet);
 
-  apr_time_exp_t c;
-  memset(&c, 0, sizeof(c));
-  c.tm_year = 104;
-  c.tm_mon = 9;
-  c.tm_mday = 5;
-  c.tm_hour = 21;
-  c.tm_sec = 37;
-  c.tm_usec = 23000;
+		apr_time_exp_t c;
+		memset(&c, 0, sizeof(c));
+		c.tm_year = 104;
+		c.tm_mon = 9;
+		c.tm_mday = 5;
+		c.tm_hour = 21;
+		c.tm_sec = 37;
+		c.tm_usec = 23000;
 
-  apr_time_t oct5;
-  apr_status_t stat = apr_time_exp_gmt_get(&oct5, &c);
-  const apr_status_t statOK = 0;
-  LOGUNIT_ASSERT_EQUAL(statOK, stat);
+		apr_time_t oct5;
+		apr_status_t stat = apr_time_exp_gmt_get(&oct5, &c);
+		const apr_status_t statOK = 0;
+		LOGUNIT_ASSERT_EQUAL(statOK, stat);
 
-  Pool p;
+		Pool p;
 
-  LogString s;
-  cachedFormat->format(s, oct5, p);
+		LogString s;
+		cachedFormat->format(s, oct5, p);
 
-  LOGUNIT_ASSERT_EQUAL(
-    (LogString) LOG4CXX_STR("October 023 Tuesday"), s);
+		LOGUNIT_ASSERT_EQUAL(
+			(LogString) LOG4CXX_STR("October 023 Tuesday"), s);
 
-  memset(&c, 0, sizeof(c));
-  c.tm_year = 104;
-  c.tm_mon = 10;
-  c.tm_mday = 1;
-  c.tm_usec = 23000;
+		memset(&c, 0, sizeof(c));
+		c.tm_year = 104;
+		c.tm_mon = 10;
+		c.tm_mday = 1;
+		c.tm_usec = 23000;
 
-  apr_time_t nov1;
-  stat = apr_time_exp_gmt_get(&nov1, &c);
-  LOGUNIT_ASSERT_EQUAL(statOK, stat);
+		apr_time_t nov1;
+		stat = apr_time_exp_gmt_get(&nov1, &c);
+		LOGUNIT_ASSERT_EQUAL(statOK, stat);
 
-  s.erase(s.begin(), s.end());
-  cachedFormat->format(s, nov1, p);
+		s.erase(s.begin(), s.end());
+		cachedFormat->format(s, nov1, p);
 
-  LOGUNIT_ASSERT_EQUAL(
-     (LogString) LOG4CXX_STR("November 023 Monday"), s);
+		LOGUNIT_ASSERT_EQUAL(
+			(LogString) LOG4CXX_STR("November 023 Monday"), s);
 
-   nov1 += 961000;
-   s.erase(s.begin(), s.end());
-   cachedFormat->format(s, nov1, p);
+		nov1 += 961000;
+		s.erase(s.begin(), s.end());
+		cachedFormat->format(s, nov1, p);
 
-   LOGUNIT_ASSERT_EQUAL(
-      (LogString) LOG4CXX_STR("November 984 Monday"), s);
-}
+		LOGUNIT_ASSERT_EQUAL(
+			(LogString) LOG4CXX_STR("November 984 Monday"), s);
+	}
 
-/**
- * Test that tests if caching is skipped if only "SS"
- *     is specified.
- */
-void test11() {
-   //
-   //   Earlier versions could be tricked by "SS0" patterns.
-   //
-   LogString badPattern(LOG4CXX_STR("ss,SS0"));
-   DateFormatPtr simpleFormat = new SimpleDateFormat(badPattern);
-   DateFormatPtr gmtFormat = new CachedDateFormat(simpleFormat, 1000000);
-   gmtFormat->setTimeZone(TimeZone::getGMT());
+	/**
+	 * Test that tests if caching is skipped if only "SS"
+	 *     is specified.
+	 */
+	void test11()
+	{
+		//
+		//   Earlier versions could be tricked by "SS0" patterns.
+		//
+		LogString badPattern(LOG4CXX_STR("ss,SS0"));
+		DateFormatPtr simpleFormat = new SimpleDateFormat(badPattern);
+		DateFormatPtr gmtFormat = new CachedDateFormat(simpleFormat, 1000000);
+		gmtFormat->setTimeZone(TimeZone::getGMT());
 
-   //
-   // The first request has to 100 ms after an ordinal second
-   //    to push the literal zero out of the pattern check
-   apr_time_t ticks = MICROSECONDS_PER_DAY * 11142L;
-   apr_time_t jul2 = ticks + 120000;
+		//
+		// The first request has to 100 ms after an ordinal second
+		//    to push the literal zero out of the pattern check
+		apr_time_t ticks = MICROSECONDS_PER_DAY * 11142L;
+		apr_time_t jul2 = ticks + 120000;
 
-   Pool p;
+		Pool p;
 
-   LogString s;
-   gmtFormat->format(s, jul2, p);
+		LogString s;
+		gmtFormat->format(s, jul2, p);
 
-   LOGUNIT_ASSERT_EQUAL(
-      (LogString) LOG4CXX_STR("00,1200"), s);
+		LOGUNIT_ASSERT_EQUAL(
+			(LogString) LOG4CXX_STR("00,1200"), s);
 
-   jul2 = ticks + 87000;
+		jul2 = ticks + 87000;
 
-   s.erase(s.begin(), s.end());
-   gmtFormat->format(s, jul2, p);
+		s.erase(s.begin(), s.end());
+		gmtFormat->format(s, jul2, p);
 
-   LOGUNIT_ASSERT_EQUAL(
-      (LogString) LOG4CXX_STR("00,870"), s);
-}
+		LOGUNIT_ASSERT_EQUAL(
+			(LogString) LOG4CXX_STR("00,870"), s);
+	}
 
-/**
- * Check pattern location for ISO8601
- */
-void test12() {
-   DateFormatPtr df    = new SimpleDateFormat(LOG4CXX_STR("yyyy-MM-dd HH:mm:ss,SSS"));
-   apr_time_t    ticks = 11142L * MICROSECONDS_PER_DAY;
-   Pool p;
-   LogString formatted;
+	/**
+	 * Check pattern location for ISO8601
+	 */
+	void test12()
+	{
+		DateFormatPtr df    = new SimpleDateFormat(LOG4CXX_STR("yyyy-MM-dd HH:mm:ss,SSS"));
+		apr_time_t    ticks = 11142L * MICROSECONDS_PER_DAY;
+		Pool p;
+		LogString formatted;
 
-   df->format(formatted, ticks, p);
-   int msStart = CachedDateFormat::findMillisecondStart(ticks, formatted, df, p);
-   LOGUNIT_ASSERT_EQUAL(20, msStart);
+		df->format(formatted, ticks, p);
+		int msStart = CachedDateFormat::findMillisecondStart(ticks, formatted, df, p);
+		LOGUNIT_ASSERT_EQUAL(20, msStart);
 
-   // Test for for milliseconds overlapping with the magic ones as per LOGCXX-420.
-   apr_time_exp_t c;
-   memset(&c, 0, sizeof(c));
-   c.tm_year = 110;
-   c.tm_mon  = 7;
-   c.tm_mday = 12;
-   c.tm_hour = 9;
-   c.tm_min  = 4;
-   c.tm_sec  = 50;
-   c.tm_usec = 406000;
+		// Test for for milliseconds overlapping with the magic ones as per LOGCXX-420.
+		apr_time_exp_t c;
+		memset(&c, 0, sizeof(c));
+		c.tm_year = 110;
+		c.tm_mon  = 7;
+		c.tm_mday = 12;
+		c.tm_hour = 9;
+		c.tm_min  = 4;
+		c.tm_sec  = 50;
+		c.tm_usec = 406000;
 
-   LOGUNIT_ASSERT_EQUAL(0, apr_time_exp_gmt_get(&ticks, &c));
+		LOGUNIT_ASSERT_EQUAL(0, apr_time_exp_gmt_get(&ticks, &c));
 
-   formatted.clear();
-   df->format(formatted, ticks, p);
-   msStart = CachedDateFormat::findMillisecondStart(ticks, formatted, df, p);
-   LOGUNIT_ASSERT_EQUAL(20, msStart);
+		formatted.clear();
+		df->format(formatted, ticks, p);
+		msStart = CachedDateFormat::findMillisecondStart(ticks, formatted, df, p);
+		LOGUNIT_ASSERT_EQUAL(20, msStart);
 
-   c.tm_usec = 609000;
-   LOGUNIT_ASSERT_EQUAL(0, apr_time_exp_gmt_get(&ticks, &c));
+		c.tm_usec = 609000;
+		LOGUNIT_ASSERT_EQUAL(0, apr_time_exp_gmt_get(&ticks, &c));
 
-   formatted.clear();
-   df->format(formatted, ticks, p);
-   msStart = CachedDateFormat::findMillisecondStart(ticks, formatted, df, p);
-   LOGUNIT_ASSERT_EQUAL(20, msStart);
-}
+		formatted.clear();
+		df->format(formatted, ticks, p);
+		msStart = CachedDateFormat::findMillisecondStart(ticks, formatted, df, p);
+		LOGUNIT_ASSERT_EQUAL(20, msStart);
+	}
 
-/**
- * Check pattern location for DATE
- */
-void test13() {
-   DateFormatPtr df = new SimpleDateFormat(LOG4CXX_STR("yyyy-MM-dd"));
-   apr_time_t ticks = 11142L * MICROSECONDS_PER_DAY;
+	/**
+	 * Check pattern location for DATE
+	 */
+	void test13()
+	{
+		DateFormatPtr df = new SimpleDateFormat(LOG4CXX_STR("yyyy-MM-dd"));
+		apr_time_t ticks = 11142L * MICROSECONDS_PER_DAY;
 
-   Pool p;
+		Pool p;
 
-   LogString formatted;
-   df->format(formatted, ticks, p);
+		LogString formatted;
+		df->format(formatted, ticks, p);
 
-   int millisecondStart = CachedDateFormat::findMillisecondStart(ticks,
-       formatted, df, p);
-   LOGUNIT_ASSERT_EQUAL((int) CachedDateFormat::NO_MILLISECONDS, millisecondStart);
-}
+		int millisecondStart = CachedDateFormat::findMillisecondStart(ticks,
+				formatted, df, p);
+		LOGUNIT_ASSERT_EQUAL((int) CachedDateFormat::NO_MILLISECONDS, millisecondStart);
+	}
 
-/**
- * Check pattern location for ABSOLUTE
- */
-void test14() {
-   DateFormatPtr df = new SimpleDateFormat(LOG4CXX_STR("HH:mm:ss,SSS"));
-   apr_time_t ticks = 11142L * MICROSECONDS_PER_DAY;
+	/**
+	 * Check pattern location for ABSOLUTE
+	 */
+	void test14()
+	{
+		DateFormatPtr df = new SimpleDateFormat(LOG4CXX_STR("HH:mm:ss,SSS"));
+		apr_time_t ticks = 11142L * MICROSECONDS_PER_DAY;
 
-   Pool p;
-   LogString formatted;
-   df->format(formatted, ticks, p);
+		Pool p;
+		LogString formatted;
+		df->format(formatted, ticks, p);
 
-   int millisecondStart = CachedDateFormat::findMillisecondStart(ticks,
-      formatted, df, p);
-   LOGUNIT_ASSERT_EQUAL(9, millisecondStart);
-}
+		int millisecondStart = CachedDateFormat::findMillisecondStart(ticks,
+				formatted, df, p);
+		LOGUNIT_ASSERT_EQUAL(9, millisecondStart);
+	}
 
-/**
- * Check pattern location for single S
- */
-void test15() {
-   DateFormatPtr df = new SimpleDateFormat(LOG4CXX_STR("HH:mm:ss,S"));
-   apr_time_t ticks = 11142L * MICROSECONDS_PER_DAY;
+	/**
+	 * Check pattern location for single S
+	 */
+	void test15()
+	{
+		DateFormatPtr df = new SimpleDateFormat(LOG4CXX_STR("HH:mm:ss,S"));
+		apr_time_t ticks = 11142L * MICROSECONDS_PER_DAY;
 
-   Pool p;
-   LogString formatted;
-   df->format(formatted, ticks, p);
+		Pool p;
+		LogString formatted;
+		df->format(formatted, ticks, p);
 
-   int millisecondStart = CachedDateFormat::findMillisecondStart(ticks,
-      formatted, df, p);
-   LOGUNIT_ASSERT_EQUAL((int) CachedDateFormat::UNRECOGNIZED_MILLISECONDS, millisecondStart);
-}
+		int millisecondStart = CachedDateFormat::findMillisecondStart(ticks,
+				formatted, df, p);
+		LOGUNIT_ASSERT_EQUAL((int) CachedDateFormat::UNRECOGNIZED_MILLISECONDS, millisecondStart);
+	}
 
-/**
- * Check pattern location for single SS
- */
-void test16() {
-   DateFormatPtr df = new SimpleDateFormat(LOG4CXX_STR("HH:mm:ss,SS"));
-   apr_time_t ticks = 11142L * MICROSECONDS_PER_DAY;
+	/**
+	 * Check pattern location for single SS
+	 */
+	void test16()
+	{
+		DateFormatPtr df = new SimpleDateFormat(LOG4CXX_STR("HH:mm:ss,SS"));
+		apr_time_t ticks = 11142L * MICROSECONDS_PER_DAY;
 
-   Pool p;
-   LogString formatted;
-   df->format(formatted, ticks, p);
+		Pool p;
+		LogString formatted;
+		df->format(formatted, ticks, p);
 
-   int millisecondStart =
-      CachedDateFormat::findMillisecondStart(ticks, formatted, df, p);
-   LOGUNIT_ASSERT_EQUAL((int) CachedDateFormat::UNRECOGNIZED_MILLISECONDS, millisecondStart);
-}
+		int millisecondStart =
+			CachedDateFormat::findMillisecondStart(ticks, formatted, df, p);
+		LOGUNIT_ASSERT_EQUAL((int) CachedDateFormat::UNRECOGNIZED_MILLISECONDS, millisecondStart);
+	}
 
-/**
- * Check caching when multiple SSS appear in pattern
- */
-void test17() {
-    apr_time_t jul2 = 12602L * MICROSECONDS_PER_DAY;
-    LogString badPattern(LOG4CXX_STR("HH:mm:ss,SSS HH:mm:ss,SSS"));
-    DateFormatPtr simpleFormat = new SimpleDateFormat(badPattern);
-    simpleFormat->setTimeZone(TimeZone::getGMT());
-    DateFormatPtr cachedFormat = new CachedDateFormat(simpleFormat, 1000000);
+	/**
+	 * Check caching when multiple SSS appear in pattern
+	 */
+	void test17()
+	{
+		apr_time_t jul2 = 12602L * MICROSECONDS_PER_DAY;
+		LogString badPattern(LOG4CXX_STR("HH:mm:ss,SSS HH:mm:ss,SSS"));
+		DateFormatPtr simpleFormat = new SimpleDateFormat(badPattern);
+		simpleFormat->setTimeZone(TimeZone::getGMT());
+		DateFormatPtr cachedFormat = new CachedDateFormat(simpleFormat, 1000000);
 
-    Pool p;
-    LogString s;
-    cachedFormat->format(s, jul2, p);
+		Pool p;
+		LogString s;
+		cachedFormat->format(s, jul2, p);
 
-    LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("00:00:00,000 00:00:00,000"), s);
-    jul2 += 120000;
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("00:00:00,000 00:00:00,000"), s);
+		jul2 += 120000;
 
-    s.erase(s.begin(), s.end());
-    simpleFormat->format(s, jul2, p);
-    LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("00:00:00,120 00:00:00,120"), s);
+		s.erase(s.begin(), s.end());
+		simpleFormat->format(s, jul2, p);
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("00:00:00,120 00:00:00,120"), s);
 
-    s.erase(s.begin(), s.end());
-    int msStart = CachedDateFormat::findMillisecondStart(jul2, s, simpleFormat, p);
-    LOGUNIT_ASSERT_EQUAL((int) CachedDateFormat::UNRECOGNIZED_MILLISECONDS, msStart);
+		s.erase(s.begin(), s.end());
+		int msStart = CachedDateFormat::findMillisecondStart(jul2, s, simpleFormat, p);
+		LOGUNIT_ASSERT_EQUAL((int) CachedDateFormat::UNRECOGNIZED_MILLISECONDS, msStart);
 
-    cachedFormat->format(s, jul2, p);
-    LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("00:00:00,120 00:00:00,120"), s) ;
+		cachedFormat->format(s, jul2, p);
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("00:00:00,120 00:00:00,120"), s) ;
 
-    int maxValid = CachedDateFormat::getMaximumCacheValidity(badPattern);
-    LOGUNIT_ASSERT_EQUAL(1000, maxValid);
+		int maxValid = CachedDateFormat::getMaximumCacheValidity(badPattern);
+		LOGUNIT_ASSERT_EQUAL(1000, maxValid);
 
-    // Test overlapping millis with a magic string from CachedDateFormat for LOGCXX-420.
-    s.clear();
-    jul2 += 286000;
-    cachedFormat->format(s, jul2, p);
-    msStart = CachedDateFormat::findMillisecondStart(jul2, s, simpleFormat, p);
-    LOGUNIT_ASSERT_EQUAL((int) CachedDateFormat::UNRECOGNIZED_MILLISECONDS, msStart);
+		// Test overlapping millis with a magic string from CachedDateFormat for LOGCXX-420.
+		s.clear();
+		jul2 += 286000;
+		cachedFormat->format(s, jul2, p);
+		msStart = CachedDateFormat::findMillisecondStart(jul2, s, simpleFormat, p);
+		LOGUNIT_ASSERT_EQUAL((int) CachedDateFormat::UNRECOGNIZED_MILLISECONDS, msStart);
 
-    s.clear();
-    jul2 += 203000;
-    cachedFormat->format(s, jul2, p);
-    msStart = CachedDateFormat::findMillisecondStart(jul2, s, simpleFormat, p);
-    LOGUNIT_ASSERT_EQUAL((int) CachedDateFormat::UNRECOGNIZED_MILLISECONDS, msStart);
-}
+		s.clear();
+		jul2 += 203000;
+		cachedFormat->format(s, jul2, p);
+		msStart = CachedDateFormat::findMillisecondStart(jul2, s, simpleFormat, p);
+		LOGUNIT_ASSERT_EQUAL((int) CachedDateFormat::UNRECOGNIZED_MILLISECONDS, msStart);
+	}
 
-/**
- * Check that patterns not containing microseconds
- * are reported as being able to be cached for a full second.
- */
-void test18() {
+	/**
+	 * Check that patterns not containing microseconds
+	 * are reported as being able to be cached for a full second.
+	 */
+	void test18()
+	{
 
-    int maxValid =
-       CachedDateFormat::getMaximumCacheValidity(
-          LOG4CXX_STR("yyyy-MM-dd"));
-    LOGUNIT_ASSERT_EQUAL(1000000, maxValid);
-}
+		int maxValid =
+			CachedDateFormat::getMaximumCacheValidity(
+				LOG4CXX_STR("yyyy-MM-dd"));
+		LOGUNIT_ASSERT_EQUAL(1000000, maxValid);
+	}
 
-/**
- * Check that patterns not containing 3 microseconds
- * are reported as being able to be cached for a full second.
- */
-void test19() {
+	/**
+	 * Check that patterns not containing 3 microseconds
+	 * are reported as being able to be cached for a full second.
+	 */
+	void test19()
+	{
 
-    int maxValid =
-       CachedDateFormat::getMaximumCacheValidity(
-          LOG4CXX_STR("yyyy-MM-dd SSS"));
-    LOGUNIT_ASSERT_EQUAL(1000000, maxValid);
-}
+		int maxValid =
+			CachedDateFormat::getMaximumCacheValidity(
+				LOG4CXX_STR("yyyy-MM-dd SSS"));
+		LOGUNIT_ASSERT_EQUAL(1000000, maxValid);
+	}
 
-/**
- * Check that patterns not containing 2 S's
- * are reported as being able to be cached for only a millisecond.
- */
-void test20() {
+	/**
+	 * Check that patterns not containing 2 S's
+	 * are reported as being able to be cached for only a millisecond.
+	 */
+	void test20()
+	{
 
-    int maxValid =
-       CachedDateFormat::getMaximumCacheValidity(
-          LOG4CXX_STR("yyyy-MM-dd SS"));
-    LOGUNIT_ASSERT_EQUAL(1000, maxValid);
-}
+		int maxValid =
+			CachedDateFormat::getMaximumCacheValidity(
+				LOG4CXX_STR("yyyy-MM-dd SS"));
+		LOGUNIT_ASSERT_EQUAL(1000, maxValid);
+	}
 
-/**
- * Check that patterns not containing multi S groups
- * are reported as being able to be cached for only a millisecond.
- */
-void test21() {
+	/**
+	 * Check that patterns not containing multi S groups
+	 * are reported as being able to be cached for only a millisecond.
+	 */
+	void test21()
+	{
 
-    int maxValid =
-       CachedDateFormat::getMaximumCacheValidity(
-          LOG4CXX_STR("yyyy-MM-dd SSS SSS"));
-    LOGUNIT_ASSERT_EQUAL(1000, maxValid);
-}
+		int maxValid =
+			CachedDateFormat::getMaximumCacheValidity(
+				LOG4CXX_STR("yyyy-MM-dd SSS SSS"));
+		LOGUNIT_ASSERT_EQUAL(1000, maxValid);
+	}
 
-/**
- * Check that findMillisecondStart correctly handles timestamps
- * which use the magic millisecond value 654.
- */
-void test22() {
-    DateFormatPtr baseFormatter(new ISO8601DateFormat());
-    CachedDateFormat isoFormat(baseFormatter, 1000000);
-    isoFormat.setTimeZone(TimeZone::getGMT());
+	/**
+	 * Check that findMillisecondStart correctly handles timestamps
+	 * which use the magic millisecond value 654.
+	 */
+	void test22()
+	{
+		DateFormatPtr baseFormatter(new ISO8601DateFormat());
+		CachedDateFormat isoFormat(baseFormatter, 1000000);
+		isoFormat.setTimeZone(TimeZone::getGMT());
 
-    Pool p;
-    LogString formatted;
+		Pool p;
+		LogString formatted;
 
-    isoFormat.format(formatted, 654000, p);
-    LOGUNIT_ASSERT_EQUAL(LOG4CXX_STR("1970-01-01 00:00:00,654"), formatted);
+		isoFormat.format(formatted, 654000, p);
+		LOGUNIT_ASSERT_EQUAL(LOG4CXX_STR("1970-01-01 00:00:00,654"), formatted);
 
-    formatted.clear();
-    isoFormat.format(formatted, 999000, p);
-    LOGUNIT_ASSERT_EQUAL(LOG4CXX_STR("1970-01-01 00:00:00,999"), formatted);
+		formatted.clear();
+		isoFormat.format(formatted, 999000, p);
+		LOGUNIT_ASSERT_EQUAL(LOG4CXX_STR("1970-01-01 00:00:00,999"), formatted);
 
-    formatted.clear();
-    isoFormat.format(formatted, 1654010, p);
-    LOGUNIT_ASSERT_EQUAL(LOG4CXX_STR("1970-01-01 00:00:01,654"), formatted);
+		formatted.clear();
+		isoFormat.format(formatted, 1654010, p);
+		LOGUNIT_ASSERT_EQUAL(LOG4CXX_STR("1970-01-01 00:00:01,654"), formatted);
 
-    formatted.clear();
-    isoFormat.format(formatted, 1999010, p);
-    LOGUNIT_ASSERT_EQUAL(LOG4CXX_STR("1970-01-01 00:00:01,999"), formatted);
-}
+		formatted.clear();
+		isoFormat.format(formatted, 1999010, p);
+		LOGUNIT_ASSERT_EQUAL(LOG4CXX_STR("1970-01-01 00:00:01,999"), formatted);
+	}
 
 };
 
diff --git a/src/test/cpp/helpers/charsetdecodertestcase.cpp b/src/test/cpp/helpers/charsetdecodertestcase.cpp
index 22a485f..0493ba2 100644
--- a/src/test/cpp/helpers/charsetdecodertestcase.cpp
+++ b/src/test/cpp/helpers/charsetdecodertestcase.cpp
@@ -30,78 +30,81 @@
 
 LOGUNIT_CLASS(CharsetDecoderTestCase)
 {
-        LOGUNIT_TEST_SUITE(CharsetDecoderTestCase);
-                LOGUNIT_TEST(decode1);
-                LOGUNIT_TEST(decode2);
-                LOGUNIT_TEST(decode8);
-        LOGUNIT_TEST_SUITE_END();
+	LOGUNIT_TEST_SUITE(CharsetDecoderTestCase);
+	LOGUNIT_TEST(decode1);
+	LOGUNIT_TEST(decode2);
+	LOGUNIT_TEST(decode8);
+	LOGUNIT_TEST_SUITE_END();
 
-        enum { BUFSIZE = 256 };
+	enum { BUFSIZE = 256 };
 
 public:
 
 
-        void decode1() {
-          char buf[] = "Hello, World";
-          ByteBuffer src(buf, strlen(buf));
+	void decode1()
+	{
+		char buf[] = "Hello, World";
+		ByteBuffer src(buf, strlen(buf));
 
-          CharsetDecoderPtr dec(CharsetDecoder::getDefaultDecoder());
-          LogString greeting;
-          log4cxx_status_t stat = dec->decode(src, greeting);
-          LOGUNIT_ASSERT_EQUAL(APR_SUCCESS, stat);
+		CharsetDecoderPtr dec(CharsetDecoder::getDefaultDecoder());
+		LogString greeting;
+		log4cxx_status_t stat = dec->decode(src, greeting);
+		LOGUNIT_ASSERT_EQUAL(APR_SUCCESS, stat);
 
-          stat = dec->decode(src, greeting);
-          LOGUNIT_ASSERT_EQUAL(APR_SUCCESS, stat);
-          LOGUNIT_ASSERT_EQUAL((size_t) 12, src.position());
+		stat = dec->decode(src, greeting);
+		LOGUNIT_ASSERT_EQUAL(APR_SUCCESS, stat);
+		LOGUNIT_ASSERT_EQUAL((size_t) 12, src.position());
 
-          LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("Hello, World"), greeting);
-        }
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("Hello, World"), greeting);
+	}
 
-        void decode2() {
-          char buf[BUFSIZE + 6];
-          memset(buf, 'A', BUFSIZE);
-          buf[BUFSIZE - 3] = 0;
+	void decode2()
+	{
+		char buf[BUFSIZE + 6];
+		memset(buf, 'A', BUFSIZE);
+		buf[BUFSIZE - 3] = 0;
 #if defined(__STDC_LIB_EXT1__) || defined(__STDC_SECURE_LIB__)
-          strcat_s(buf, sizeof buf, "Hello");
+		strcat_s(buf, sizeof buf, "Hello");
 #else
-          strcat(buf, "Hello");
+		strcat(buf, "Hello");
 #endif
-          ByteBuffer src(buf, strlen(buf));
+		ByteBuffer src(buf, strlen(buf));
 
-          CharsetDecoderPtr dec(CharsetDecoder::getDefaultDecoder());
+		CharsetDecoderPtr dec(CharsetDecoder::getDefaultDecoder());
 
-          LogString greeting;
-          log4cxx_status_t stat = dec->decode(src, greeting);
-          LOGUNIT_ASSERT_EQUAL(APR_SUCCESS, stat);
-          LOGUNIT_ASSERT_EQUAL((size_t) 0, src.remaining());
+		LogString greeting;
+		log4cxx_status_t stat = dec->decode(src, greeting);
+		LOGUNIT_ASSERT_EQUAL(APR_SUCCESS, stat);
+		LOGUNIT_ASSERT_EQUAL((size_t) 0, src.remaining());
 
 
-          stat = dec->decode(src, greeting);
-          LOGUNIT_ASSERT_EQUAL(APR_SUCCESS, stat);
+		stat = dec->decode(src, greeting);
+		LOGUNIT_ASSERT_EQUAL(APR_SUCCESS, stat);
 
-          LogString manyAs(BUFSIZE - 3, LOG4CXX_STR('A'));
-          LOGUNIT_ASSERT_EQUAL(manyAs, greeting.substr(0, BUFSIZE - 3));
-          LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("Hello")), greeting.substr(BUFSIZE - 3));
-        }
+		LogString manyAs(BUFSIZE - 3, LOG4CXX_STR('A'));
+		LOGUNIT_ASSERT_EQUAL(manyAs, greeting.substr(0, BUFSIZE - 3));
+		LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("Hello")), greeting.substr(BUFSIZE - 3));
+	}
 
 
 
-        void decode8() {
-          char buf[] = { 'H', 'e', 'l', 'l', 'o', ',', 0, 'W', 'o', 'r', 'l', 'd'};
-          ByteBuffer src(buf, 12);
+	void decode8()
+	{
+		char buf[] = { 'H', 'e', 'l', 'l', 'o', ',', 0, 'W', 'o', 'r', 'l', 'd'};
+		ByteBuffer src(buf, 12);
 
-          CharsetDecoderPtr dec(CharsetDecoder::getDefaultDecoder());
-          LogString greeting;
-          log4cxx_status_t stat = dec->decode(src, greeting);
-          LOGUNIT_ASSERT_EQUAL(APR_SUCCESS, stat);
+		CharsetDecoderPtr dec(CharsetDecoder::getDefaultDecoder());
+		LogString greeting;
+		log4cxx_status_t stat = dec->decode(src, greeting);
+		LOGUNIT_ASSERT_EQUAL(APR_SUCCESS, stat);
 
-          stat = dec->decode(src, greeting);
-          LOGUNIT_ASSERT_EQUAL(APR_SUCCESS, stat);
-          LOGUNIT_ASSERT_EQUAL((size_t) 12, src.position());
+		stat = dec->decode(src, greeting);
+		LOGUNIT_ASSERT_EQUAL(APR_SUCCESS, stat);
+		LOGUNIT_ASSERT_EQUAL((size_t) 12, src.position());
 
-          const logchar expected[] = { 0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x2C, 0x00, 0x57, 0x6F, 0x72, 0x6C, 0x64 };
-          LOGUNIT_ASSERT_EQUAL(LogString(expected, 12), greeting);
-        }
+		const logchar expected[] = { 0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x2C, 0x00, 0x57, 0x6F, 0x72, 0x6C, 0x64 };
+		LOGUNIT_ASSERT_EQUAL(LogString(expected, 12), greeting);
+	}
 
 
 
diff --git a/src/test/cpp/helpers/charsetencodertestcase.cpp b/src/test/cpp/helpers/charsetencodertestcase.cpp
index 74af926..5677820 100644
--- a/src/test/cpp/helpers/charsetencodertestcase.cpp
+++ b/src/test/cpp/helpers/charsetencodertestcase.cpp
@@ -33,268 +33,312 @@
 
 LOGUNIT_CLASS(CharsetEncoderTestCase)
 {
-        LOGUNIT_TEST_SUITE(CharsetEncoderTestCase);
-                LOGUNIT_TEST(encode1);
-                LOGUNIT_TEST(encode2);
-                LOGUNIT_TEST(encode3);
-                LOGUNIT_TEST(encode4);
-#if APR_HAS_THREADS        
-                LOGUNIT_TEST(thread1);
-#endif                
-        LOGUNIT_TEST_SUITE_END();
+	LOGUNIT_TEST_SUITE(CharsetEncoderTestCase);
+	LOGUNIT_TEST(encode1);
+	LOGUNIT_TEST(encode2);
+	LOGUNIT_TEST(encode3);
+	LOGUNIT_TEST(encode4);
+#if APR_HAS_THREADS
+	LOGUNIT_TEST(thread1);
+#endif
+	LOGUNIT_TEST_SUITE_END();
 
-        enum { BUFSIZE = 256 };
+	enum { BUFSIZE = 256 };
 
 public:
 
 
-        void encode1() {
-          const LogString greeting(LOG4CXX_STR("Hello, World"));
-          CharsetEncoderPtr enc(CharsetEncoder::getEncoder(LOG4CXX_STR("US-ASCII")));
-          char buf[BUFSIZE];
-          ByteBuffer out(buf, BUFSIZE);
-          LogString::const_iterator iter = greeting.begin();
-          log4cxx_status_t stat = enc->encode(greeting, iter, out);
-          LOGUNIT_ASSERT_EQUAL(APR_SUCCESS, stat);
-          LOGUNIT_ASSERT(iter == greeting.end());
+	void encode1()
+	{
+		const LogString greeting(LOG4CXX_STR("Hello, World"));
+		CharsetEncoderPtr enc(CharsetEncoder::getEncoder(LOG4CXX_STR("US-ASCII")));
+		char buf[BUFSIZE];
+		ByteBuffer out(buf, BUFSIZE);
+		LogString::const_iterator iter = greeting.begin();
+		log4cxx_status_t stat = enc->encode(greeting, iter, out);
+		LOGUNIT_ASSERT_EQUAL(APR_SUCCESS, stat);
+		LOGUNIT_ASSERT(iter == greeting.end());
 
-          stat = enc->encode(greeting, iter, out);
-          LOGUNIT_ASSERT_EQUAL(APR_SUCCESS, stat);
-          LOGUNIT_ASSERT_EQUAL((size_t) 12, out.position());
+		stat = enc->encode(greeting, iter, out);
+		LOGUNIT_ASSERT_EQUAL(APR_SUCCESS, stat);
+		LOGUNIT_ASSERT_EQUAL((size_t) 12, out.position());
 
-          out.flip();
-          std::string encoded((const char*) out.data(), out.limit());
-          LOGUNIT_ASSERT_EQUAL((std::string) "Hello, World", encoded);
-          LOGUNIT_ASSERT(iter == greeting.end());
-        }
+		out.flip();
+		std::string encoded((const char*) out.data(), out.limit());
+		LOGUNIT_ASSERT_EQUAL((std::string) "Hello, World", encoded);
+		LOGUNIT_ASSERT(iter == greeting.end());
+	}
 
-        void encode2() {
-          LogString greeting(BUFSIZE - 3, LOG4CXX_STR('A'));
-          greeting.append(LOG4CXX_STR("Hello"));
+	void encode2()
+	{
+		LogString greeting(BUFSIZE - 3, LOG4CXX_STR('A'));
+		greeting.append(LOG4CXX_STR("Hello"));
 
-          CharsetEncoderPtr enc(CharsetEncoder::getEncoder(LOG4CXX_STR("US-ASCII")));
+		CharsetEncoderPtr enc(CharsetEncoder::getEncoder(LOG4CXX_STR("US-ASCII")));
 
-          char buf[BUFSIZE];
-          ByteBuffer out(buf, BUFSIZE);
-          LogString::const_iterator iter = greeting.begin();
-          log4cxx_status_t stat = enc->encode(greeting, iter, out);
-          LOGUNIT_ASSERT_EQUAL(APR_SUCCESS, stat);
-          LOGUNIT_ASSERT_EQUAL((size_t) 0, out.remaining());
-          LOGUNIT_ASSERT_EQUAL(LOG4CXX_STR('o'), *(iter+1));
+		char buf[BUFSIZE];
+		ByteBuffer out(buf, BUFSIZE);
+		LogString::const_iterator iter = greeting.begin();
+		log4cxx_status_t stat = enc->encode(greeting, iter, out);
+		LOGUNIT_ASSERT_EQUAL(APR_SUCCESS, stat);
+		LOGUNIT_ASSERT_EQUAL((size_t) 0, out.remaining());
+		LOGUNIT_ASSERT_EQUAL(LOG4CXX_STR('o'), *(iter + 1));
 
-          out.flip();
-          std::string encoded((char*) out.data(), out.limit());
-          out.clear();
+		out.flip();
+		std::string encoded((char*) out.data(), out.limit());
+		out.clear();
 
-          stat = enc->encode(greeting, iter, out);
-          LOGUNIT_ASSERT_EQUAL(APR_SUCCESS, stat);
-          LOGUNIT_ASSERT_EQUAL((size_t) 2, out.position());
-          LOGUNIT_ASSERT(iter == greeting.end());
+		stat = enc->encode(greeting, iter, out);
+		LOGUNIT_ASSERT_EQUAL(APR_SUCCESS, stat);
+		LOGUNIT_ASSERT_EQUAL((size_t) 2, out.position());
+		LOGUNIT_ASSERT(iter == greeting.end());
 
-          stat = enc->encode(greeting, iter, out);
-          out.flip();
-          LOGUNIT_ASSERT_EQUAL(APR_SUCCESS, stat);
-          encoded.append(out.data(), out.limit());
+		stat = enc->encode(greeting, iter, out);
+		out.flip();
+		LOGUNIT_ASSERT_EQUAL(APR_SUCCESS, stat);
+		encoded.append(out.data(), out.limit());
 
-          std::string manyAs(BUFSIZE - 3, 'A');
-          LOGUNIT_ASSERT_EQUAL(manyAs, encoded.substr(0, BUFSIZE - 3));
-          LOGUNIT_ASSERT_EQUAL(std::string("Hello"), encoded.substr(BUFSIZE - 3));
-        }
+		std::string manyAs(BUFSIZE - 3, 'A');
+		LOGUNIT_ASSERT_EQUAL(manyAs, encoded.substr(0, BUFSIZE - 3));
+		LOGUNIT_ASSERT_EQUAL(std::string("Hello"), encoded.substr(BUFSIZE - 3));
+	}
 
 
-        void encode3() {
+	void encode3()
+	{
 #if LOG4CXX_LOGCHAR_IS_WCHAR || LOG4CXX_LOGCHAR_IS_UNICHAR
-          //   arbitrary, hopefully meaningless, characters from
-          //     Latin, Arabic, Armenian, Bengali, CJK and Cyrillic
-          const logchar greet[] = { L'A', 0x0605, 0x0530, 0x986, 0x4E03, 0x400, 0 };
+		//   arbitrary, hopefully meaningless, characters from
+		//     Latin, Arabic, Armenian, Bengali, CJK and Cyrillic
+		const logchar greet[] = { L'A', 0x0605, 0x0530, 0x986, 0x4E03, 0x400, 0 };
 #endif
 
 #if LOG4CXX_LOGCHAR_IS_UTF8
-          const char greet[] = { 'A',
-                                    (char) 0xD8, (char) 0x85,
-                                    (char) 0xD4, (char) 0xB0,
-                                    (char) 0xE0, (char) 0xA6, (char) 0x86,
-                                    (char) 0xE4, (char) 0xB8, (char) 0x83,
-                                    (char) 0xD0, (char) 0x80,
-                                    0 };
+		const char greet[] = { 'A',
+				(char) 0xD8, (char) 0x85,
+				(char) 0xD4, (char) 0xB0,
+				(char) 0xE0, (char) 0xA6, (char) 0x86,
+				(char) 0xE4, (char) 0xB8, (char) 0x83,
+				(char) 0xD0, (char) 0x80,
+				0
+			};
 #endif
-          LogString greeting(greet);
+		LogString greeting(greet);
 
-          CharsetEncoderPtr enc(CharsetEncoder::getEncoder(LOG4CXX_STR("US-ASCII")));
+		CharsetEncoderPtr enc(CharsetEncoder::getEncoder(LOG4CXX_STR("US-ASCII")));
 
-          char buf[BUFSIZE];
-          ByteBuffer out(buf, BUFSIZE);
+		char buf[BUFSIZE];
+		ByteBuffer out(buf, BUFSIZE);
 
-          LogString::const_iterator iter = greeting.begin();
-          log4cxx_status_t stat = enc->encode(greeting, iter, out);
-          out.flip();
-          LOGUNIT_ASSERT_EQUAL(true, CharsetEncoder::isError(stat));
-          LOGUNIT_ASSERT_EQUAL((size_t) 1, out.limit());
-          LOGUNIT_ASSERT_EQUAL(greet[1], *iter);
-          LOGUNIT_ASSERT_EQUAL('A', out.data()[0]);
-        }
+		LogString::const_iterator iter = greeting.begin();
+		log4cxx_status_t stat = enc->encode(greeting, iter, out);
+		out.flip();
+		LOGUNIT_ASSERT_EQUAL(true, CharsetEncoder::isError(stat));
+		LOGUNIT_ASSERT_EQUAL((size_t) 1, out.limit());
+		LOGUNIT_ASSERT_EQUAL(greet[1], *iter);
+		LOGUNIT_ASSERT_EQUAL('A', out.data()[0]);
+	}
 
 
-        void encode4() {
-          const char utf8_greet[] = { 'A',
-                                    (char) 0xD8, (char) 0x85,
-                                    (char) 0xD4, (char) 0xB0,
-                                    (char) 0xE0, (char) 0xA6, (char) 0x86,
-                                    (char) 0xE4, (char) 0xB8, (char) 0x83,
-                                    (char) 0xD0, (char) 0x80,
-                                    0 };
+	void encode4()
+	{
+		const char utf8_greet[] = { 'A',
+				(char) 0xD8, (char) 0x85,
+				(char) 0xD4, (char) 0xB0,
+				(char) 0xE0, (char) 0xA6, (char) 0x86,
+				(char) 0xE4, (char) 0xB8, (char) 0x83,
+				(char) 0xD0, (char) 0x80,
+				0
+			};
 #if LOG4CXX_LOGCHAR_IS_WCHAR || LOG4CXX_LOGCHAR_IS_UNICHAR
-          //   arbitrary, hopefully meaningless, characters from
-          //     Latin, Arabic, Armenian, Bengali, CJK and Cyrillic
-          const logchar greet[] = { L'A', 0x0605, 0x0530, 0x986, 0x4E03, 0x400, 0 };
+		//   arbitrary, hopefully meaningless, characters from
+		//     Latin, Arabic, Armenian, Bengali, CJK and Cyrillic
+		const logchar greet[] = { L'A', 0x0605, 0x0530, 0x986, 0x4E03, 0x400, 0 };
 #endif
 
 #if LOG4CXX_LOGCHAR_IS_UTF8
-          const logchar *greet = utf8_greet;
+		const logchar* greet = utf8_greet;
 #endif
-          LogString greeting(greet);
+		LogString greeting(greet);
 
-          CharsetEncoderPtr enc(CharsetEncoder::getEncoder(LOG4CXX_STR("UTF-8")));
+		CharsetEncoderPtr enc(CharsetEncoder::getEncoder(LOG4CXX_STR("UTF-8")));
 
-          char buf[BUFSIZE];
-          ByteBuffer out(buf, BUFSIZE);
-          LogString::const_iterator iter = greeting.begin();
-          log4cxx_status_t stat = enc->encode(greeting, iter, out);
-          LOGUNIT_ASSERT_EQUAL(false, CharsetEncoder::isError(stat));
-          stat = enc->encode(greeting, iter, out);
-          LOGUNIT_ASSERT_EQUAL(false, CharsetEncoder::isError(stat));
+		char buf[BUFSIZE];
+		ByteBuffer out(buf, BUFSIZE);
+		LogString::const_iterator iter = greeting.begin();
+		log4cxx_status_t stat = enc->encode(greeting, iter, out);
+		LOGUNIT_ASSERT_EQUAL(false, CharsetEncoder::isError(stat));
+		stat = enc->encode(greeting, iter, out);
+		LOGUNIT_ASSERT_EQUAL(false, CharsetEncoder::isError(stat));
 
-          out.flip();
-          LOGUNIT_ASSERT_EQUAL((size_t) 13, out.limit());
-          for(size_t i = 0; i < out.limit(); i++) {
-             LOGUNIT_ASSERT_EQUAL((int) utf8_greet[i], (int) out.data()[i]);
-          }
-          LOGUNIT_ASSERT(iter == greeting.end());
-        }
-        
-#if APR_HAS_THREADS        
-        class ThreadPackage {
-        public:
-            ThreadPackage(CharsetEncoderPtr& enc, int repetitions) : 
-                p(), lock(p), condition(p), passCount(0), failCount(0), enc(enc), repetitions(repetitions) {
-            }
-            
-            void await() {
-                synchronized sync(lock);
-                condition.await(lock);
-            }
-            
-            void signalAll() {
-                synchronized sync(lock);
-                condition.signalAll();
-            }
-            
-            void fail() {
-                apr_atomic_inc32(&failCount);
-            }
-            
-            void pass() {
-                apr_atomic_inc32(&passCount);
-            }
-            
-            apr_uint32_t getFail() {
-               return apr_atomic_read32(&failCount);
-            }
-            
-            apr_uint32_t getPass() {
-               return apr_atomic_read32(&passCount);
-            }
-            
-            int getRepetitions() {
-                return repetitions;
-            }
-            
-            CharsetEncoderPtr& getEncoder() {
-               return enc;
-            }
-            
-        private:
-            ThreadPackage(const ThreadPackage&);
-            ThreadPackage& operator=(ThreadPackage&);
-            Pool p;
-            Mutex lock;
-            Condition condition;
-            volatile apr_uint32_t passCount;
-            volatile apr_uint32_t failCount; 
-            CharsetEncoderPtr enc;
-            int repetitions;
-        };
-        
-        static void* LOG4CXX_THREAD_FUNC thread1Action(apr_thread_t* /* thread */, void* data) {
-            ThreadPackage* package = (ThreadPackage*) data;
+		out.flip();
+		LOGUNIT_ASSERT_EQUAL((size_t) 13, out.limit());
+
+		for (size_t i = 0; i < out.limit(); i++)
+		{
+			LOGUNIT_ASSERT_EQUAL((int) utf8_greet[i], (int) out.data()[i]);
+		}
+
+		LOGUNIT_ASSERT(iter == greeting.end());
+	}
+
+#if APR_HAS_THREADS
+	class ThreadPackage
+	{
+		public:
+			ThreadPackage(CharsetEncoderPtr& enc, int repetitions) :
+				p(), lock(p), condition(p), passCount(0), failCount(0), enc(enc), repetitions(repetitions)
+			{
+			}
+
+			void await()
+			{
+				synchronized sync(lock);
+				condition.await(lock);
+			}
+
+			void signalAll()
+			{
+				synchronized sync(lock);
+				condition.signalAll();
+			}
+
+			void fail()
+			{
+				apr_atomic_inc32(&failCount);
+			}
+
+			void pass()
+			{
+				apr_atomic_inc32(&passCount);
+			}
+
+			apr_uint32_t getFail()
+			{
+				return apr_atomic_read32(&failCount);
+			}
+
+			apr_uint32_t getPass()
+			{
+				return apr_atomic_read32(&passCount);
+			}
+
+			int getRepetitions()
+			{
+				return repetitions;
+			}
+
+			CharsetEncoderPtr& getEncoder()
+			{
+				return enc;
+			}
+
+		private:
+			ThreadPackage(const ThreadPackage&);
+			ThreadPackage& operator=(ThreadPackage&);
+			Pool p;
+			Mutex lock;
+			Condition condition;
+			volatile apr_uint32_t passCount;
+			volatile apr_uint32_t failCount;
+			CharsetEncoderPtr enc;
+			int repetitions;
+	};
+
+	static void* LOG4CXX_THREAD_FUNC thread1Action(apr_thread_t* /* thread */, void* data)
+	{
+		ThreadPackage* package = (ThreadPackage*) data;
 #if LOG4CXX_LOGCHAR_IS_UTF8
-            const logchar greet[] = { 'H', 'e', 'l', 'l', 'o', ' ',
-                                    (char) 0xC2, (char) 0xA2,  //  cent sign
-                                    (char) 0xC2, (char) 0xA9,  //  copyright
-                                    (char) 0xc3, (char) 0xb4,  //  latin small letter o with circumflex
-                                    0 };
+		const logchar greet[] = { 'H', 'e', 'l', 'l', 'o', ' ',
+				(char) 0xC2, (char) 0xA2,  //  cent sign
+				(char) 0xC2, (char) 0xA9,  //  copyright
+				(char) 0xc3, (char) 0xb4,  //  latin small letter o with circumflex
+				0
+			};
 #endif
 #if LOG4CXX_LOGCHAR_IS_WCHAR || LOG4CXX_LOGCHAR_IS_UNICHAR
-            //   arbitrary, hopefully meaningless, characters from
-            //     Latin, Arabic, Armenian, Bengali, CJK and Cyrillic
-            const logchar greet[] = { L'H', L'e', L'l', L'l', L'o', L' ',
-                0x00A2, 0x00A9, 0x00F4 , 0 };
+		//   arbitrary, hopefully meaningless, characters from
+		//     Latin, Arabic, Armenian, Bengali, CJK and Cyrillic
+		const logchar greet[] = { L'H', L'e', L'l', L'l', L'o', L' ',
+				0x00A2, 0x00A9, 0x00F4, 0
+			};
 #endif
-          
-          const char expected[] =  { 'H', 'e', 'l', 'l', 'o', ' ',
-                (char) 0x00A2, (char) 0x00A9, (char) 0x00F4 };
 
-          LogString greeting(greet);
+		const char expected[] =  { 'H', 'e', 'l', 'l', 'o', ' ',
+				(char) 0x00A2, (char) 0x00A9, (char) 0x00F4
+			};
 
-          package->await();
-          for(int i = 0; i < package->getRepetitions(); i++) {
-            bool pass = true;
-            char buf[BUFSIZE];
-            ByteBuffer out(buf, BUFSIZE);
-            LogString::const_iterator iter = greeting.begin();
-            log4cxx_status_t stat = package->getEncoder()->encode(greeting, iter, out);
-            pass = (false == CharsetEncoder::isError(stat));
-            if (pass) {
-                stat = package->getEncoder()->encode(greeting, iter, out);
-                pass = (false == CharsetEncoder::isError(stat));
-                if (pass) {
-                    out.flip();
-                    pass = (sizeof(expected) == out.limit());
-                    for(size_t i = 0; i < out.limit() && pass; i++) {
-                        pass = (expected[i] == out.data()[i]);
-                    }
-                    pass = pass && (iter == greeting.end());
-                }
-            }
-            if (pass) {
-                package->pass();
-            } else {
-                package->fail();
-            }
-          }
-            return 0;
-        }
+		LogString greeting(greet);
 
-        void thread1() {
-              enum { THREAD_COUNT = 10, THREAD_REPS = 10000 };
-              Thread threads[THREAD_COUNT];
-              CharsetEncoderPtr enc(CharsetEncoder::getEncoder(LOG4CXX_STR("ISO-8859-1")));
-              ThreadPackage* package = new ThreadPackage(enc, THREAD_REPS);
-              { for(int i = 0; i < THREAD_COUNT; i++) {
-                  threads[i].run(thread1Action, package);
-              } }
-              //
-              //   give time for all threads to be launched so
-              //      we don't signal before everybody is waiting.
-              Thread::sleep(100);
-              package->signalAll();
-              for(int i = 0; i < THREAD_COUNT; i++) {
-                  threads[i].join();
-              }
-              LOGUNIT_ASSERT_EQUAL((apr_uint32_t) 0, package->getFail());
-              LOGUNIT_ASSERT_EQUAL((apr_uint32_t) THREAD_COUNT * THREAD_REPS, package->getPass());
-              delete package;
-        }
+		package->await();
+
+		for (int i = 0; i < package->getRepetitions(); i++)
+		{
+			bool pass = true;
+			char buf[BUFSIZE];
+			ByteBuffer out(buf, BUFSIZE);
+			LogString::const_iterator iter = greeting.begin();
+			log4cxx_status_t stat = package->getEncoder()->encode(greeting, iter, out);
+			pass = (false == CharsetEncoder::isError(stat));
+
+			if (pass)
+			{
+				stat = package->getEncoder()->encode(greeting, iter, out);
+				pass = (false == CharsetEncoder::isError(stat));
+
+				if (pass)
+				{
+					out.flip();
+					pass = (sizeof(expected) == out.limit());
+
+					for (size_t i = 0; i < out.limit() && pass; i++)
+					{
+						pass = (expected[i] == out.data()[i]);
+					}
+
+					pass = pass && (iter == greeting.end());
+				}
+			}
+
+			if (pass)
+			{
+				package->pass();
+			}
+			else
+			{
+				package->fail();
+			}
+		}
+
+		return 0;
+	}
+
+	void thread1()
+	{
+		enum { THREAD_COUNT = 10, THREAD_REPS = 10000 };
+		Thread threads[THREAD_COUNT];
+		CharsetEncoderPtr enc(CharsetEncoder::getEncoder(LOG4CXX_STR("ISO-8859-1")));
+		ThreadPackage* package = new ThreadPackage(enc, THREAD_REPS);
+		{
+			for (int i = 0; i < THREAD_COUNT; i++)
+			{
+				threads[i].run(thread1Action, package);
+			}
+		}
+		//
+		//   give time for all threads to be launched so
+		//      we don't signal before everybody is waiting.
+		Thread::sleep(100);
+		package->signalAll();
+
+		for (int i = 0; i < THREAD_COUNT; i++)
+		{
+			threads[i].join();
+		}
+
+		LOGUNIT_ASSERT_EQUAL((apr_uint32_t) 0, package->getFail());
+		LOGUNIT_ASSERT_EQUAL((apr_uint32_t) THREAD_COUNT * THREAD_REPS, package->getPass());
+		delete package;
+	}
 #endif
 
 };
diff --git a/src/test/cpp/helpers/cyclicbuffertestcase.cpp b/src/test/cpp/helpers/cyclicbuffertestcase.cpp
index 05e9065..c644d55 100644
--- a/src/test/cpp/helpers/cyclicbuffertestcase.cpp
+++ b/src/test/cpp/helpers/cyclicbuffertestcase.cpp
@@ -32,138 +32,141 @@
 
 LOGUNIT_CLASS(CyclicBufferTestCase)
 {
-   LOGUNIT_TEST_SUITE(CyclicBufferTestCase);
-      LOGUNIT_TEST(test0);
-      LOGUNIT_TEST(test1);
-      LOGUNIT_TEST(testResize);
-   LOGUNIT_TEST_SUITE_END();
+	LOGUNIT_TEST_SUITE(CyclicBufferTestCase);
+	LOGUNIT_TEST(test0);
+	LOGUNIT_TEST(test1);
+	LOGUNIT_TEST(testResize);
+	LOGUNIT_TEST_SUITE_END();
 
-   LoggerPtr logger;
-   std::vector<LoggingEventPtr> e;
+	LoggerPtr logger;
+	std::vector<LoggingEventPtr> e;
 
 public:
-   void setUp()
-   {
-      e.reserve(1000);
-      LoggingEventPtr event;
-      for (int i = 0; i < MAX; i++)
-      {
-         event = new LoggingEvent(LOG4CXX_STR("x"), Level::getDebug(), LOG4CXX_STR("e"),
-                          log4cxx::spi::LocationInfo::getLocationUnavailable());
-         e.push_back(event);
-      }
-   }
+	void setUp()
+	{
+		e.reserve(1000);
+		LoggingEventPtr event;
 
-   void tearDown()
-   {
-      LogManager::shutdown();
-   }
+		for (int i = 0; i < MAX; i++)
+		{
+			event = new LoggingEvent(LOG4CXX_STR("x"), Level::getDebug(), LOG4CXX_STR("e"),
+				log4cxx::spi::LocationInfo::getLocationUnavailable());
+			e.push_back(event);
+		}
+	}
 
-   void test0()
-   {
-      int size = 2;
+	void tearDown()
+	{
+		LogManager::shutdown();
+	}
 
-      CyclicBuffer cb(size);
-      LOGUNIT_ASSERT_EQUAL(size, cb.getMaxSize());
+	void test0()
+	{
+		int size = 2;
 
-      cb.add(e[0]);
-      LOGUNIT_ASSERT_EQUAL(1, cb.length());
-      LOGUNIT_ASSERT_EQUAL(e[0], cb.get());
-      LOGUNIT_ASSERT_EQUAL(0, cb.length());
-      LOGUNIT_ASSERT(cb.get() == 0);
-      LOGUNIT_ASSERT_EQUAL(0, cb.length());
+		CyclicBuffer cb(size);
+		LOGUNIT_ASSERT_EQUAL(size, cb.getMaxSize());
 
-      CyclicBuffer cb2(size);
-      cb2.add(e[0]);
-      cb2.add(e[1]);
-      LOGUNIT_ASSERT_EQUAL(2, cb2.length());
-      LOGUNIT_ASSERT_EQUAL(e[0], cb2.get());
-      LOGUNIT_ASSERT_EQUAL(1, cb2.length());
-      LOGUNIT_ASSERT_EQUAL(e[1], cb2.get());
-      LOGUNIT_ASSERT_EQUAL(0, cb2.length());
-      LOGUNIT_ASSERT(cb2.get() == 0);
-      LOGUNIT_ASSERT_EQUAL(0, cb2.length());
-   }
+		cb.add(e[0]);
+		LOGUNIT_ASSERT_EQUAL(1, cb.length());
+		LOGUNIT_ASSERT_EQUAL(e[0], cb.get());
+		LOGUNIT_ASSERT_EQUAL(0, cb.length());
+		LOGUNIT_ASSERT(cb.get() == 0);
+		LOGUNIT_ASSERT_EQUAL(0, cb.length());
 
-   void test1()
-   {
-      for (int bufSize = 1; bufSize <= 128; bufSize *= 2)
-         doTest1(bufSize);
-   }
+		CyclicBuffer cb2(size);
+		cb2.add(e[0]);
+		cb2.add(e[1]);
+		LOGUNIT_ASSERT_EQUAL(2, cb2.length());
+		LOGUNIT_ASSERT_EQUAL(e[0], cb2.get());
+		LOGUNIT_ASSERT_EQUAL(1, cb2.length());
+		LOGUNIT_ASSERT_EQUAL(e[1], cb2.get());
+		LOGUNIT_ASSERT_EQUAL(0, cb2.length());
+		LOGUNIT_ASSERT(cb2.get() == 0);
+		LOGUNIT_ASSERT_EQUAL(0, cb2.length());
+	}
 
-   void doTest1(int size)
-   {
-      //System.out.println("Doing test with size = "+size);
-      CyclicBuffer cb(size);
+	void test1()
+	{
+		for (int bufSize = 1; bufSize <= 128; bufSize *= 2)
+		{
+			doTest1(bufSize);
+		}
+	}
 
-      LOGUNIT_ASSERT_EQUAL(size, cb.getMaxSize());
+	void doTest1(int size)
+	{
+		//System.out.println("Doing test with size = "+size);
+		CyclicBuffer cb(size);
 
-      int i;
+		LOGUNIT_ASSERT_EQUAL(size, cb.getMaxSize());
 
-      for (i = -(size + 10); i < (size + 10); i++)
-      {
-         LOGUNIT_ASSERT(cb.get(i) == 0);
-      }
+		int i;
 
-      for (i = 0; i < MAX; i++)
-      {
-         cb.add(e[i]);
+		for (i = -(size + 10); i < (size + 10); i++)
+		{
+			LOGUNIT_ASSERT(cb.get(i) == 0);
+		}
 
-         int limit = (i < (size - 1)) ? i : (size - 1);
+		for (i = 0; i < MAX; i++)
+		{
+			cb.add(e[i]);
 
-         //System.out.println("\nLimit is " + limit + ", i="+i);
-         for (int j = limit; j >= 0; j--)
-         {
-            //System.out.println("i= "+i+", j="+j);
-            LOGUNIT_ASSERT_EQUAL(e[i - (limit - j)], cb.get(j));
-         }
+			int limit = (i < (size - 1)) ? i : (size - 1);
 
-         LOGUNIT_ASSERT(cb.get(-1) == 0);
-         LOGUNIT_ASSERT(cb.get(limit + 1) == 0);
-      }
-   }
+			//System.out.println("\nLimit is " + limit + ", i="+i);
+			for (int j = limit; j >= 0; j--)
+			{
+				//System.out.println("i= "+i+", j="+j);
+				LOGUNIT_ASSERT_EQUAL(e[i - (limit - j)], cb.get(j));
+			}
 
-   void testResize()
-   {
-      for (int isize = 1; isize <= 128; isize *= 2)
-      {
-         doTestResize(isize, (isize / 2) + 1, (isize / 2) + 1);
-         doTestResize(isize, (isize / 2) + 1, isize + 10);
-         doTestResize(isize, isize + 10, (isize / 2) + 1);
-         doTestResize(isize, isize + 10, isize + 10);
-      }
+			LOGUNIT_ASSERT(cb.get(-1) == 0);
+			LOGUNIT_ASSERT(cb.get(limit + 1) == 0);
+		}
+	}
 
-   }
+	void testResize()
+	{
+		for (int isize = 1; isize <= 128; isize *= 2)
+		{
+			doTestResize(isize, (isize / 2) + 1, (isize / 2) + 1);
+			doTestResize(isize, (isize / 2) + 1, isize + 10);
+			doTestResize(isize, isize + 10, (isize / 2) + 1);
+			doTestResize(isize, isize + 10, isize + 10);
+		}
 
-   void doTestResize(int initialSize, int numberOfAdds, int newSize)
-   {
-      //System.out.println("initialSize = "+initialSize+", numberOfAdds="
-      //        +numberOfAdds+", newSize="+newSize);
-      CyclicBuffer cb(initialSize);
+	}
 
-      for (int i = 0; i < numberOfAdds; i++)
-      {
-         cb.add(e[i]);
-      }
+	void doTestResize(int initialSize, int numberOfAdds, int newSize)
+	{
+		//System.out.println("initialSize = "+initialSize+", numberOfAdds="
+		//        +numberOfAdds+", newSize="+newSize);
+		CyclicBuffer cb(initialSize);
 
-      cb.resize(newSize);
+		for (int i = 0; i < numberOfAdds; i++)
+		{
+			cb.add(e[i]);
+		}
 
-      int offset = numberOfAdds - initialSize;
+		cb.resize(newSize);
 
-      if (offset < 0)
-      {
-         offset = 0;
-      }
+		int offset = numberOfAdds - initialSize;
 
-      int len = (newSize < numberOfAdds) ? newSize : numberOfAdds;
-      len = (len < initialSize) ? len : initialSize;
+		if (offset < 0)
+		{
+			offset = 0;
+		}
 
-      //System.out.println("Len = "+len+", offset="+offset);
-      for (int j = 0; j < len; j++)
-      {
-         LOGUNIT_ASSERT_EQUAL(e[offset + j], cb.get(j));
-      }
-   }
+		int len = (newSize < numberOfAdds) ? newSize : numberOfAdds;
+		len = (len < initialSize) ? len : initialSize;
+
+		//System.out.println("Len = "+len+", offset="+offset);
+		for (int j = 0; j < len; j++)
+		{
+			LOGUNIT_ASSERT_EQUAL(e[offset + j], cb.get(j));
+		}
+	}
 };
 
 LOGUNIT_TEST_SUITE_REGISTRATION(CyclicBufferTestCase);
diff --git a/src/test/cpp/helpers/datetimedateformattestcase.cpp b/src/test/cpp/helpers/datetimedateformattestcase.cpp
index 0897bc1..e771404 100644
--- a/src/test/cpp/helpers/datetimedateformattestcase.cpp
+++ b/src/test/cpp/helpers/datetimedateformattestcase.cpp
@@ -31,9 +31,9 @@
 
 #define LOCALE_US "C"
 #if defined(_WIN32)
-#define LOCALE_FR "French_france"
+	#define LOCALE_FR "French_france"
 #else
-#define LOCALE_FR "fr_FR"
+	#define LOCALE_FR "fr_FR"
 #endif
 
 #define LOG4CXX_TEST 1
@@ -44,33 +44,33 @@
 #include <locale>
 #include "localechanger.h"
 #define MAKE_LOCALE(ptr, id)     \
-std::locale loco(id);            \
-std::locale* ptr = &loco;
+	std::locale loco(id);            \
+	std::locale* ptr = &loco;
 #else
 #define MAKE_LOCALE(ptr, id)     \
-std::locale* ptr = NULL;
+	std::locale* ptr = NULL;
 #endif
 
 
 /**
    Unit test {@link DateTimeDateFormat}.
-   
-   
+
+
 */
 LOGUNIT_CLASS(DateTimeDateFormatTestCase)
 {
-  LOGUNIT_TEST_SUITE( DateTimeDateFormatTestCase );
-  LOGUNIT_TEST( test1 );
-  LOGUNIT_TEST( test2 );
-  LOGUNIT_TEST( test3 );
-  LOGUNIT_TEST( test4 );
-  LOGUNIT_TEST( test5 );
-  LOGUNIT_TEST( test6 );
+	LOGUNIT_TEST_SUITE( DateTimeDateFormatTestCase );
+	LOGUNIT_TEST( test1 );
+	LOGUNIT_TEST( test2 );
+	LOGUNIT_TEST( test3 );
+	LOGUNIT_TEST( test4 );
+	LOGUNIT_TEST( test5 );
+	LOGUNIT_TEST( test6 );
 #if LOG4CXX_HAS_STD_LOCALE
-  LOGUNIT_TEST( test7 );
-  LOGUNIT_TEST( test8 );
+	LOGUNIT_TEST( test7 );
+	LOGUNIT_TEST( test8 );
 #endif
-  LOGUNIT_TEST_SUITE_END();
+	LOGUNIT_TEST_SUITE_END();
 
 
 
@@ -79,160 +79,165 @@
 #define MICROSECONDS_PER_DAY APR_INT64_C(86400000000)
 
 
-  /**
-   Asserts that formatting the provided date results in the expected string.
+	/**
+	 Asserts that formatting the provided date results in the expected string.
 
-  @param date Date date
-   @param timeZone TimeZone timezone for conversion
-   @param expected String expected string
-  */
-  void assertFormattedTime( apr_time_t date, const std::locale* locale,
-       const TimeZonePtr& timeZone, const LogString& expected )
-       {
-         DateTimeDateFormat formatter(locale);
-         formatter.setTimeZone(timeZone);
-         LogString actual;
-         Pool p;
-         formatter.format(actual, date, p);
-         LOGUNIT_ASSERT_EQUAL( expected, actual );
-  }
+	@param date Date date
+	 @param timeZone TimeZone timezone for conversion
+	 @param expected String expected string
+	*/
+	void assertFormattedTime( apr_time_t date, const std::locale * locale,
+		const TimeZonePtr & timeZone, const LogString & expected )
+	{
+		DateTimeDateFormat formatter(locale);
+		formatter.setTimeZone(timeZone);
+		LogString actual;
+		Pool p;
+		formatter.format(actual, date, p);
+		LOGUNIT_ASSERT_EQUAL( expected, actual );
+	}
 public:
 
-  /** Convert 02 Jan 2004 00:00:00 GMT for GMT. */
-  void test1()
-  {
-    //
-    //   02 Jan 2004 00:00 GMT
-    //
-    apr_time_t jan2 = MICROSECONDS_PER_DAY * 12419;
-    MAKE_LOCALE(localeUS, LOCALE_US);
-    assertFormattedTime( jan2, localeUS, TimeZone::getGMT(), LOG4CXX_STR("02 Jan 2004 00:00:00,000"));
-  }
+	/** Convert 02 Jan 2004 00:00:00 GMT for GMT. */
+	void test1()
+	{
+		//
+		//   02 Jan 2004 00:00 GMT
+		//
+		apr_time_t jan2 = MICROSECONDS_PER_DAY * 12419;
+		MAKE_LOCALE(localeUS, LOCALE_US);
+		assertFormattedTime( jan2, localeUS, TimeZone::getGMT(), LOG4CXX_STR("02 Jan 2004 00:00:00,000"));
+	}
 
-  /** Convert 03 Jan 2004 00:00:00 GMT for America/Chicago. */
-  void test2()
-  {
-    //
-    //   03 Jan 2004 00:00 GMT
-    apr_time_t jan3 = MICROSECONDS_PER_DAY * 12420;
-    MAKE_LOCALE(localeUS, LOCALE_US);
-    assertFormattedTime( jan3, localeUS,
-             TimeZone::getTimeZone(LOG4CXX_STR("GMT-6")),
-             LOG4CXX_STR("02 Jan 2004 18:00:00,000"));
-  }
+	/** Convert 03 Jan 2004 00:00:00 GMT for America/Chicago. */
+	void test2()
+	{
+		//
+		//   03 Jan 2004 00:00 GMT
+		apr_time_t jan3 = MICROSECONDS_PER_DAY * 12420;
+		MAKE_LOCALE(localeUS, LOCALE_US);
+		assertFormattedTime( jan3, localeUS,
+			TimeZone::getTimeZone(LOG4CXX_STR("GMT-6")),
+			LOG4CXX_STR("02 Jan 2004 18:00:00,000"));
+	}
 
 
-  /** Convert 30 Jun 2004 00:00:00 GMT for GMT. */
-  void test3()
-  {
-    apr_time_t jun30 = MICROSECONDS_PER_DAY * 12599;
-    MAKE_LOCALE(localeUS, LOCALE_US);
-    assertFormattedTime( jun30, localeUS, TimeZone::getGMT(),
-           LOG4CXX_STR("30 Jun 2004 00:00:00,000"));
-  }
+	/** Convert 30 Jun 2004 00:00:00 GMT for GMT. */
+	void test3()
+	{
+		apr_time_t jun30 = MICROSECONDS_PER_DAY * 12599;
+		MAKE_LOCALE(localeUS, LOCALE_US);
+		assertFormattedTime( jun30, localeUS, TimeZone::getGMT(),
+			LOG4CXX_STR("30 Jun 2004 00:00:00,000"));
+	}
 
-  /** Convert 29 Jun 2004 00:00:00 GMT for Chicago, daylight savings in effect. */
-  void test4()
-  {
-    apr_time_t jul1 = MICROSECONDS_PER_DAY * 12600;
-    MAKE_LOCALE(localeUS, LOCALE_US);
-    assertFormattedTime( jul1, localeUS,
-           TimeZone::getTimeZone(LOG4CXX_STR("GMT-5")),
-           LOG4CXX_STR("30 Jun 2004 19:00:00,000"));
-  }
+	/** Convert 29 Jun 2004 00:00:00 GMT for Chicago, daylight savings in effect. */
+	void test4()
+	{
+		apr_time_t jul1 = MICROSECONDS_PER_DAY * 12600;
+		MAKE_LOCALE(localeUS, LOCALE_US);
+		assertFormattedTime( jul1, localeUS,
+			TimeZone::getTimeZone(LOG4CXX_STR("GMT-5")),
+			LOG4CXX_STR("30 Jun 2004 19:00:00,000"));
+	}
 
-  /** Test multiple calls in close intervals. */
-  void test5()
-  {
-    //   subsequent calls within one minute
-    //     are optimized to reuse previous formatted value
-    //     make a couple of nearly spaced calls
-    apr_time_t ticks = MICROSECONDS_PER_DAY * 12601;
-    MAKE_LOCALE(localeUS, LOCALE_US);
-    assertFormattedTime( ticks, localeUS, TimeZone::getGMT(),
-           LOG4CXX_STR("02 Jul 2004 00:00:00,000"));
-    assertFormattedTime( ticks + 8000, localeUS, TimeZone::getGMT(),
-           LOG4CXX_STR("02 Jul 2004 00:00:00,008"));
-    assertFormattedTime( ticks + 17000, localeUS, TimeZone::getGMT(),
-           LOG4CXX_STR("02 Jul 2004 00:00:00,017"));
-    assertFormattedTime( ticks + 237000, localeUS, TimeZone::getGMT(),
-           LOG4CXX_STR("02 Jul 2004 00:00:00,237"));
-    assertFormattedTime( ticks + 1415000, localeUS, TimeZone::getGMT(),
-           LOG4CXX_STR("02 Jul 2004 00:00:01,415"));
-  }
+	/** Test multiple calls in close intervals. */
+	void test5()
+	{
+		//   subsequent calls within one minute
+		//     are optimized to reuse previous formatted value
+		//     make a couple of nearly spaced calls
+		apr_time_t ticks = MICROSECONDS_PER_DAY * 12601;
+		MAKE_LOCALE(localeUS, LOCALE_US);
+		assertFormattedTime( ticks, localeUS, TimeZone::getGMT(),
+			LOG4CXX_STR("02 Jul 2004 00:00:00,000"));
+		assertFormattedTime( ticks + 8000, localeUS, TimeZone::getGMT(),
+			LOG4CXX_STR("02 Jul 2004 00:00:00,008"));
+		assertFormattedTime( ticks + 17000, localeUS, TimeZone::getGMT(),
+			LOG4CXX_STR("02 Jul 2004 00:00:00,017"));
+		assertFormattedTime( ticks + 237000, localeUS, TimeZone::getGMT(),
+			LOG4CXX_STR("02 Jul 2004 00:00:00,237"));
+		assertFormattedTime( ticks + 1415000, localeUS, TimeZone::getGMT(),
+			LOG4CXX_STR("02 Jul 2004 00:00:01,415"));
+	}
 
-  /** Check that caching does not disregard timezone. This test would fail for revision 1.4 of DateTimeDateFormat.java. */
-  void test6()
-  {
-    apr_time_t jul3 = MICROSECONDS_PER_DAY * 12602;
-    MAKE_LOCALE(localeUS, LOCALE_US);
-    assertFormattedTime( jul3, localeUS, TimeZone::getGMT(),
-        LOG4CXX_STR("03 Jul 2004 00:00:00,000"));
-    assertFormattedTime( jul3, localeUS,
-          TimeZone::getTimeZone(LOG4CXX_STR("GMT-5")),
-          LOG4CXX_STR("02 Jul 2004 19:00:00,000"));
-    assertFormattedTime( jul3, localeUS, TimeZone::getGMT(),
-          LOG4CXX_STR("03 Jul 2004 00:00:00,000"));
-  }
+	/** Check that caching does not disregard timezone. This test would fail for revision 1.4 of DateTimeDateFormat.java. */
+	void test6()
+	{
+		apr_time_t jul3 = MICROSECONDS_PER_DAY * 12602;
+		MAKE_LOCALE(localeUS, LOCALE_US);
+		assertFormattedTime( jul3, localeUS, TimeZone::getGMT(),
+			LOG4CXX_STR("03 Jul 2004 00:00:00,000"));
+		assertFormattedTime( jul3, localeUS,
+			TimeZone::getTimeZone(LOG4CXX_STR("GMT-5")),
+			LOG4CXX_STR("02 Jul 2004 19:00:00,000"));
+		assertFormattedTime( jul3, localeUS, TimeZone::getGMT(),
+			LOG4CXX_STR("03 Jul 2004 00:00:00,000"));
+	}
 
 #if LOG4CXX_HAS_STD_LOCALE
-  LogString formatDate(const std::locale& locale, const tm& date, const LogString& fmt) {
-        //
-        //  output the using STL
-        //
-        std::basic_ostringstream<logchar> buffer;
+	LogString formatDate(const std::locale & locale, const tm & date, const LogString & fmt)
+	{
+		//
+		//  output the using STL
+		//
+		std::basic_ostringstream<logchar> buffer;
 #if defined(_MSC_VER) && _MSC_VER < 1300
-         _USEFAC(locale, std::time_put<logchar>)
-             .put(buffer, buffer, &date, fmt.c_str(), fmt.c_str() + fmt.length());
+		_USEFAC(locale, std::time_put<logchar>)
+		.put(buffer, buffer, &date, fmt.c_str(), fmt.c_str() + fmt.length());
 #else
 #if defined(_RWSTD_NO_TEMPLATE_ON_RETURN_TYPE)
-         const std::time_put<logchar>& facet = std::use_facet(locale, (std::time_put<logchar>*) 0);
+		const std::time_put<logchar>& facet = std::use_facet(locale, (std::time_put<logchar>*) 0);
 #else
-         const std::time_put<logchar>& facet = std::use_facet<std::time_put<logchar> >(locale);
+		const std::time_put<logchar>& facet = std::use_facet<std::time_put<logchar> >(locale);
 #endif
-         facet.put(buffer, buffer, buffer.fill(), &date, fmt.c_str(), fmt.c_str() + fmt.length());
+		facet.put(buffer, buffer, buffer.fill(), &date, fmt.c_str(), fmt.c_str() + fmt.length());
 #endif
-        return buffer.str();
-  }
+		return buffer.str();
+	}
 
-  /** Check that format is locale sensitive. */
-  void test7()
-  {
-    apr_time_t avr11 = MICROSECONDS_PER_DAY * 12519;
-    LocaleChanger localeChange(LOCALE_FR);
-    if (localeChange.isEffective()) {
-        LogString formatted;
-        Pool p;
-        SimpleDateFormat formatter(LOG4CXX_STR("MMM"));
-        formatter.format(formatted, avr11, p);
+	/** Check that format is locale sensitive. */
+	void test7()
+	{
+		apr_time_t avr11 = MICROSECONDS_PER_DAY * 12519;
+		LocaleChanger localeChange(LOCALE_FR);
 
-        std::locale localeFR(LOCALE_FR);
-        struct tm avr11tm = { 0, 0, 0, 11, 03, 104 };
-        LogString expected(formatDate(localeFR, avr11tm, LOG4CXX_STR("%b")));
+		if (localeChange.isEffective())
+		{
+			LogString formatted;
+			Pool p;
+			SimpleDateFormat formatter(LOG4CXX_STR("MMM"));
+			formatter.format(formatted, avr11, p);
 
-        LOGUNIT_ASSERT_EQUAL(expected, formatted);
-    }
-  }
+			std::locale localeFR(LOCALE_FR);
+			struct tm avr11tm = { 0, 0, 0, 11, 03, 104 };
+			LogString expected(formatDate(localeFR, avr11tm, LOG4CXX_STR("%b")));
 
-  /** Check that format is locale sensitive. */
-  void test8()
-  {
-    apr_time_t apr11 = MICROSECONDS_PER_DAY * 12519;
-    LocaleChanger localeChange(LOCALE_US);
-    if (localeChange.isEffective()) {
-        LogString formatted;
-        Pool p;
-        SimpleDateFormat formatter(LOG4CXX_STR("MMM"));
-        formatter.setTimeZone(TimeZone::getGMT());
-        formatter.format(formatted, apr11, p);
+			LOGUNIT_ASSERT_EQUAL(expected, formatted);
+		}
+	}
 
-        std::locale localeUS(LOCALE_US);
-        struct tm apr11tm = { 0, 0, 0, 11, 03, 104 };
-        LogString expected(formatDate(localeUS, apr11tm, LOG4CXX_STR("%b")));
+	/** Check that format is locale sensitive. */
+	void test8()
+	{
+		apr_time_t apr11 = MICROSECONDS_PER_DAY * 12519;
+		LocaleChanger localeChange(LOCALE_US);
 
-        LOGUNIT_ASSERT_EQUAL(expected, formatted);
-    }
-  }
+		if (localeChange.isEffective())
+		{
+			LogString formatted;
+			Pool p;
+			SimpleDateFormat formatter(LOG4CXX_STR("MMM"));
+			formatter.setTimeZone(TimeZone::getGMT());
+			formatter.format(formatted, apr11, p);
+
+			std::locale localeUS(LOCALE_US);
+			struct tm apr11tm = { 0, 0, 0, 11, 03, 104 };
+			LogString expected(formatDate(localeUS, apr11tm, LOG4CXX_STR("%b")));
+
+			LOGUNIT_ASSERT_EQUAL(expected, formatted);
+		}
+	}
 #endif
 
 };
diff --git a/src/test/cpp/helpers/filewatchdogtest.cpp b/src/test/cpp/helpers/filewatchdogtest.cpp
index 87a972a..67cae70 100644
--- a/src/test/cpp/helpers/filewatchdogtest.cpp
+++ b/src/test/cpp/helpers/filewatchdogtest.cpp
@@ -27,38 +27,43 @@
  *
  * FileWatchdog tests.
  */
-LOGUNIT_CLASS(FileWatchdogTest) {
-  LOGUNIT_TEST_SUITE(FileWatchdogTest);
-          LOGUNIT_TEST(testShutdownDelay);
-  LOGUNIT_TEST_SUITE_END();
-  
+LOGUNIT_CLASS(FileWatchdogTest)
+{
+	LOGUNIT_TEST_SUITE(FileWatchdogTest);
+	LOGUNIT_TEST(testShutdownDelay);
+	LOGUNIT_TEST_SUITE_END();
+
 private:
-    class MockWatchdog : public FileWatchdog {
-    public:
-        MockWatchdog(const File& file) : FileWatchdog(file) {
-        }
-        
-        void doOnChange() {
-        }
-    };
-    
+	class MockWatchdog : public FileWatchdog
+	{
+		public:
+			MockWatchdog(const File& file) : FileWatchdog(file)
+			{
+			}
+
+			void doOnChange()
+			{
+			}
+	};
+
 public:
-  
-  /**
-   *  Tests that FileWatchdog will respond to a shutdown request more rapidly
-   *     than waiting out its delay. 
-   */
-  void testShutdownDelay() {
-      apr_time_t start = apr_time_now();
-      {
-        MockWatchdog dog(File(LOG4CXX_STR("input/patternlayout1.properties")));
-        dog.start();
-        //   wait 50 ms for thread to get rolling 
-        apr_sleep(50000);
-      }
-      apr_time_t delta = apr_time_now() - start;
-      LOGUNIT_ASSERT(delta < 30000000);
-  }
+
+	/**
+	 *  Tests that FileWatchdog will respond to a shutdown request more rapidly
+	 *     than waiting out its delay.
+	 */
+	void testShutdownDelay()
+	{
+		apr_time_t start = apr_time_now();
+		{
+			MockWatchdog dog(File(LOG4CXX_STR("input/patternlayout1.properties")));
+			dog.start();
+			//   wait 50 ms for thread to get rolling
+			apr_sleep(50000);
+		}
+		apr_time_t delta = apr_time_now() - start;
+		LOGUNIT_ASSERT(delta < 30000000);
+	}
 
 };
 
diff --git a/src/test/cpp/helpers/inetaddresstestcase.cpp b/src/test/cpp/helpers/inetaddresstestcase.cpp
index 9077752..b29ca5c 100644
--- a/src/test/cpp/helpers/inetaddresstestcase.cpp
+++ b/src/test/cpp/helpers/inetaddresstestcase.cpp
@@ -24,60 +24,65 @@
 
 LOGUNIT_CLASS(InetAddressTestCase)
 {
-        LOGUNIT_TEST_SUITE(InetAddressTestCase);
-                LOGUNIT_TEST(testGetLocalHost);
-                LOGUNIT_TEST(testByNameLocal);
-                LOGUNIT_TEST(testAllByNameLocal);
-                LOGUNIT_TEST(testUnreachable);
-        LOGUNIT_TEST_SUITE_END();
+	LOGUNIT_TEST_SUITE(InetAddressTestCase);
+	LOGUNIT_TEST(testGetLocalHost);
+	LOGUNIT_TEST(testByNameLocal);
+	LOGUNIT_TEST(testAllByNameLocal);
+	LOGUNIT_TEST(testUnreachable);
+	LOGUNIT_TEST_SUITE_END();
 
 public:
-        /**
-         * Tests the InetAddress::getLocalHost() method.
-         */
-        void testGetLocalHost() {
-           InetAddressPtr addr = InetAddress::getLocalHost();
+	/**
+	 * Tests the InetAddress::getLocalHost() method.
+	 */
+	void testGetLocalHost()
+	{
+		InetAddressPtr addr = InetAddress::getLocalHost();
 
-           LOGUNIT_ASSERT(addr->getHostAddress() == LOG4CXX_STR("127.0.0.1"));
-           LOGUNIT_ASSERT(!addr->getHostName().empty());
-        }
+		LOGUNIT_ASSERT(addr->getHostAddress() == LOG4CXX_STR("127.0.0.1"));
+		LOGUNIT_ASSERT(!addr->getHostName().empty());
+	}
 
-        /**
-         * Tests the InetAddress::getByName() method with the
-         * "localhost" host name.
-         */
-        void testByNameLocal() {
-           InetAddressPtr addr = InetAddress::getByName(LOG4CXX_STR("localhost"));
+	/**
+	 * Tests the InetAddress::getByName() method with the
+	 * "localhost" host name.
+	 */
+	void testByNameLocal()
+	{
+		InetAddressPtr addr = InetAddress::getByName(LOG4CXX_STR("localhost"));
 
-           LOGUNIT_ASSERT(addr->getHostAddress() == LOG4CXX_STR("127.0.0.1"));
-           LOGUNIT_ASSERT(!addr->getHostName().empty());
-        }
+		LOGUNIT_ASSERT(addr->getHostAddress() == LOG4CXX_STR("127.0.0.1"));
+		LOGUNIT_ASSERT(!addr->getHostName().empty());
+	}
 
-        /**
-         * Tests the InetAddress::getAllByName() method with the
-         * "localhost" host name.
-         */
-        void testAllByNameLocal() {
-           std::vector<InetAddressPtr> addr = InetAddress::getAllByName(LOG4CXX_STR("localhost"));
+	/**
+	 * Tests the InetAddress::getAllByName() method with the
+	 * "localhost" host name.
+	 */
+	void testAllByNameLocal()
+	{
+		std::vector<InetAddressPtr> addr = InetAddress::getAllByName(LOG4CXX_STR("localhost"));
 
-           LOGUNIT_ASSERT(addr.size() > 0);
-        }
+		LOGUNIT_ASSERT(addr.size() > 0);
+	}
 
-        /**
-         * Tests the UnknownHostException.
-         */
-        void testUnknownHost() {
-           InetAddressPtr addr = InetAddress::getByName(LOG4CXX_STR("unknown.invalid"));
-        }
-      
-    /**
-    * Tests an (likely) unreachable address.
-    */
-      void testUnreachable()  {
-       InetAddressPtr addr(InetAddress::getByName(LOG4CXX_STR("192.168.10.254")));
-      LogString addrStr(addr->toString());
-      LOGUNIT_ASSERT_EQUAL(addrStr.size() - 15, addrStr.find(LOG4CXX_STR("/192.168.10.254")));
-   }
+	/**
+	 * Tests the UnknownHostException.
+	 */
+	void testUnknownHost()
+	{
+		InetAddressPtr addr = InetAddress::getByName(LOG4CXX_STR("unknown.invalid"));
+	}
+
+	/**
+	* Tests an (likely) unreachable address.
+	*/
+	void testUnreachable()
+	{
+		InetAddressPtr addr(InetAddress::getByName(LOG4CXX_STR("192.168.10.254")));
+		LogString addrStr(addr->toString());
+		LOGUNIT_ASSERT_EQUAL(addrStr.size() - 15, addrStr.find(LOG4CXX_STR("/192.168.10.254")));
+	}
 
 };
 
diff --git a/src/test/cpp/helpers/iso8601dateformattestcase.cpp b/src/test/cpp/helpers/iso8601dateformattestcase.cpp
index 7aa7247..13e63a6 100644
--- a/src/test/cpp/helpers/iso8601dateformattestcase.cpp
+++ b/src/test/cpp/helpers/iso8601dateformattestcase.cpp
@@ -20,7 +20,7 @@
 #define LOG4CXX_TEST
 #include <log4cxx/private/log4cxx_private.h>
 #if LOG4CXX_HAS_STD_LOCALE
-#include <locale>
+	#include <locale>
 #endif
 #include "../insertwide.h"
 #include <log4cxx/helpers/pool.h>
@@ -33,125 +33,134 @@
 
 /**
    Unit test {@link ISO8601DateFormat}.
-   
-   */
-LOGUNIT_CLASS(ISO8601DateFormatTestCase) {
-     LOGUNIT_TEST_SUITE( ISO8601DateFormatTestCase );
-     LOGUNIT_TEST( test1 );
-     LOGUNIT_TEST( test2 );
-     LOGUNIT_TEST( test3 );
-     LOGUNIT_TEST( test4 );
-     LOGUNIT_TEST( test5 );
-     LOGUNIT_TEST( test6 );
-     LOGUNIT_TEST( test7 );
-     LOGUNIT_TEST_SUITE_END();
 
-  /**
-   * Asserts that formatting the provided date results
-   * in the expected string.
-   *
-   * @param date Date date
-   * @param timeZone TimeZone timezone for conversion
-   * @param expected String expected string
    */
-  void assertFormattedTime(log4cxx_time_t date,
-                           const TimeZonePtr& timeZone,
-                           const LogString& expected) {
-    ISO8601DateFormat formatter;
-    formatter.setTimeZone(timeZone);
-    LogString actual;
-    Pool p;
-    formatter.format(actual, date, p);
-    LOGUNIT_ASSERT_EQUAL(expected, actual);
-  }
+LOGUNIT_CLASS(ISO8601DateFormatTestCase)
+{
+	LOGUNIT_TEST_SUITE( ISO8601DateFormatTestCase );
+	LOGUNIT_TEST( test1 );
+	LOGUNIT_TEST( test2 );
+	LOGUNIT_TEST( test3 );
+	LOGUNIT_TEST( test4 );
+	LOGUNIT_TEST( test5 );
+	LOGUNIT_TEST( test6 );
+	LOGUNIT_TEST( test7 );
+	LOGUNIT_TEST_SUITE_END();
+
+	/**
+	 * Asserts that formatting the provided date results
+	 * in the expected string.
+	 *
+	 * @param date Date date
+	 * @param timeZone TimeZone timezone for conversion
+	 * @param expected String expected string
+	 */
+	void assertFormattedTime(log4cxx_time_t date,
+		const TimeZonePtr & timeZone,
+		const LogString & expected)
+	{
+		ISO8601DateFormat formatter;
+		formatter.setTimeZone(timeZone);
+		LogString actual;
+		Pool p;
+		formatter.format(actual, date, p);
+		LOGUNIT_ASSERT_EQUAL(expected, actual);
+	}
 
 
 public:
-  /**
-   * Convert 02 Jan 2004 00:00:00 GMT for GMT.
-   */
-  void test1() {
-    log4cxx_time_t jan2 = Date::getMicrosecondsPerDay() * 12419;
-    assertFormattedTime(jan2, TimeZone::getGMT(),
-          LOG4CXX_STR("2004-01-02 00:00:00,000"));
-  }
+	/**
+	 * Convert 02 Jan 2004 00:00:00 GMT for GMT.
+	 */
+	void test1()
+	{
+		log4cxx_time_t jan2 = Date::getMicrosecondsPerDay() * 12419;
+		assertFormattedTime(jan2, TimeZone::getGMT(),
+			LOG4CXX_STR("2004-01-02 00:00:00,000"));
+	}
 
-  /**
-   * Convert 03 Jan 2004 00:00:00 GMT for America/Chicago.
-   */
-  void test2() {
-    //
-    //   03 Jan 2004 00:00 GMT
-    //       (asking for the same time at a different timezone
-    //          will ignore the change of timezone)
-    log4cxx_time_t jan3 = Date::getMicrosecondsPerDay() * 12420;
-    assertFormattedTime(jan3, TimeZone::getTimeZone(LOG4CXX_STR("GMT-6")),
-          LOG4CXX_STR("2004-01-02 18:00:00,000"));
-  }
+	/**
+	 * Convert 03 Jan 2004 00:00:00 GMT for America/Chicago.
+	 */
+	void test2()
+	{
+		//
+		//   03 Jan 2004 00:00 GMT
+		//       (asking for the same time at a different timezone
+		//          will ignore the change of timezone)
+		log4cxx_time_t jan3 = Date::getMicrosecondsPerDay() * 12420;
+		assertFormattedTime(jan3, TimeZone::getTimeZone(LOG4CXX_STR("GMT-6")),
+			LOG4CXX_STR("2004-01-02 18:00:00,000"));
+	}
 
 
-  /**
-   * Convert 30 Jun 2004 00:00:00 GMT for GMT.
-   */
-  void test3() {
-    log4cxx_time_t jun30 = Date::getMicrosecondsPerDay() * 12599;
-    assertFormattedTime(jun30, TimeZone::getGMT(),
-          LOG4CXX_STR("2004-06-30 00:00:00,000"));
-  }
+	/**
+	 * Convert 30 Jun 2004 00:00:00 GMT for GMT.
+	 */
+	void test3()
+	{
+		log4cxx_time_t jun30 = Date::getMicrosecondsPerDay() * 12599;
+		assertFormattedTime(jun30, TimeZone::getGMT(),
+			LOG4CXX_STR("2004-06-30 00:00:00,000"));
+	}
 
-  /**
-   * Convert 1 Jul 2004 00:00:00 GMT for Chicago, daylight savings in effect.
-   */
-  void test4() {
-    log4cxx_time_t jul1 = Date::getMicrosecondsPerDay() * 12600;
-    assertFormattedTime(jul1, TimeZone::getTimeZone(LOG4CXX_STR("GMT-5")),
-           LOG4CXX_STR("2004-06-30 19:00:00,000"));
-  }
+	/**
+	 * Convert 1 Jul 2004 00:00:00 GMT for Chicago, daylight savings in effect.
+	 */
+	void test4()
+	{
+		log4cxx_time_t jul1 = Date::getMicrosecondsPerDay() * 12600;
+		assertFormattedTime(jul1, TimeZone::getTimeZone(LOG4CXX_STR("GMT-5")),
+			LOG4CXX_STR("2004-06-30 19:00:00,000"));
+	}
 
-  /**
-   * Test multiple calls in close intervals.
-   */
-  void test5() {
-    //   subsequent calls within one minute
-    //     are optimized to reuse previous formatted value
-    //     make a couple of nearly spaced calls
-    log4cxx_time_t ticks =  Date::getMicrosecondsPerDay() * 12601;
-    assertFormattedTime(ticks, TimeZone::getGMT(),
-          LOG4CXX_STR("2004-07-02 00:00:00,000"));
-    assertFormattedTime(ticks + 8000, TimeZone::getGMT(),
-           LOG4CXX_STR("2004-07-02 00:00:00,008"));
-    assertFormattedTime(ticks + 17000, TimeZone::getGMT(),
-           LOG4CXX_STR("2004-07-02 00:00:00,017"));
-    assertFormattedTime(ticks + 237000, TimeZone::getGMT(),
-           LOG4CXX_STR("2004-07-02 00:00:00,237"));
-    assertFormattedTime(ticks + 1415000, TimeZone::getGMT(),
-           LOG4CXX_STR("2004-07-02 00:00:01,415"));
-  }
+	/**
+	 * Test multiple calls in close intervals.
+	 */
+	void test5()
+	{
+		//   subsequent calls within one minute
+		//     are optimized to reuse previous formatted value
+		//     make a couple of nearly spaced calls
+		log4cxx_time_t ticks =  Date::getMicrosecondsPerDay() * 12601;
+		assertFormattedTime(ticks, TimeZone::getGMT(),
+			LOG4CXX_STR("2004-07-02 00:00:00,000"));
+		assertFormattedTime(ticks + 8000, TimeZone::getGMT(),
+			LOG4CXX_STR("2004-07-02 00:00:00,008"));
+		assertFormattedTime(ticks + 17000, TimeZone::getGMT(),
+			LOG4CXX_STR("2004-07-02 00:00:00,017"));
+		assertFormattedTime(ticks + 237000, TimeZone::getGMT(),
+			LOG4CXX_STR("2004-07-02 00:00:00,237"));
+		assertFormattedTime(ticks + 1415000, TimeZone::getGMT(),
+			LOG4CXX_STR("2004-07-02 00:00:01,415"));
+	}
 
-  /**
-   *  Check that caching does not disregard timezone.
-   * This test would fail for revision 1.4 of DateTimeDateFormat.java.
-   */
-  void test6() {
-    log4cxx_time_t jul3 =  Date::getMicrosecondsPerDay() * 12602;
-    assertFormattedTime(jul3, TimeZone::getGMT(),
-           LOG4CXX_STR("2004-07-03 00:00:00,000"));
-    assertFormattedTime(jul3, TimeZone::getTimeZone(LOG4CXX_STR("GMT-5")),
-           LOG4CXX_STR("2004-07-02 19:00:00,000"));
-    assertFormattedTime(jul3, TimeZone::getGMT(),
-           LOG4CXX_STR("2004-07-03 00:00:00,000"));
-  }
+	/**
+	 *  Check that caching does not disregard timezone.
+	 * This test would fail for revision 1.4 of DateTimeDateFormat.java.
+	 */
+	void test6()
+	{
+		log4cxx_time_t jul3 =  Date::getMicrosecondsPerDay() * 12602;
+		assertFormattedTime(jul3, TimeZone::getGMT(),
+			LOG4CXX_STR("2004-07-03 00:00:00,000"));
+		assertFormattedTime(jul3, TimeZone::getTimeZone(LOG4CXX_STR("GMT-5")),
+			LOG4CXX_STR("2004-07-02 19:00:00,000"));
+		assertFormattedTime(jul3, TimeZone::getGMT(),
+			LOG4CXX_STR("2004-07-03 00:00:00,000"));
+	}
 
-  /**
-   * Checks that numberFormat is implemented.
-   */
-  void test7() {
-    LogString number;
-    ISO8601DateFormat formatter;
-    Pool p;
-    formatter.numberFormat(number, 87, p);
-    LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("87"), number);
-  }
+	/**
+	 * Checks that numberFormat is implemented.
+	 */
+	void test7()
+	{
+		LogString number;
+		ISO8601DateFormat formatter;
+		Pool p;
+		formatter.numberFormat(number, 87, p);
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("87"), number);
+	}
 
 
 
diff --git a/src/test/cpp/helpers/localechanger.cpp b/src/test/cpp/helpers/localechanger.cpp
index 9c9b00b..8dce3c6 100644
--- a/src/test/cpp/helpers/localechanger.cpp
+++ b/src/test/cpp/helpers/localechanger.cpp
@@ -27,24 +27,33 @@
 *   Construction attemtps to change default locale.
 * @param locale locale.
 */
-LocaleChanger::LocaleChanger(const char* locale) {
-    effective = false;
-    try {
-        std::locale newLocale(locale);
-        initial = std::locale::global(newLocale);
-        effective = true;
-    } catch(std::runtime_error&) {
-    } catch(std::exception&) {
-    }
-  }
+LocaleChanger::LocaleChanger(const char* locale)
+{
+	effective = false;
+
+	try
+	{
+		std::locale newLocale(locale);
+		initial = std::locale::global(newLocale);
+		effective = true;
+	}
+	catch (std::runtime_error&)
+	{
+	}
+	catch (std::exception&)
+	{
+	}
+}
 
 /**
 * Restores previous locale.
 */
-LocaleChanger::~LocaleChanger() {
-      if (effective) {
-        std::locale::global(initial);
-      }
-  }
+LocaleChanger::~LocaleChanger()
+{
+	if (effective)
+	{
+		std::locale::global(initial);
+	}
+}
 
 #endif
diff --git a/src/test/cpp/helpers/localechanger.h b/src/test/cpp/helpers/localechanger.h
index ef902b9..b001d11 100644
--- a/src/test/cpp/helpers/localechanger.h
+++ b/src/test/cpp/helpers/localechanger.h
@@ -20,40 +20,46 @@
 
 #include <locale>
 
-namespace log4cxx {
-  namespace helpers {
-    /**
-    *   Utility class to change the locale for the duration of a test.
-    *
-    * 
-    * 
-    *
-    */
-    class LocaleChanger {
-    public:
-    /**
-    *   Construction attemtps to change default locale.
-    * @param locale locale.
-    */
-       LocaleChanger(const char* locale);
+namespace log4cxx
+{
+namespace helpers
+{
+/**
+*   Utility class to change the locale for the duration of a test.
+*
+*
+*
+*
+*/
+class LocaleChanger
+{
+	public:
+		/**
+		*   Construction attemtps to change default locale.
+		* @param locale locale.
+		*/
+		LocaleChanger(const char* locale);
 
-    /**
-    * Restores previous locale.
-    */
-      ~LocaleChanger();
+		/**
+		* Restores previous locale.
+		*/
+		~LocaleChanger();
 
-      /**
-      * Determines whether locale change was effective.
-      * @return true if effective.
-      */
-      inline bool isEffective() { return effective; }
+		/**
+		* Determines whether locale change was effective.
+		* @return true if effective.
+		*/
+		inline bool isEffective()
+		{
+			return effective;
+		}
 
-    private:
-      LocaleChanger(LocaleChanger&);
-      LocaleChanger& operator=(LocaleChanger&);
-      std::locale initial;
-      bool effective;
-    };
-  }
+	private:
+		LocaleChanger(LocaleChanger&);
+		LocaleChanger& operator=(LocaleChanger&);
+		std::locale initial;
+		bool effective;
+};
+}
 }
 #endif
diff --git a/src/test/cpp/helpers/messagebuffertest.cpp b/src/test/cpp/helpers/messagebuffertest.cpp
index ea2ed34..b0dee79 100644
--- a/src/test/cpp/helpers/messagebuffertest.cpp
+++ b/src/test/cpp/helpers/messagebuffertest.cpp
@@ -14,7 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
- 
+
 #include <log4cxx/helpers/messagebuffer.h>
 #include <iomanip>
 #include "../insertwide.h"
@@ -22,7 +22,7 @@
 #include <log4cxx/logstring.h>
 
 #if LOG4CXX_CFSTRING_API
-#include <CoreFoundation/CFString.h>
+	#include <CoreFoundation/CFString.h>
 #endif
 
 using namespace log4cxx;
@@ -33,160 +33,176 @@
  */
 LOGUNIT_CLASS(MessageBufferTest)
 {
-   LOGUNIT_TEST_SUITE(MessageBufferTest);
-      LOGUNIT_TEST(testInsertChar);
-      LOGUNIT_TEST(testInsertConstStr);
-      LOGUNIT_TEST(testInsertStr);
-      LOGUNIT_TEST(testInsertString);
-      LOGUNIT_TEST(testInsertNull);
-      LOGUNIT_TEST(testInsertInt);
-      LOGUNIT_TEST(testInsertManipulator);
+	LOGUNIT_TEST_SUITE(MessageBufferTest);
+	LOGUNIT_TEST(testInsertChar);
+	LOGUNIT_TEST(testInsertConstStr);
+	LOGUNIT_TEST(testInsertStr);
+	LOGUNIT_TEST(testInsertString);
+	LOGUNIT_TEST(testInsertNull);
+	LOGUNIT_TEST(testInsertInt);
+	LOGUNIT_TEST(testInsertManipulator);
 #if LOG4CXX_WCHAR_T_API
-      LOGUNIT_TEST(testInsertConstWStr);
-      LOGUNIT_TEST(testInsertWString);
-      LOGUNIT_TEST(testInsertWStr);
+	LOGUNIT_TEST(testInsertConstWStr);
+	LOGUNIT_TEST(testInsertWString);
+	LOGUNIT_TEST(testInsertWStr);
 #endif
 #if LOG4CXX_UNICHAR_API
-      LOGUNIT_TEST(testInsertConstUStr);
-      LOGUNIT_TEST(testInsertUString);
+	LOGUNIT_TEST(testInsertConstUStr);
+	LOGUNIT_TEST(testInsertUString);
 #endif
 #if LOG4CXX_CFSTRING_API
-      LOGUNIT_TEST(testInsertCFString);
+	LOGUNIT_TEST(testInsertCFString);
 #endif
-   LOGUNIT_TEST_SUITE_END();
+	LOGUNIT_TEST_SUITE_END();
 
 
 public:
-    void testInsertChar() {
-        MessageBuffer buf;
-        std::string greeting("Hello, World");
-        CharMessageBuffer& retval = buf << "Hello, Worl" << 'd';
-        LOGUNIT_ASSERT_EQUAL(greeting, buf.str(retval)); 
-        LOGUNIT_ASSERT_EQUAL(false, buf.hasStream());
-    }
+	void testInsertChar()
+	{
+		MessageBuffer buf;
+		std::string greeting("Hello, World");
+		CharMessageBuffer& retval = buf << "Hello, Worl" << 'd';
+		LOGUNIT_ASSERT_EQUAL(greeting, buf.str(retval));
+		LOGUNIT_ASSERT_EQUAL(false, buf.hasStream());
+	}
 
-    void testInsertConstStr() {
-        MessageBuffer buf;
-        std::string greeting("Hello, World");
-        CharMessageBuffer& retval = buf << "Hello" << ", World";
-        LOGUNIT_ASSERT_EQUAL(greeting, buf.str(retval)); 
-        LOGUNIT_ASSERT_EQUAL(false, buf.hasStream());
-    }
+	void testInsertConstStr()
+	{
+		MessageBuffer buf;
+		std::string greeting("Hello, World");
+		CharMessageBuffer& retval = buf << "Hello" << ", World";
+		LOGUNIT_ASSERT_EQUAL(greeting, buf.str(retval));
+		LOGUNIT_ASSERT_EQUAL(false, buf.hasStream());
+	}
 
-    void testInsertStr() {
-        MessageBuffer buf;
-        std::string greeting("Hello, World");
-   char* part1 = (char*) malloc(10*sizeof(wchar_t));
-   strcpy(part1, "Hello");
-   char* part2 = (char*) malloc(10*sizeof(wchar_t));
-   strcpy(part2, ", World");
-        CharMessageBuffer& retval = buf << part1 << part2;
-   free(part1);
-   free(part2);
-        LOGUNIT_ASSERT_EQUAL(greeting, buf.str(retval)); 
-        LOGUNIT_ASSERT_EQUAL(false, buf.hasStream());
-    }
+	void testInsertStr()
+	{
+		MessageBuffer buf;
+		std::string greeting("Hello, World");
+		char* part1 = (char*) malloc(10 * sizeof(wchar_t));
+		strcpy(part1, "Hello");
+		char* part2 = (char*) malloc(10 * sizeof(wchar_t));
+		strcpy(part2, ", World");
+		CharMessageBuffer& retval = buf << part1 << part2;
+		free(part1);
+		free(part2);
+		LOGUNIT_ASSERT_EQUAL(greeting, buf.str(retval));
+		LOGUNIT_ASSERT_EQUAL(false, buf.hasStream());
+	}
 
-    void testInsertString() {
-        MessageBuffer buf;
-        std::string greeting("Hello, World");
-        CharMessageBuffer& retval = buf << std::string("Hello") << std::string(", World");
-        LOGUNIT_ASSERT_EQUAL(greeting, buf.str(retval)); 
-        LOGUNIT_ASSERT_EQUAL(false, buf.hasStream());
-    }
-    
-    void testInsertNull() {
-        MessageBuffer buf;
-        std::string greeting("Hello, null");
-        CharMessageBuffer& retval = buf << "Hello, " << (const char*) 0;
-        LOGUNIT_ASSERT_EQUAL(greeting, buf.str(retval)); 
-        LOGUNIT_ASSERT_EQUAL(false, buf.hasStream());
-    }
-    
-    void testInsertInt() {
-        MessageBuffer buf;
-        std::string greeting("Hello, 5");
-        std::ostream& retval = buf << "Hello, " << 5;
-        LOGUNIT_ASSERT_EQUAL(greeting, buf.str(retval));
-        LOGUNIT_ASSERT_EQUAL(true, buf.hasStream());
-    }
-        
-    void testInsertManipulator() {
-        MessageBuffer buf;
-        std::string greeting("pi=3.142");
-        std::ostream& retval = buf << "pi=" << std::setprecision(4) << 3.1415926;
-        LOGUNIT_ASSERT_EQUAL(greeting, buf.str(retval));
-        LOGUNIT_ASSERT_EQUAL(true, buf.hasStream());
-    }
+	void testInsertString()
+	{
+		MessageBuffer buf;
+		std::string greeting("Hello, World");
+		CharMessageBuffer& retval = buf << std::string("Hello") << std::string(", World");
+		LOGUNIT_ASSERT_EQUAL(greeting, buf.str(retval));
+		LOGUNIT_ASSERT_EQUAL(false, buf.hasStream());
+	}
+
+	void testInsertNull()
+	{
+		MessageBuffer buf;
+		std::string greeting("Hello, null");
+		CharMessageBuffer& retval = buf << "Hello, " << (const char*) 0;
+		LOGUNIT_ASSERT_EQUAL(greeting, buf.str(retval));
+		LOGUNIT_ASSERT_EQUAL(false, buf.hasStream());
+	}
+
+	void testInsertInt()
+	{
+		MessageBuffer buf;
+		std::string greeting("Hello, 5");
+		std::ostream& retval = buf << "Hello, " << 5;
+		LOGUNIT_ASSERT_EQUAL(greeting, buf.str(retval));
+		LOGUNIT_ASSERT_EQUAL(true, buf.hasStream());
+	}
+
+	void testInsertManipulator()
+	{
+		MessageBuffer buf;
+		std::string greeting("pi=3.142");
+		std::ostream& retval = buf << "pi=" << std::setprecision(4) << 3.1415926;
+		LOGUNIT_ASSERT_EQUAL(greeting, buf.str(retval));
+		LOGUNIT_ASSERT_EQUAL(true, buf.hasStream());
+	}
 
 #if LOG4CXX_WCHAR_T_API
-    void testInsertConstWStr() {
-        MessageBuffer buf;
-        std::wstring greeting(L"Hello, World");
-        WideMessageBuffer& retval = buf << L"Hello" << L", World";
-        LOGUNIT_ASSERT_EQUAL(greeting, buf.str(retval)); 
-        LOGUNIT_ASSERT_EQUAL(false, buf.hasStream());
-    }
+	void testInsertConstWStr()
+	{
+		MessageBuffer buf;
+		std::wstring greeting(L"Hello, World");
+		WideMessageBuffer& retval = buf << L"Hello" << L", World";
+		LOGUNIT_ASSERT_EQUAL(greeting, buf.str(retval));
+		LOGUNIT_ASSERT_EQUAL(false, buf.hasStream());
+	}
 
-    void testInsertWString() {
-        MessageBuffer buf;
-        std::wstring greeting(L"Hello, World");
-        WideMessageBuffer& retval = buf << std::wstring(L"Hello") << std::wstring(L", World");
-        LOGUNIT_ASSERT_EQUAL(greeting, buf.str(retval)); 
-        LOGUNIT_ASSERT_EQUAL(false, buf.hasStream());
-    }
+	void testInsertWString()
+	{
+		MessageBuffer buf;
+		std::wstring greeting(L"Hello, World");
+		WideMessageBuffer& retval = buf << std::wstring(L"Hello") << std::wstring(L", World");
+		LOGUNIT_ASSERT_EQUAL(greeting, buf.str(retval));
+		LOGUNIT_ASSERT_EQUAL(false, buf.hasStream());
+	}
 
-    void testInsertWStr() {
-        MessageBuffer buf;
-        std::wstring greeting(L"Hello, World");
-       wchar_t* part1 = (wchar_t*) malloc(10*sizeof(wchar_t));
-       wcscpy(part1, L"Hello");
-       wchar_t* part2 = (wchar_t*) malloc(10*sizeof(wchar_t));
-       wcscpy(part2, L", World");
-        WideMessageBuffer& retval = buf << part1 << part2;
-       free(part1);
-       free(part2);
-        LOGUNIT_ASSERT_EQUAL(greeting, buf.str(retval)); 
-        LOGUNIT_ASSERT_EQUAL(false, buf.hasStream());
-    }
+	void testInsertWStr()
+	{
+		MessageBuffer buf;
+		std::wstring greeting(L"Hello, World");
+		wchar_t* part1 = (wchar_t*) malloc(10 * sizeof(wchar_t));
+		wcscpy(part1, L"Hello");
+		wchar_t* part2 = (wchar_t*) malloc(10 * sizeof(wchar_t));
+		wcscpy(part2, L", World");
+		WideMessageBuffer& retval = buf << part1 << part2;
+		free(part1);
+		free(part2);
+		LOGUNIT_ASSERT_EQUAL(greeting, buf.str(retval));
+		LOGUNIT_ASSERT_EQUAL(false, buf.hasStream());
+	}
 #endif
 
 #if LOG4CXX_UNICHAR_API
-    void testInsertConstUStr() {
-        MessageBuffer buf;
-        const log4cxx::UniChar hello[] = { 'H', 'e', 'l', 'l', 'o', 0 };
-        const log4cxx::UniChar world[] = { ',', ' ', 'W', 'o', 'r', 'l', 'd', 0 };
-        const log4cxx::UniChar greeting[] = { 'H', 'e', 'l', 'l', 'o', 
-                                  ',', ' ', 'W', 'o', 'r', 'l', 'd', 0 };
-        UniCharMessageBuffer& retval = buf << hello << world;
-        LOGUNIT_ASSERT_EQUAL(std::basic_string<log4cxx::UniChar>(greeting), buf.str(retval)); 
-        LOGUNIT_ASSERT_EQUAL(false, buf.hasStream());
-    }
+	void testInsertConstUStr()
+	{
+		MessageBuffer buf;
+		const log4cxx::UniChar hello[] = { 'H', 'e', 'l', 'l', 'o', 0 };
+		const log4cxx::UniChar world[] = { ',', ' ', 'W', 'o', 'r', 'l', 'd', 0 };
+		const log4cxx::UniChar greeting[] = { 'H', 'e', 'l', 'l', 'o',
+				',', ' ', 'W', 'o', 'r', 'l', 'd', 0
+			};
+		UniCharMessageBuffer& retval = buf << hello << world;
+		LOGUNIT_ASSERT_EQUAL(std::basic_string<log4cxx::UniChar>(greeting), buf.str(retval));
+		LOGUNIT_ASSERT_EQUAL(false, buf.hasStream());
+	}
 
-    void testInsertUString() {
-        MessageBuffer buf;
-        const log4cxx::UniChar hello[] = { 'H', 'e', 'l', 'l', 'o', 0 };
-        const log4cxx::UniChar world[] = { ',', ' ', 'W', 'o', 'r', 'l', 'd', 0 };
-        const log4cxx::UniChar greeting[] = { 'H', 'e', 'l', 'l', 'o', 
-                                  ',', ' ', 'W', 'o', 'r', 'l', 'd', 0 };
-        UniCharMessageBuffer& retval = buf << std::basic_string<log4cxx::UniChar>(hello) 
-                                           << std::basic_string<log4cxx::UniChar>(world);
-        LOGUNIT_ASSERT_EQUAL(std::basic_string<log4cxx::UniChar>(greeting), buf.str(retval)); 
-        LOGUNIT_ASSERT_EQUAL(false, buf.hasStream());
-    }
+	void testInsertUString()
+	{
+		MessageBuffer buf;
+		const log4cxx::UniChar hello[] = { 'H', 'e', 'l', 'l', 'o', 0 };
+		const log4cxx::UniChar world[] = { ',', ' ', 'W', 'o', 'r', 'l', 'd', 0 };
+		const log4cxx::UniChar greeting[] = { 'H', 'e', 'l', 'l', 'o',
+				',', ' ', 'W', 'o', 'r', 'l', 'd', 0
+			};
+		UniCharMessageBuffer& retval = buf << std::basic_string<log4cxx::UniChar>(hello)
+			<< std::basic_string<log4cxx::UniChar>(world);
+		LOGUNIT_ASSERT_EQUAL(std::basic_string<log4cxx::UniChar>(greeting), buf.str(retval));
+		LOGUNIT_ASSERT_EQUAL(false, buf.hasStream());
+	}
 
 #endif
 
 #if LOG4CXX_CFSTRING_API
-    void testInsertCFString() {
-        MessageBuffer buf;
-        const log4cxx::UniChar greeting[] = { 'H', 'e', 'l', 'l', 'o', 
-                                  ',', ' ', 'W', 'o', 'r', 'l', 'd', 0 };
-        UniCharMessageBuffer& retval = buf << CFSTR("Hello") 
-                                           << CFSTR(", World");
-        LOGUNIT_ASSERT_EQUAL(std::basic_string<log4cxx::UniChar>(greeting), buf.str(retval)); 
-        LOGUNIT_ASSERT_EQUAL(false, buf.hasStream());
-    }
+	void testInsertCFString()
+	{
+		MessageBuffer buf;
+		const log4cxx::UniChar greeting[] = { 'H', 'e', 'l', 'l', 'o',
+				',', ' ', 'W', 'o', 'r', 'l', 'd', 0
+			};
+		UniCharMessageBuffer& retval = buf << CFSTR("Hello")
+			<< CFSTR(", World");
+		LOGUNIT_ASSERT_EQUAL(std::basic_string<log4cxx::UniChar>(greeting), buf.str(retval));
+		LOGUNIT_ASSERT_EQUAL(false, buf.hasStream());
+	}
 
 #endif
 
diff --git a/src/test/cpp/helpers/optionconvertertestcase.cpp b/src/test/cpp/helpers/optionconvertertestcase.cpp
index 1cc3a82..d3c128a 100644
--- a/src/test/cpp/helpers/optionconvertertestcase.cpp
+++ b/src/test/cpp/helpers/optionconvertertestcase.cpp
@@ -38,182 +38,197 @@
 
 LOGUNIT_CLASS(OptionConverterTestCase)
 {
-   LOGUNIT_TEST_SUITE(OptionConverterTestCase);
-      LOGUNIT_TEST(varSubstTest1);
-      LOGUNIT_TEST(varSubstTest2);
-      LOGUNIT_TEST(varSubstTest3);
-      LOGUNIT_TEST(varSubstTest4);
-      LOGUNIT_TEST(varSubstTest5);
-      LOGUNIT_TEST(testTmpDir);
+	LOGUNIT_TEST_SUITE(OptionConverterTestCase);
+	LOGUNIT_TEST(varSubstTest1);
+	LOGUNIT_TEST(varSubstTest2);
+	LOGUNIT_TEST(varSubstTest3);
+	LOGUNIT_TEST(varSubstTest4);
+	LOGUNIT_TEST(varSubstTest5);
+	LOGUNIT_TEST(testTmpDir);
 #if APR_HAS_USER
-      LOGUNIT_TEST(testUserHome);
-      LOGUNIT_TEST(testUserName);
+	LOGUNIT_TEST(testUserHome);
+	LOGUNIT_TEST(testUserName);
 #endif
-      LOGUNIT_TEST(testUserDir);
-   LOGUNIT_TEST_SUITE_END();
+	LOGUNIT_TEST(testUserDir);
+	LOGUNIT_TEST_SUITE_END();
 
-   Properties props;
-   Properties nullProperties;
+	Properties props;
+	Properties nullProperties;
 
 public:
-   void setUp()
-   {
-   }
+	void setUp()
+	{
+	}
 
-   void tearDown()
-   {
-   }
+	void tearDown()
+	{
+	}
 
-   /**
-   * Checks that environment variables were properly set
-   * before invoking tests.  ::putenv not reliable.
-   */
-   void envCheck() {
-     Pool p;
-     char* toto;
-     apr_status_t stat = apr_env_get(&toto, "TOTO", 
-         p.getAPRPool());
-     LOGUNIT_ASSERT_EQUAL(APR_SUCCESS, stat);
-     LOGUNIT_ASSERT_EQUAL("wonderful", toto);
-     char* key1;
-     stat = apr_env_get(&key1, "key1", 
-         p.getAPRPool());
-     LOGUNIT_ASSERT_EQUAL(APR_SUCCESS, stat);
-     LOGUNIT_ASSERT_EQUAL("value1", key1);
-     char* key2;
-     stat = apr_env_get(&key2, "key2", 
-         p.getAPRPool());
-     LOGUNIT_ASSERT_EQUAL(APR_SUCCESS, stat);
-     LOGUNIT_ASSERT_EQUAL("value2", key2);
-   }
+	/**
+	* Checks that environment variables were properly set
+	* before invoking tests.  ::putenv not reliable.
+	*/
+	void envCheck()
+	{
+		Pool p;
+		char* toto;
+		apr_status_t stat = apr_env_get(&toto, "TOTO",
+				p.getAPRPool());
+		LOGUNIT_ASSERT_EQUAL(APR_SUCCESS, stat);
+		LOGUNIT_ASSERT_EQUAL("wonderful", toto);
+		char* key1;
+		stat = apr_env_get(&key1, "key1",
+				p.getAPRPool());
+		LOGUNIT_ASSERT_EQUAL(APR_SUCCESS, stat);
+		LOGUNIT_ASSERT_EQUAL("value1", key1);
+		char* key2;
+		stat = apr_env_get(&key2, "key2",
+				p.getAPRPool());
+		LOGUNIT_ASSERT_EQUAL(APR_SUCCESS, stat);
+		LOGUNIT_ASSERT_EQUAL("value2", key2);
+	}
 
-   void varSubstTest1()
-   {
-      envCheck();
-      LogString r(OptionConverter::substVars(LOG4CXX_STR("hello world."), nullProperties));
-      LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("hello world."), r);
+	void varSubstTest1()
+	{
+		envCheck();
+		LogString r(OptionConverter::substVars(LOG4CXX_STR("hello world."), nullProperties));
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("hello world."), r);
 
-      r = OptionConverter::substVars(LOG4CXX_STR("hello ${TOTO} world."), nullProperties);
+		r = OptionConverter::substVars(LOG4CXX_STR("hello ${TOTO} world."), nullProperties);
 
-      LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("hello wonderful world."), r);
-   }
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("hello wonderful world."), r);
+	}
 
 
-   void varSubstTest2()
-   {
-     envCheck();
-      LogString r(OptionConverter::substVars(LOG4CXX_STR("Test2 ${key1} mid ${key2} end."),
-         nullProperties));
-      LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("Test2 value1 mid value2 end."), r);
-   }
+	void varSubstTest2()
+	{
+		envCheck();
+		LogString r(OptionConverter::substVars(LOG4CXX_STR("Test2 ${key1} mid ${key2} end."),
+				nullProperties));
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("Test2 value1 mid value2 end."), r);
+	}
 
 
-   void varSubstTest3()
-   {
-     envCheck();
-      LogString r(OptionConverter::substVars(
-         LOG4CXX_STR("Test3 ${unset} mid ${key1} end."), nullProperties));
-      LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("Test3  mid value1 end."), r);
-   }
+	void varSubstTest3()
+	{
+		envCheck();
+		LogString r(OptionConverter::substVars(
+				LOG4CXX_STR("Test3 ${unset} mid ${key1} end."), nullProperties));
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("Test3  mid value1 end."), r);
+	}
 
 
-   void varSubstTest4()
-   {
-      LogString res;
-      LogString val(LOG4CXX_STR("Test4 ${incomplete "));
-      try
-      {
-         res = OptionConverter::substVars(val, nullProperties);
-      }
-      catch(IllegalArgumentException& e)
-      {
-         std::string witness("\"Test4 ${incomplete \" has no closing brace. Opening brace at position 6.");
-         LOGUNIT_ASSERT_EQUAL(witness, (std::string) e.what());
-      }
-   }
+	void varSubstTest4()
+	{
+		LogString res;
+		LogString val(LOG4CXX_STR("Test4 ${incomplete "));
+
+		try
+		{
+			res = OptionConverter::substVars(val, nullProperties);
+		}
+		catch (IllegalArgumentException& e)
+		{
+			std::string witness("\"Test4 ${incomplete \" has no closing brace. Opening brace at position 6.");
+			LOGUNIT_ASSERT_EQUAL(witness, (std::string) e.what());
+		}
+	}
 
 
-   void varSubstTest5()
-   {
-      Properties props1;
-      props1.setProperty(LOG4CXX_STR("p1"), LOG4CXX_STR("x1"));
-      props1.setProperty(LOG4CXX_STR("p2"), LOG4CXX_STR("${p1}"));
-      LogString res = OptionConverter::substVars(LOG4CXX_STR("${p2}"), props1);
-      LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("x1"), res);
-   }
+	void varSubstTest5()
+	{
+		Properties props1;
+		props1.setProperty(LOG4CXX_STR("p1"), LOG4CXX_STR("x1"));
+		props1.setProperty(LOG4CXX_STR("p2"), LOG4CXX_STR("${p1}"));
+		LogString res = OptionConverter::substVars(LOG4CXX_STR("${p2}"), props1);
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("x1"), res);
+	}
 
-    void testTmpDir()
-    {
-       LogString actual(OptionConverter::substVars(
-          LOG4CXX_STR("${java.io.tmpdir}"), nullProperties));
-       Pool p;
-       const char* tmpdir = NULL;
-       apr_status_t stat = apr_temp_dir_get(&tmpdir, p.getAPRPool());
-       LOGUNIT_ASSERT_EQUAL(APR_SUCCESS, stat);
-       LogString expected;
-       Transcoder::decode(tmpdir, expected);
+	void testTmpDir()
+	{
+		LogString actual(OptionConverter::substVars(
+				LOG4CXX_STR("${java.io.tmpdir}"), nullProperties));
+		Pool p;
+		const char* tmpdir = NULL;
+		apr_status_t stat = apr_temp_dir_get(&tmpdir, p.getAPRPool());
+		LOGUNIT_ASSERT_EQUAL(APR_SUCCESS, stat);
+		LogString expected;
+		Transcoder::decode(tmpdir, expected);
 
-       LOGUNIT_ASSERT_EQUAL(expected, actual);
-    }
+		LOGUNIT_ASSERT_EQUAL(expected, actual);
+	}
 
 #if APR_HAS_USER
-    void testUserHome() {
-      LogString actual(OptionConverter::substVars(
-         LOG4CXX_STR("${user.home}"), nullProperties));
-      Pool p;
+	void testUserHome()
+	{
+		LogString actual(OptionConverter::substVars(
+				LOG4CXX_STR("${user.home}"), nullProperties));
+		Pool p;
 
-      apr_uid_t userid;
-      apr_gid_t groupid;
-      apr_status_t stat = apr_uid_current(&userid, &groupid, p.getAPRPool());
-      if (stat == APR_SUCCESS) {
-         char* username = NULL;
-         stat = apr_uid_name_get(&username, userid, p.getAPRPool());
-         if (stat == APR_SUCCESS) {
-            char* dirname = NULL;
-            stat = apr_uid_homepath_get(&dirname, username, p.getAPRPool());
-            if (stat == APR_SUCCESS) {
-               LogString expected;
-               Transcoder::decode(dirname, expected);
-               LOGUNIT_ASSERT_EQUAL(expected, actual);
-             }
-          }
-      }   
+		apr_uid_t userid;
+		apr_gid_t groupid;
+		apr_status_t stat = apr_uid_current(&userid, &groupid, p.getAPRPool());
 
-    }
+		if (stat == APR_SUCCESS)
+		{
+			char* username = NULL;
+			stat = apr_uid_name_get(&username, userid, p.getAPRPool());
 
-    void testUserName() {
-       LogString actual(OptionConverter::substVars(
-           LOG4CXX_STR("${user.name}"), nullProperties));
-       Pool p;
-       apr_uid_t userid;
-       apr_gid_t groupid;
-       apr_status_t stat = apr_uid_current(&userid, &groupid, p.getAPRPool());
-       if (stat == APR_SUCCESS) {
-           char* username = NULL;
-          stat = apr_uid_name_get(&username, userid, p.getAPRPool());
-          if (stat == APR_SUCCESS) {
-             LogString expected;
-             Transcoder::decode(username, expected);
-             LOGUNIT_ASSERT_EQUAL(expected, actual);
-          }
-       }
-   }
+			if (stat == APR_SUCCESS)
+			{
+				char* dirname = NULL;
+				stat = apr_uid_homepath_get(&dirname, username, p.getAPRPool());
+
+				if (stat == APR_SUCCESS)
+				{
+					LogString expected;
+					Transcoder::decode(dirname, expected);
+					LOGUNIT_ASSERT_EQUAL(expected, actual);
+				}
+			}
+		}
+
+	}
+
+	void testUserName()
+	{
+		LogString actual(OptionConverter::substVars(
+				LOG4CXX_STR("${user.name}"), nullProperties));
+		Pool p;
+		apr_uid_t userid;
+		apr_gid_t groupid;
+		apr_status_t stat = apr_uid_current(&userid, &groupid, p.getAPRPool());
+
+		if (stat == APR_SUCCESS)
+		{
+			char* username = NULL;
+			stat = apr_uid_name_get(&username, userid, p.getAPRPool());
+
+			if (stat == APR_SUCCESS)
+			{
+				LogString expected;
+				Transcoder::decode(username, expected);
+				LOGUNIT_ASSERT_EQUAL(expected, actual);
+			}
+		}
+	}
 #endif
 
-    void testUserDir() {
-      LogString actual(OptionConverter::substVars(
-          LOG4CXX_STR("${user.dir}"), nullProperties));
-      Pool p;
+	void testUserDir()
+	{
+		LogString actual(OptionConverter::substVars(
+				LOG4CXX_STR("${user.dir}"), nullProperties));
+		Pool p;
 
-      char* dirname = NULL;
-      apr_status_t stat = apr_filepath_get(&dirname, APR_FILEPATH_NATIVE, p.getAPRPool());
-      LOGUNIT_ASSERT_EQUAL(APR_SUCCESS, stat);
+		char* dirname = NULL;
+		apr_status_t stat = apr_filepath_get(&dirname, APR_FILEPATH_NATIVE, p.getAPRPool());
+		LOGUNIT_ASSERT_EQUAL(APR_SUCCESS, stat);
 
-      LogString expected;
-      Transcoder::decode(dirname, expected);
+		LogString expected;
+		Transcoder::decode(dirname, expected);
 
-      LOGUNIT_ASSERT_EQUAL(expected, actual);
-    }
+		LOGUNIT_ASSERT_EQUAL(expected, actual);
+	}
 };
 
 LOGUNIT_TEST_SUITE_REGISTRATION(OptionConverterTestCase);
diff --git a/src/test/cpp/helpers/propertiestestcase.cpp b/src/test/cpp/helpers/propertiestestcase.cpp
index 07ded38..b97fff3 100644
--- a/src/test/cpp/helpers/propertiestestcase.cpp
+++ b/src/test/cpp/helpers/propertiestestcase.cpp
@@ -26,225 +26,240 @@
 
 LOGUNIT_CLASS(PropertiesTestCase)
 {
-        LOGUNIT_TEST_SUITE(PropertiesTestCase);
-                LOGUNIT_TEST(testLoad1);
-                LOGUNIT_TEST(testTab1);
-                LOGUNIT_TEST(testTab2);
-                LOGUNIT_TEST(testTab3);
-                LOGUNIT_TEST(testTab4);
-                LOGUNIT_TEST(testTab5);
-                LOGUNIT_TEST(testTab6);
-                LOGUNIT_TEST(testTab7);
-                LOGUNIT_TEST(testCRLF1);
-                LOGUNIT_TEST(testEscT1);
-                LOGUNIT_TEST(testEscT2);
-                LOGUNIT_TEST(testEscN1);
-                LOGUNIT_TEST(testEscN2);
-                LOGUNIT_TEST(testEscR1);
-                LOGUNIT_TEST(testEscR2);
-        LOGUNIT_TEST_SUITE_END();
+	LOGUNIT_TEST_SUITE(PropertiesTestCase);
+	LOGUNIT_TEST(testLoad1);
+	LOGUNIT_TEST(testTab1);
+	LOGUNIT_TEST(testTab2);
+	LOGUNIT_TEST(testTab3);
+	LOGUNIT_TEST(testTab4);
+	LOGUNIT_TEST(testTab5);
+	LOGUNIT_TEST(testTab6);
+	LOGUNIT_TEST(testTab7);
+	LOGUNIT_TEST(testCRLF1);
+	LOGUNIT_TEST(testEscT1);
+	LOGUNIT_TEST(testEscT2);
+	LOGUNIT_TEST(testEscN1);
+	LOGUNIT_TEST(testEscN2);
+	LOGUNIT_TEST(testEscR1);
+	LOGUNIT_TEST(testEscR2);
+	LOGUNIT_TEST_SUITE_END();
 
 public:
-        void testLoad1() {
-          //
-          //    read patternLayout1.properties
-          FileInputStreamPtr propFile = 
-            new FileInputStream(LOG4CXX_STR("input/patternLayout1.properties"));
-          Properties properties;
-          properties.load(propFile);
-          LogString pattern(properties.getProperty(LOG4CXX_STR("log4j.appender.testAppender.layout.ConversionPattern")));
-          LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("%-5p - %m%n"), pattern);
-        }
-        
-        /**
-         *  Test tab as separator between key and value, see LOGCXX-291.
-        */
-        void testTab1() {
-          FileInputStreamPtr propFile(
-            new FileInputStream(LOG4CXX_STR("input/propertiestestcase.properties")));
-          Properties properties;
-          properties.load(propFile);
-          LogString actual(properties.getProperty(LOG4CXX_STR("propertiestestcase.tab1")));
-          LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("tab delimited")), actual);
-        }
+	void testLoad1()
+	{
+		//
+		//    read patternLayout1.properties
+		FileInputStreamPtr propFile =
+			new FileInputStream(LOG4CXX_STR("input/patternLayout1.properties"));
+		Properties properties;
+		properties.load(propFile);
+		LogString pattern(properties.getProperty(LOG4CXX_STR("log4j.appender.testAppender.layout.ConversionPattern")));
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("%-5p - %m%n"), pattern);
+	}
 
-        /**
-         *  Test tab as whitespace before key, see LOGCXX-291.
-        */
-        void testTab2() {
-          FileInputStreamPtr propFile(
-            new FileInputStream(LOG4CXX_STR("input/propertiestestcase.properties")));
-          Properties properties;
-          properties.load(propFile);
-          LogString actual(properties.getProperty(LOG4CXX_STR("propertiestestcase.tab2")));
-          LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("tab before key")), actual);
-        }
+	/**
+	 *  Test tab as separator between key and value, see LOGCXX-291.
+	*/
+	void testTab1()
+	{
+		FileInputStreamPtr propFile(
+			new FileInputStream(LOG4CXX_STR("input/propertiestestcase.properties")));
+		Properties properties;
+		properties.load(propFile);
+		LogString actual(properties.getProperty(LOG4CXX_STR("propertiestestcase.tab1")));
+		LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("tab delimited")), actual);
+	}
 
-        /**
-         *  Test tab as escaped within key, see LOGCXX-291.
-        */
-        void testTab3() {
-          FileInputStreamPtr propFile(
-            new FileInputStream(LOG4CXX_STR("input/propertiestestcase.properties")));
-          Properties properties;
-          properties.load(propFile);
-          LogString key(LOG4CXX_STR("propertiestestcase.tab3"));
-          key.append(1, 0x09);
-          LogString actual(properties.getProperty(key));
-          LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("key contains tab")), actual);
-        }
+	/**
+	 *  Test tab as whitespace before key, see LOGCXX-291.
+	*/
+	void testTab2()
+	{
+		FileInputStreamPtr propFile(
+			new FileInputStream(LOG4CXX_STR("input/propertiestestcase.properties")));
+		Properties properties;
+		properties.load(propFile);
+		LogString actual(properties.getProperty(LOG4CXX_STR("propertiestestcase.tab2")));
+		LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("tab before key")), actual);
+	}
 
-        /**
-         *  Test tab after delimitor, see LOGCXX-291.
-        */
-        void testTab4() {
-          FileInputStreamPtr propFile(
-            new FileInputStream(LOG4CXX_STR("input/propertiestestcase.properties")));
-          Properties properties;
-          properties.load(propFile);
-          LogString actual(properties.getProperty(LOG4CXX_STR("propertiestestcase.tab4")));
-          LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("tab after equals")), actual);
-        }
+	/**
+	 *  Test tab as escaped within key, see LOGCXX-291.
+	*/
+	void testTab3()
+	{
+		FileInputStreamPtr propFile(
+			new FileInputStream(LOG4CXX_STR("input/propertiestestcase.properties")));
+		Properties properties;
+		properties.load(propFile);
+		LogString key(LOG4CXX_STR("propertiestestcase.tab3"));
+		key.append(1, 0x09);
+		LogString actual(properties.getProperty(key));
+		LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("key contains tab")), actual);
+	}
 
-        /**
-         *  Test tab after continuation in key, see LOGCXX-291.
-        */
-        void testTab5() {
-          FileInputStreamPtr propFile(
-            new FileInputStream(LOG4CXX_STR("input/propertiestestcase.properties")));
-          Properties properties;
-          properties.load(propFile);
-          LogString actual(properties.getProperty(LOG4CXX_STR("propertiestestcase.tab5")));
-          LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("tab after continue")), actual);
-        }
+	/**
+	 *  Test tab after delimitor, see LOGCXX-291.
+	*/
+	void testTab4()
+	{
+		FileInputStreamPtr propFile(
+			new FileInputStream(LOG4CXX_STR("input/propertiestestcase.properties")));
+		Properties properties;
+		properties.load(propFile);
+		LogString actual(properties.getProperty(LOG4CXX_STR("propertiestestcase.tab4")));
+		LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("tab after equals")), actual);
+	}
 
-        /**
-         *  Test tab escaped in value, see LOGCXX-291.
-        */
-        void testTab6() {
-          FileInputStreamPtr propFile(
-            new FileInputStream(LOG4CXX_STR("input/propertiestestcase.properties")));
-          Properties properties;
-          properties.load(propFile);
-          LogString actual(properties.getProperty(LOG4CXX_STR("propertiestestcase.tab6")));
-          LogString expected(1, 0x09);
-          expected.append(LOG4CXX_STR(" in value"));
-          LOGUNIT_ASSERT_EQUAL(expected, actual);
-        }
+	/**
+	 *  Test tab after continuation in key, see LOGCXX-291.
+	*/
+	void testTab5()
+	{
+		FileInputStreamPtr propFile(
+			new FileInputStream(LOG4CXX_STR("input/propertiestestcase.properties")));
+		Properties properties;
+		properties.load(propFile);
+		LogString actual(properties.getProperty(LOG4CXX_STR("propertiestestcase.tab5")));
+		LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("tab after continue")), actual);
+	}
 
-        /**
-         *  Test tab in value continuation, see LOGCXX-291.
-        */
-        void testTab7() {
-          FileInputStreamPtr propFile(
-            new FileInputStream(LOG4CXX_STR("input/propertiestestcase.properties")));
-          Properties properties;
-          properties.load(propFile);
-          LogString actual(properties.getProperty(LOG4CXX_STR("propertiestestcase.tab7")));
-          LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("continuedvalue")), actual);
-        }
+	/**
+	 *  Test tab escaped in value, see LOGCXX-291.
+	*/
+	void testTab6()
+	{
+		FileInputStreamPtr propFile(
+			new FileInputStream(LOG4CXX_STR("input/propertiestestcase.properties")));
+		Properties properties;
+		properties.load(propFile);
+		LogString actual(properties.getProperty(LOG4CXX_STR("propertiestestcase.tab6")));
+		LogString expected(1, 0x09);
+		expected.append(LOG4CXX_STR(" in value"));
+		LOGUNIT_ASSERT_EQUAL(expected, actual);
+	}
 
-        /**
-         *  Test tab in value continuation, see LOGCXX-292.
-        */
-        void testCRLF1() {
-          FileInputStreamPtr propFile(
-            new FileInputStream(LOG4CXX_STR("input/propertiestestcase.properties")));
-          Properties properties;
-          properties.load(propFile);
-          LogString actual(properties.getProperty(LOG4CXX_STR("propertiestestcase.crlf1")));
-          LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("continuedvalue")), actual);
-        }
+	/**
+	 *  Test tab in value continuation, see LOGCXX-291.
+	*/
+	void testTab7()
+	{
+		FileInputStreamPtr propFile(
+			new FileInputStream(LOG4CXX_STR("input/propertiestestcase.properties")));
+		Properties properties;
+		properties.load(propFile);
+		LogString actual(properties.getProperty(LOG4CXX_STR("propertiestestcase.tab7")));
+		LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("continuedvalue")), actual);
+	}
 
-    /**
-     *  Test tab as escaped within key, see LOGCXX-293.
-    */
-    void testEscT1()  {
-      FileInputStreamPtr propFile(
-        new FileInputStream(LOG4CXX_STR("input/propertiestestcase.properties")));
-      Properties properties;
-      properties.load(propFile);
-      LogString key(LOG4CXX_STR("propertiestestcase.esct1"));
-      key.append(1, 0x09);
-      LogString actual(properties.getProperty(key));
-      LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("key contains tab")), actual);
-    }
+	/**
+	 *  Test tab in value continuation, see LOGCXX-292.
+	*/
+	void testCRLF1()
+	{
+		FileInputStreamPtr propFile(
+			new FileInputStream(LOG4CXX_STR("input/propertiestestcase.properties")));
+		Properties properties;
+		properties.load(propFile);
+		LogString actual(properties.getProperty(LOG4CXX_STR("propertiestestcase.crlf1")));
+		LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("continuedvalue")), actual);
+	}
+
+	/**
+	 *  Test tab as escaped within key, see LOGCXX-293.
+	*/
+	void testEscT1()
+	{
+		FileInputStreamPtr propFile(
+			new FileInputStream(LOG4CXX_STR("input/propertiestestcase.properties")));
+		Properties properties;
+		properties.load(propFile);
+		LogString key(LOG4CXX_STR("propertiestestcase.esct1"));
+		key.append(1, 0x09);
+		LogString actual(properties.getProperty(key));
+		LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("key contains tab")), actual);
+	}
 
 
 
-    /**
-     *  Test tab escaped in value, see LOGCXX-293.
-    */
-    void testEscT2()  {
-      FileInputStreamPtr propFile(
-        new FileInputStream(LOG4CXX_STR("input/propertiestestcase.properties")));
-      Properties properties;
-      properties.load(propFile);
-      LogString actual(properties.getProperty(LOG4CXX_STR("propertiestestcase.esct2")));
-      LogString expected(1, 0x09);
-      expected.append(LOG4CXX_STR(" in value"));
-      LOGUNIT_ASSERT_EQUAL(expected, actual);
-    }
+	/**
+	 *  Test tab escaped in value, see LOGCXX-293.
+	*/
+	void testEscT2()
+	{
+		FileInputStreamPtr propFile(
+			new FileInputStream(LOG4CXX_STR("input/propertiestestcase.properties")));
+		Properties properties;
+		properties.load(propFile);
+		LogString actual(properties.getProperty(LOG4CXX_STR("propertiestestcase.esct2")));
+		LogString expected(1, 0x09);
+		expected.append(LOG4CXX_STR(" in value"));
+		LOGUNIT_ASSERT_EQUAL(expected, actual);
+	}
 
-    /**
-     *  Test \n within key, see LOGCXX-293.
-    */
-    void testEscN1()  {
-      FileInputStreamPtr propFile(
-        new FileInputStream(LOG4CXX_STR("input/propertiestestcase.properties")));
-      Properties properties;;
-      properties.load(propFile);
-      LogString key(LOG4CXX_STR("propertiestestcase.escn1"));
-      key.append(1, 0x0A);
-      LogString actual(properties.getProperty(key));
-      LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("key contains lf")), actual);
-    }
+	/**
+	 *  Test \n within key, see LOGCXX-293.
+	*/
+	void testEscN1()
+	{
+		FileInputStreamPtr propFile(
+			new FileInputStream(LOG4CXX_STR("input/propertiestestcase.properties")));
+		Properties properties;;
+		properties.load(propFile);
+		LogString key(LOG4CXX_STR("propertiestestcase.escn1"));
+		key.append(1, 0x0A);
+		LogString actual(properties.getProperty(key));
+		LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("key contains lf")), actual);
+	}
 
 
 
-    /**
-     *  Test \n in value, see LOGCXX-293.
-    */
-    void testEscN2()  {
-      FileInputStreamPtr propFile(
-        new FileInputStream(LOG4CXX_STR("input/propertiestestcase.properties")));
-      Properties properties;
-      properties.load(propFile);
-      LogString actual(properties.getProperty(LOG4CXX_STR("propertiestestcase.escn2")));
-      LogString expected(1, 0x0A);
-      expected.append(LOG4CXX_STR(" in value"));
-      LOGUNIT_ASSERT_EQUAL(expected, actual);
-    }
+	/**
+	 *  Test \n in value, see LOGCXX-293.
+	*/
+	void testEscN2()
+	{
+		FileInputStreamPtr propFile(
+			new FileInputStream(LOG4CXX_STR("input/propertiestestcase.properties")));
+		Properties properties;
+		properties.load(propFile);
+		LogString actual(properties.getProperty(LOG4CXX_STR("propertiestestcase.escn2")));
+		LogString expected(1, 0x0A);
+		expected.append(LOG4CXX_STR(" in value"));
+		LOGUNIT_ASSERT_EQUAL(expected, actual);
+	}
 
-    /**
-     *  Test \r within key, see LOGCXX-293.
-    */
-    void testEscR1()  {
-      FileInputStreamPtr propFile(
-        new FileInputStream(LOG4CXX_STR("input/propertiestestcase.properties")));
-      Properties properties;
-      properties.load(propFile);
-      LogString key(LOG4CXX_STR("propertiestestcase.escr1"));
-      key.append(1, 0x0D);
-      LogString actual(properties.getProperty(key));
-      LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("key contains cr")), actual);
-    }
+	/**
+	 *  Test \r within key, see LOGCXX-293.
+	*/
+	void testEscR1()
+	{
+		FileInputStreamPtr propFile(
+			new FileInputStream(LOG4CXX_STR("input/propertiestestcase.properties")));
+		Properties properties;
+		properties.load(propFile);
+		LogString key(LOG4CXX_STR("propertiestestcase.escr1"));
+		key.append(1, 0x0D);
+		LogString actual(properties.getProperty(key));
+		LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("key contains cr")), actual);
+	}
 
 
 
-    /**
-     *  Test \r in value, see LOGCXX-293.
-    */
-    void testEscR2()  {
-      FileInputStreamPtr propFile(
-        new FileInputStream(LOG4CXX_STR("input/propertiestestcase.properties")));
-      Properties properties;
-      properties.load(propFile);
-      LogString actual(properties.getProperty(LOG4CXX_STR("propertiestestcase.escr2")));
-      LogString expected(1, 0x0D);
-      expected.append(LOG4CXX_STR(" in value"));
-      LOGUNIT_ASSERT_EQUAL(expected, actual);
-    }
+	/**
+	 *  Test \r in value, see LOGCXX-293.
+	*/
+	void testEscR2()
+	{
+		FileInputStreamPtr propFile(
+			new FileInputStream(LOG4CXX_STR("input/propertiestestcase.properties")));
+		Properties properties;
+		properties.load(propFile);
+		LogString actual(properties.getProperty(LOG4CXX_STR("propertiestestcase.escr2")));
+		LogString expected(1, 0x0D);
+		expected.append(LOG4CXX_STR(" in value"));
+		LOGUNIT_ASSERT_EQUAL(expected, actual);
+	}
 
 
 };
diff --git a/src/test/cpp/helpers/relativetimedateformattestcase.cpp b/src/test/cpp/helpers/relativetimedateformattestcase.cpp
index 88d4351..a28ebce 100644
--- a/src/test/cpp/helpers/relativetimedateformattestcase.cpp
+++ b/src/test/cpp/helpers/relativetimedateformattestcase.cpp
@@ -33,60 +33,64 @@
 
 /**
    Unit test {@link RelativeTimeDateFormat} class.
-   
+
    */
-LOGUNIT_CLASS(RelativeTimeDateFormatTestCase) {
-     LOGUNIT_TEST_SUITE(RelativeTimeDateFormatTestCase);
-             LOGUNIT_TEST(test1);
-             LOGUNIT_TEST(test2);
-             LOGUNIT_TEST(test3);
-     LOGUNIT_TEST_SUITE_END();
+LOGUNIT_CLASS(RelativeTimeDateFormatTestCase)
+{
+	LOGUNIT_TEST_SUITE(RelativeTimeDateFormatTestCase);
+	LOGUNIT_TEST(test1);
+	LOGUNIT_TEST(test2);
+	LOGUNIT_TEST(test3);
+	LOGUNIT_TEST_SUITE_END();
 
 
-  public:
+public:
 
-  /**
-  *   Convert 2 Jan 2004
-  */
-  void test1() {
-    log4cxx_time_t jan2 = Date::getMicrosecondsPerDay() * 12419;
-    log4cxx_time_t preStartTime = LoggingEvent::getStartTime();
+	/**
+	*   Convert 2 Jan 2004
+	*/
+	void test1()
+	{
+		log4cxx_time_t jan2 = Date::getMicrosecondsPerDay() * 12419;
+		log4cxx_time_t preStartTime = LoggingEvent::getStartTime();
 
-    RelativeTimeDateFormat formatter;
+		RelativeTimeDateFormat formatter;
 
-    Pool p;
+		Pool p;
 
-    LogString actual;
+		LogString actual;
 
-    formatter.format(actual, jan2, p);
+		formatter.format(actual, jan2, p);
 
-    log4cxx_time_t elapsed = log4cxx::helpers::StringHelper::toInt64(actual);
+		log4cxx_time_t elapsed = log4cxx::helpers::StringHelper::toInt64(actual);
 
 
-    LOGUNIT_ASSERT(preStartTime + elapsed*1000 > jan2 - 2000);
-    LOGUNIT_ASSERT(preStartTime + elapsed*1000 < jan2 + 2000);
-  }
+		LOGUNIT_ASSERT(preStartTime + elapsed * 1000 > jan2 - 2000);
+		LOGUNIT_ASSERT(preStartTime + elapsed * 1000 < jan2 + 2000);
+	}
 
 
-    /**
-     * Checks that numberFormat works as expected.
-     */
-    void test2() {
-      LogString numb;
-      Pool p;
-      RelativeTimeDateFormat formatter;
-      formatter.numberFormat(numb, 87, p);
-      LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("87"), numb);
-    }
+	/**
+	 * Checks that numberFormat works as expected.
+	 */
+	void test2()
+	{
+		LogString numb;
+		Pool p;
+		RelativeTimeDateFormat formatter;
+		formatter.numberFormat(numb, 87, p);
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("87"), numb);
+	}
 
 
-  /**
-   * Checks that setting timezone doesn't throw an exception.
-   */
-  void test3() {
-    RelativeTimeDateFormat formatter;
-    formatter.setTimeZone(TimeZone::getGMT());
-  }
+	/**
+	 * Checks that setting timezone doesn't throw an exception.
+	 */
+	void test3()
+	{
+		RelativeTimeDateFormat formatter;
+		formatter.setTimeZone(TimeZone::getGMT());
+	}
 
 };
 
diff --git a/src/test/cpp/helpers/stringhelpertestcase.cpp b/src/test/cpp/helpers/stringhelpertestcase.cpp
index 1085265..aba933e 100644
--- a/src/test/cpp/helpers/stringhelpertestcase.cpp
+++ b/src/test/cpp/helpers/stringhelpertestcase.cpp
@@ -26,98 +26,108 @@
 
 /**
    Unit test for StringHelper.
-   
-   
+
+
 */
 LOGUNIT_CLASS(StringHelperTestCase)
-   {
-     LOGUNIT_TEST_SUITE( StringHelperTestCase );
-     LOGUNIT_TEST( testStartsWith1 );
-     LOGUNIT_TEST( testStartsWith2 );
-     LOGUNIT_TEST( testStartsWith3 );
-     LOGUNIT_TEST( testStartsWith4 );
-     LOGUNIT_TEST( testStartsWith5 );
-     LOGUNIT_TEST( testEndsWith1 );
-     LOGUNIT_TEST( testEndsWith2 );
-     LOGUNIT_TEST( testEndsWith3 );
-     LOGUNIT_TEST( testEndsWith4 );
-     LOGUNIT_TEST( testEndsWith5 );
-     LOGUNIT_TEST_SUITE_END();
+{
+	LOGUNIT_TEST_SUITE( StringHelperTestCase );
+	LOGUNIT_TEST( testStartsWith1 );
+	LOGUNIT_TEST( testStartsWith2 );
+	LOGUNIT_TEST( testStartsWith3 );
+	LOGUNIT_TEST( testStartsWith4 );
+	LOGUNIT_TEST( testStartsWith5 );
+	LOGUNIT_TEST( testEndsWith1 );
+	LOGUNIT_TEST( testEndsWith2 );
+	LOGUNIT_TEST( testEndsWith3 );
+	LOGUNIT_TEST( testEndsWith4 );
+	LOGUNIT_TEST( testEndsWith5 );
+	LOGUNIT_TEST_SUITE_END();
 
 
 public:
 
-  /**
-   * Check that startsWith("foobar", "foo") returns true.
-   */
-  void testStartsWith1() {
-    LOGUNIT_ASSERT_EQUAL(true, StringHelper::startsWith(LOG4CXX_STR("foobar"), LOG4CXX_STR("foo")));
-  }
+	/**
+	 * Check that startsWith("foobar", "foo") returns true.
+	 */
+	void testStartsWith1()
+	{
+		LOGUNIT_ASSERT_EQUAL(true, StringHelper::startsWith(LOG4CXX_STR("foobar"), LOG4CXX_STR("foo")));
+	}
 
-  /**
-   * Check that startsWith("bar", "foobar") returns false.
-   */
-  void testStartsWith2() {
-    LOGUNIT_ASSERT_EQUAL(false, StringHelper::startsWith(LOG4CXX_STR("foo"), LOG4CXX_STR("foobar")));
-  }
+	/**
+	 * Check that startsWith("bar", "foobar") returns false.
+	 */
+	void testStartsWith2()
+	{
+		LOGUNIT_ASSERT_EQUAL(false, StringHelper::startsWith(LOG4CXX_STR("foo"), LOG4CXX_STR("foobar")));
+	}
 
-  /**
-   * Check that startsWith("foobar", "foobar") returns true.
-   */
-  void testStartsWith3() {
-    LOGUNIT_ASSERT_EQUAL(true, StringHelper::startsWith(LOG4CXX_STR("foobar"), LOG4CXX_STR("foobar")));
-  }
+	/**
+	 * Check that startsWith("foobar", "foobar") returns true.
+	 */
+	void testStartsWith3()
+	{
+		LOGUNIT_ASSERT_EQUAL(true, StringHelper::startsWith(LOG4CXX_STR("foobar"), LOG4CXX_STR("foobar")));
+	}
 
-  /**
-   * Check that startsWith("foobar", "") returns true.
-   */
-  void testStartsWith4() {
-    LOGUNIT_ASSERT_EQUAL(true, StringHelper::startsWith(LOG4CXX_STR("foobar"), LOG4CXX_STR("")));
-  }
+	/**
+	 * Check that startsWith("foobar", "") returns true.
+	 */
+	void testStartsWith4()
+	{
+		LOGUNIT_ASSERT_EQUAL(true, StringHelper::startsWith(LOG4CXX_STR("foobar"), LOG4CXX_STR("")));
+	}
 
-  /**
-   * Check that startsWith("foobar", "abc") returns false.
-   */
-  void testStartsWith5() {
-    LOGUNIT_ASSERT_EQUAL(false, StringHelper::startsWith(LOG4CXX_STR("foobar"), LOG4CXX_STR("abc")));
-  }
+	/**
+	 * Check that startsWith("foobar", "abc") returns false.
+	 */
+	void testStartsWith5()
+	{
+		LOGUNIT_ASSERT_EQUAL(false, StringHelper::startsWith(LOG4CXX_STR("foobar"), LOG4CXX_STR("abc")));
+	}
 
 
 
-  /**
-   * Check that endsWith("foobar", "bar") returns true.
-   */
-  void testEndsWith1() {
-    LOGUNIT_ASSERT_EQUAL(true, StringHelper::endsWith(LOG4CXX_STR("foobar"), LOG4CXX_STR("bar")));
-  }
+	/**
+	 * Check that endsWith("foobar", "bar") returns true.
+	 */
+	void testEndsWith1()
+	{
+		LOGUNIT_ASSERT_EQUAL(true, StringHelper::endsWith(LOG4CXX_STR("foobar"), LOG4CXX_STR("bar")));
+	}
 
-  /**
-   * Check that endsWith("bar", "foobar") returns false.
-   */
-  void testEndsWith2() {
-    LOGUNIT_ASSERT_EQUAL(false, StringHelper::endsWith(LOG4CXX_STR("bar"), LOG4CXX_STR("foobar")));
-  }
+	/**
+	 * Check that endsWith("bar", "foobar") returns false.
+	 */
+	void testEndsWith2()
+	{
+		LOGUNIT_ASSERT_EQUAL(false, StringHelper::endsWith(LOG4CXX_STR("bar"), LOG4CXX_STR("foobar")));
+	}
 
-  /**
-   * Check that endsWith("foobar", "foobar") returns true.
-   */
-  void testEndsWith3() {
-    LOGUNIT_ASSERT_EQUAL(true, StringHelper::endsWith(LOG4CXX_STR("foobar"), LOG4CXX_STR("foobar")));
-  }
+	/**
+	 * Check that endsWith("foobar", "foobar") returns true.
+	 */
+	void testEndsWith3()
+	{
+		LOGUNIT_ASSERT_EQUAL(true, StringHelper::endsWith(LOG4CXX_STR("foobar"), LOG4CXX_STR("foobar")));
+	}
 
-  /**
-   * Check that endsWith("foobar", "") returns true.
-   */
-  void testEndsWith4() {
-    LOGUNIT_ASSERT_EQUAL(true, StringHelper::endsWith(LOG4CXX_STR("foobar"), LOG4CXX_STR("")));
-  }
+	/**
+	 * Check that endsWith("foobar", "") returns true.
+	 */
+	void testEndsWith4()
+	{
+		LOGUNIT_ASSERT_EQUAL(true, StringHelper::endsWith(LOG4CXX_STR("foobar"), LOG4CXX_STR("")));
+	}
 
-  /**
-   * Check that endsWith("foobar", "abc") returns false.
-   */
-  void testEndsWith5() {
-    LOGUNIT_ASSERT_EQUAL(false, StringHelper::startsWith(LOG4CXX_STR("foobar"), LOG4CXX_STR("abc")));
-  }
+	/**
+	 * Check that endsWith("foobar", "abc") returns false.
+	 */
+	void testEndsWith5()
+	{
+		LOGUNIT_ASSERT_EQUAL(false, StringHelper::startsWith(LOG4CXX_STR("foobar"), LOG4CXX_STR("abc")));
+	}
 
 
 };
diff --git a/src/test/cpp/helpers/stringtokenizertestcase.cpp b/src/test/cpp/helpers/stringtokenizertestcase.cpp
index 85043e5..b0b9bf4 100644
--- a/src/test/cpp/helpers/stringtokenizertestcase.cpp
+++ b/src/test/cpp/helpers/stringtokenizertestcase.cpp
@@ -25,110 +25,136 @@
 
 LOGUNIT_CLASS(StringTokenizerTestCase)
 {
-   LOGUNIT_TEST_SUITE(StringTokenizerTestCase);
-      LOGUNIT_TEST(testNextTokenEmptyString);
-                LOGUNIT_TEST(testHasMoreTokensEmptyString);
-                LOGUNIT_TEST(testNextTokenAllDelim);
-                LOGUNIT_TEST(testHasMoreTokensAllDelim);
-                LOGUNIT_TEST(test1);
-                LOGUNIT_TEST(test2);
-                LOGUNIT_TEST(test3);
-                LOGUNIT_TEST(test4);
-                LOGUNIT_TEST(test5);
-                LOGUNIT_TEST(test6);
-   LOGUNIT_TEST_SUITE_END();
+	LOGUNIT_TEST_SUITE(StringTokenizerTestCase);
+	LOGUNIT_TEST(testNextTokenEmptyString);
+	LOGUNIT_TEST(testHasMoreTokensEmptyString);
+	LOGUNIT_TEST(testNextTokenAllDelim);
+	LOGUNIT_TEST(testHasMoreTokensAllDelim);
+	LOGUNIT_TEST(test1);
+	LOGUNIT_TEST(test2);
+	LOGUNIT_TEST(test3);
+	LOGUNIT_TEST(test4);
+	LOGUNIT_TEST(test5);
+	LOGUNIT_TEST(test6);
+	LOGUNIT_TEST_SUITE_END();
 
 public:
-        void testNextTokenEmptyString() {
-           LogString src;
-           LogString delim(LOG4CXX_STR(" "));
-           StringTokenizer tokenizer(src, delim);
-           try {
-             LogString token(tokenizer.nextToken());
-           } catch (NoSuchElementException &ex) {
-             return;
-           }
-           LOGUNIT_ASSERT(false);
-        }
+	void testNextTokenEmptyString()
+	{
+		LogString src;
+		LogString delim(LOG4CXX_STR(" "));
+		StringTokenizer tokenizer(src, delim);
 
-        void testHasMoreTokensEmptyString() {
-           LogString src;
-           LogString delim(LOG4CXX_STR(" "));
-           StringTokenizer tokenizer(src, delim);
-           LOGUNIT_ASSERT_EQUAL(false, tokenizer.hasMoreTokens());
-        }
+		try
+		{
+			LogString token(tokenizer.nextToken());
+		}
+		catch (NoSuchElementException& ex)
+		{
+			return;
+		}
 
-        void testNextTokenAllDelim() {
-           LogString src(LOG4CXX_STR("==="));
-           LogString delim(LOG4CXX_STR("="));
-           StringTokenizer tokenizer(src, delim);
-           try {
-             LogString token(tokenizer.nextToken());
-           } catch (NoSuchElementException &ex) {
-             return;
-           }
-           LOGUNIT_ASSERT(false);
-        }
+		LOGUNIT_ASSERT(false);
+	}
 
-        void testHasMoreTokensAllDelim() {
-           LogString src(LOG4CXX_STR("==="));
-           LogString delim(LOG4CXX_STR("="));
-           StringTokenizer tokenizer(src, delim);
-           LOGUNIT_ASSERT_EQUAL(false, tokenizer.hasMoreTokens());
-        }
+	void testHasMoreTokensEmptyString()
+	{
+		LogString src;
+		LogString delim(LOG4CXX_STR(" "));
+		StringTokenizer tokenizer(src, delim);
+		LOGUNIT_ASSERT_EQUAL(false, tokenizer.hasMoreTokens());
+	}
 
-        void testBody(const LogString& src, const LogString& delim) {
-           StringTokenizer tokenizer(src, delim);
-           LOGUNIT_ASSERT_EQUAL(true, tokenizer.hasMoreTokens());
-           LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("log4j"), tokenizer.nextToken());
-           LOGUNIT_ASSERT_EQUAL(true, tokenizer.hasMoreTokens());
-           LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("properties"), tokenizer.nextToken());
-           LOGUNIT_ASSERT_EQUAL(true, tokenizer.hasMoreTokens());
-           LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("txt"), tokenizer.nextToken());
-           LOGUNIT_ASSERT_EQUAL(false, tokenizer.hasMoreTokens());
-           try {
-              LogString token(tokenizer.nextToken());
-           } catch (NoSuchElementException& ex) {
-             return;
-           }
-           LOGUNIT_ASSERT(false);
-        }
+	void testNextTokenAllDelim()
+	{
+		LogString src(LOG4CXX_STR("==="));
+		LogString delim(LOG4CXX_STR("="));
+		StringTokenizer tokenizer(src, delim);
 
-        void test1() {
-          LogString src(LOG4CXX_STR("log4j.properties.txt"));
-          LogString delim(LOG4CXX_STR("."));
-          testBody(src, delim);
-        }
+		try
+		{
+			LogString token(tokenizer.nextToken());
+		}
+		catch (NoSuchElementException& ex)
+		{
+			return;
+		}
 
-        void test2() {
-          LogString src(LOG4CXX_STR(".log4j.properties.txt"));
-          LogString delim(LOG4CXX_STR("."));
-          testBody(src, delim);
-        }
+		LOGUNIT_ASSERT(false);
+	}
 
-        void test3() {
-          LogString src(LOG4CXX_STR("log4j.properties.txt."));
-          LogString delim(LOG4CXX_STR("."));
-          testBody(src, delim);
-        }
+	void testHasMoreTokensAllDelim()
+	{
+		LogString src(LOG4CXX_STR("==="));
+		LogString delim(LOG4CXX_STR("="));
+		StringTokenizer tokenizer(src, delim);
+		LOGUNIT_ASSERT_EQUAL(false, tokenizer.hasMoreTokens());
+	}
 
-        void test4() {
-          LogString src(LOG4CXX_STR("log4j..properties....txt"));
-          LogString delim(LOG4CXX_STR("."));
-          testBody(src, delim);
-        }
+	void testBody(const LogString & src, const LogString & delim)
+	{
+		StringTokenizer tokenizer(src, delim);
+		LOGUNIT_ASSERT_EQUAL(true, tokenizer.hasMoreTokens());
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("log4j"), tokenizer.nextToken());
+		LOGUNIT_ASSERT_EQUAL(true, tokenizer.hasMoreTokens());
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("properties"), tokenizer.nextToken());
+		LOGUNIT_ASSERT_EQUAL(true, tokenizer.hasMoreTokens());
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("txt"), tokenizer.nextToken());
+		LOGUNIT_ASSERT_EQUAL(false, tokenizer.hasMoreTokens());
 
-        void test5() {
-          LogString src(LOG4CXX_STR("log4j properties,txt"));
-          LogString delim(LOG4CXX_STR(" ,"));
-          testBody(src, delim);
-        }
+		try
+		{
+			LogString token(tokenizer.nextToken());
+		}
+		catch (NoSuchElementException& ex)
+		{
+			return;
+		}
 
-        void test6() {
-           LogString src(LOG4CXX_STR(" log4j properties,txt "));
-           LogString delim(LOG4CXX_STR(" ,"));
-           testBody(src, delim);
-        }
+		LOGUNIT_ASSERT(false);
+	}
+
+	void test1()
+	{
+		LogString src(LOG4CXX_STR("log4j.properties.txt"));
+		LogString delim(LOG4CXX_STR("."));
+		testBody(src, delim);
+	}
+
+	void test2()
+	{
+		LogString src(LOG4CXX_STR(".log4j.properties.txt"));
+		LogString delim(LOG4CXX_STR("."));
+		testBody(src, delim);
+	}
+
+	void test3()
+	{
+		LogString src(LOG4CXX_STR("log4j.properties.txt."));
+		LogString delim(LOG4CXX_STR("."));
+		testBody(src, delim);
+	}
+
+	void test4()
+	{
+		LogString src(LOG4CXX_STR("log4j..properties....txt"));
+		LogString delim(LOG4CXX_STR("."));
+		testBody(src, delim);
+	}
+
+	void test5()
+	{
+		LogString src(LOG4CXX_STR("log4j properties,txt"));
+		LogString delim(LOG4CXX_STR(" ,"));
+		testBody(src, delim);
+	}
+
+	void test6()
+	{
+		LogString src(LOG4CXX_STR(" log4j properties,txt "));
+		LogString delim(LOG4CXX_STR(" ,"));
+		testBody(src, delim);
+	}
 
 };
 
diff --git a/src/test/cpp/helpers/syslogwritertest.cpp b/src/test/cpp/helpers/syslogwritertest.cpp
index b5961f9..e46543a 100644
--- a/src/test/cpp/helpers/syslogwritertest.cpp
+++ b/src/test/cpp/helpers/syslogwritertest.cpp
@@ -24,19 +24,20 @@
 
 LOGUNIT_CLASS(SyslogWriterTest)
 {
-        LOGUNIT_TEST_SUITE(SyslogWriterTest);
-                LOGUNIT_TEST(testUnknownHost);
-        LOGUNIT_TEST_SUITE_END();
+	LOGUNIT_TEST_SUITE(SyslogWriterTest);
+	LOGUNIT_TEST(testUnknownHost);
+	LOGUNIT_TEST_SUITE_END();
 
 public:
-        /**
-         * Tests writing to an unknown host.
-         */
-        void testUnknownHost() {
-           SyslogWriter writer(LOG4CXX_STR("unknown.invalid"));
-           writer.write(LOG4CXX_STR("Hello, Unknown World."));
-        }
-      
+	/**
+	 * Tests writing to an unknown host.
+	 */
+	void testUnknownHost()
+	{
+		SyslogWriter writer(LOG4CXX_STR("unknown.invalid"));
+		writer.write(LOG4CXX_STR("Hello, Unknown World."));
+	}
+
 };
 
 
diff --git a/src/test/cpp/helpers/threadtestcase.cpp b/src/test/cpp/helpers/threadtestcase.cpp
index c7df2c0..21fc671 100644
--- a/src/test/cpp/helpers/threadtestcase.cpp
+++ b/src/test/cpp/helpers/threadtestcase.cpp
@@ -26,39 +26,46 @@
 
 /**
    Unit test for Thread.
-   
-   */
-LOGUNIT_CLASS(ThreadTestCase) {
-  LOGUNIT_TEST_SUITE(ThreadTestCase);
-          LOGUNIT_TEST(testInterrupt);
-  LOGUNIT_TEST_SUITE_END();
 
-  public:
-  /**
-   * Start a thread that will wait for a minute, then interrupt it.
    */
-  void testInterrupt() {
-    Thread thread1;
-    bool interrupted = false;
-    thread1.run(sleep, &interrupted);
-    apr_sleep(100000);
-    apr_time_t start = apr_time_now();
-    thread1.interrupt();
-    thread1.join();
-    LOGUNIT_ASSERT_EQUAL(true, interrupted);
-    apr_time_t elapsed = apr_time_now() - start;
-    LOGUNIT_ASSERT(elapsed < 1000000); 
-  }
+LOGUNIT_CLASS(ThreadTestCase)
+{
+	LOGUNIT_TEST_SUITE(ThreadTestCase);
+	LOGUNIT_TEST(testInterrupt);
+	LOGUNIT_TEST_SUITE_END();
+
+public:
+	/**
+	 * Start a thread that will wait for a minute, then interrupt it.
+	 */
+	void testInterrupt()
+	{
+		Thread thread1;
+		bool interrupted = false;
+		thread1.run(sleep, &interrupted);
+		apr_sleep(100000);
+		apr_time_t start = apr_time_now();
+		thread1.interrupt();
+		thread1.join();
+		LOGUNIT_ASSERT_EQUAL(true, interrupted);
+		apr_time_t elapsed = apr_time_now() - start;
+		LOGUNIT_ASSERT(elapsed < 1000000);
+	}
 
 private:
-  static void* LOG4CXX_THREAD_FUNC sleep(apr_thread_t* thread, void* data) {
-      try {
-        Thread::sleep(60000);
-      } catch(InterruptedException& ex) {
-        *(reinterpret_cast<bool*>(data)) = true;
-      }
-      return NULL;
-  }
+	static void* LOG4CXX_THREAD_FUNC sleep(apr_thread_t* thread, void* data)
+	{
+		try
+		{
+			Thread::sleep(60000);
+		}
+		catch (InterruptedException& ex)
+		{
+			*(reinterpret_cast<bool*>(data)) = true;
+		}
+
+		return NULL;
+	}
 
 };
 
diff --git a/src/test/cpp/helpers/timezonetestcase.cpp b/src/test/cpp/helpers/timezonetestcase.cpp
index 4883c27..cdbe58a 100644
--- a/src/test/cpp/helpers/timezonetestcase.cpp
+++ b/src/test/cpp/helpers/timezonetestcase.cpp
@@ -25,99 +25,106 @@
 
 //Define INT64_C for compilers that don't have it
 #if (!defined(INT64_C))
-#define INT64_C(value)  value ## LL
+	#define INT64_C(value)  value ## LL
 #endif
 
 
 /**
    Unit test {@link TimeZone}.
-   
+
    */
-LOGUNIT_CLASS(TimeZoneTestCase) {
-  LOGUNIT_TEST_SUITE(TimeZoneTestCase);
-          LOGUNIT_TEST(test1);
-          LOGUNIT_TEST(test2);
+LOGUNIT_CLASS(TimeZoneTestCase)
+{
+	LOGUNIT_TEST_SUITE(TimeZoneTestCase);
+	LOGUNIT_TEST(test1);
+	LOGUNIT_TEST(test2);
 #if !defined(__BORLANDC__)
-          LOGUNIT_TEST(test3);
+	LOGUNIT_TEST(test3);
 #endif
-          LOGUNIT_TEST(test4);
-          LOGUNIT_TEST(test5);
-          LOGUNIT_TEST(test6);
-  LOGUNIT_TEST_SUITE_END();
+	LOGUNIT_TEST(test4);
+	LOGUNIT_TEST(test5);
+	LOGUNIT_TEST(test6);
+	LOGUNIT_TEST_SUITE_END();
 
 #define MICROSECONDS_PER_DAY APR_INT64_C(86400000000)
 
 
-  public:
-  /**
-   * Checks the GMT timezone
-   */
-  void test1() {
-    TimeZonePtr tz(TimeZone::getGMT());
-    LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("GMT"), tz->getID());
-  }
+public:
+	/**
+	 * Checks the GMT timezone
+	 */
+	void test1()
+	{
+		TimeZonePtr tz(TimeZone::getGMT());
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("GMT"), tz->getID());
+	}
 
-  /**
-   * Get "GMT-6" time zone
-   */
-  void test2() {
-    TimeZonePtr tz(TimeZone::getTimeZone(LOG4CXX_STR("GMT-6")));
-    LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("GMT-06:00"), tz->getID());
+	/**
+	 * Get "GMT-6" time zone
+	 */
+	void test2()
+	{
+		TimeZonePtr tz(TimeZone::getTimeZone(LOG4CXX_STR("GMT-6")));
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("GMT-06:00"), tz->getID());
 
-    apr_time_t jan2 = MICROSECONDS_PER_DAY * 12420;
-    apr_time_exp_t exploded;
-    tz->explode(&exploded, jan2);
-    LOGUNIT_ASSERT_EQUAL(-6 * 3600, exploded.tm_gmtoff);
-    LOGUNIT_ASSERT_EQUAL(18, exploded.tm_hour);
-  }
+		apr_time_t jan2 = MICROSECONDS_PER_DAY * 12420;
+		apr_time_exp_t exploded;
+		tz->explode(&exploded, jan2);
+		LOGUNIT_ASSERT_EQUAL(-6 * 3600, exploded.tm_gmtoff);
+		LOGUNIT_ASSERT_EQUAL(18, exploded.tm_hour);
+	}
 
-  /**
-   * Get the default timezone name
-   */
-  void test3() {
-    TimeZonePtr tz(TimeZone::getDefault());
-    LogString tzName(tz->getID());
-    LOGUNIT_ASSERT(tzName.length() > 0);
-  }
+	/**
+	 * Get the default timezone name
+	 */
+	void test3()
+	{
+		TimeZonePtr tz(TimeZone::getDefault());
+		LogString tzName(tz->getID());
+		LOGUNIT_ASSERT(tzName.length() > 0);
+	}
 
 
-/**
- * Get "GMT+0010" time zone
- */
-void test4() {
-  TimeZonePtr tz(TimeZone::getTimeZone(LOG4CXX_STR("GMT+0010")));
-  LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("GMT+00:10"), tz->getID());
+	/**
+	 * Get "GMT+0010" time zone
+	 */
+	void test4()
+	{
+		TimeZonePtr tz(TimeZone::getTimeZone(LOG4CXX_STR("GMT+0010")));
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("GMT+00:10"), tz->getID());
 
-  apr_time_t jan2 = MICROSECONDS_PER_DAY * 12420;
-  apr_time_exp_t exploded;
-  tz->explode(&exploded, jan2);
-  LOGUNIT_ASSERT_EQUAL(600, exploded.tm_gmtoff);
-  LOGUNIT_ASSERT_EQUAL(0, exploded.tm_hour);
-  LOGUNIT_ASSERT_EQUAL(10, exploded.tm_min);
-}
+		apr_time_t jan2 = MICROSECONDS_PER_DAY * 12420;
+		apr_time_exp_t exploded;
+		tz->explode(&exploded, jan2);
+		LOGUNIT_ASSERT_EQUAL(600, exploded.tm_gmtoff);
+		LOGUNIT_ASSERT_EQUAL(0, exploded.tm_hour);
+		LOGUNIT_ASSERT_EQUAL(10, exploded.tm_min);
+	}
 
 
-/**
- * Get "GMT+6" time zone
- */
-void test5() {
-  TimeZonePtr tz(TimeZone::getTimeZone(LOG4CXX_STR("GMT+6")));
-  LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("GMT+06:00"), tz->getID());
+	/**
+	 * Get "GMT+6" time zone
+	 */
+	void test5()
+	{
+		TimeZonePtr tz(TimeZone::getTimeZone(LOG4CXX_STR("GMT+6")));
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("GMT+06:00"), tz->getID());
 
-  apr_time_t jan2 = MICROSECONDS_PER_DAY * 12420;
-  apr_time_exp_t exploded;
-  tz->explode(&exploded, jan2);
-  LOGUNIT_ASSERT_EQUAL(6 * 3600, exploded.tm_gmtoff);
-  LOGUNIT_ASSERT_EQUAL(6, exploded.tm_hour);
-}
+		apr_time_t jan2 = MICROSECONDS_PER_DAY * 12420;
+		apr_time_exp_t exploded;
+		tz->explode(&exploded, jan2);
+		LOGUNIT_ASSERT_EQUAL(6 * 3600, exploded.tm_gmtoff);
+		LOGUNIT_ASSERT_EQUAL(6, exploded.tm_hour);
+	}
 
-/**
- * Checks the GMT timezone
- */
-void test6() {
-  TimeZonePtr tz(TimeZone::getTimeZone(LOG4CXX_STR("GMT")));
-  LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("GMT"), tz->getID());
-}
+	/**
+	 * Checks the GMT timezone
+	 */
+	void test6()
+	{
+		TimeZonePtr tz(TimeZone::getTimeZone(LOG4CXX_STR("GMT")));
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("GMT"), tz->getID());
+	}
 
 
 };
diff --git a/src/test/cpp/helpers/transcodertestcase.cpp b/src/test/cpp/helpers/transcodertestcase.cpp
index cc394f0..4f3a061 100644
--- a/src/test/cpp/helpers/transcodertestcase.cpp
+++ b/src/test/cpp/helpers/transcodertestcase.cpp
@@ -26,315 +26,345 @@
 
 LOGUNIT_CLASS(TranscoderTestCase)
 {
-        LOGUNIT_TEST_SUITE(TranscoderTestCase);
-                LOGUNIT_TEST(decode1);
+	LOGUNIT_TEST_SUITE(TranscoderTestCase);
+	LOGUNIT_TEST(decode1);
 #if LOG4CXX_WCHAR_T_API
-                LOGUNIT_TEST(decode2);
+	LOGUNIT_TEST(decode2);
 #endif
-                LOGUNIT_TEST(decode3);
+	LOGUNIT_TEST(decode3);
 #if LOG4CXX_WCHAR_T_API
-                LOGUNIT_TEST(decode4);
+	LOGUNIT_TEST(decode4);
 #endif
-                LOGUNIT_TEST(decode7);
-                LOGUNIT_TEST(decode8);
+	LOGUNIT_TEST(decode7);
+	LOGUNIT_TEST(decode8);
 #if LOG4CXX_WCHAR_T_API
-                LOGUNIT_TEST(encode1);
+	LOGUNIT_TEST(encode1);
 #endif
-                LOGUNIT_TEST(encode2);
+	LOGUNIT_TEST(encode2);
 #if LOG4CXX_WCHAR_T_API
-                LOGUNIT_TEST(encode3);
+	LOGUNIT_TEST(encode3);
 #endif
-                LOGUNIT_TEST(encode4);
+	LOGUNIT_TEST(encode4);
 #if LOG4CXX_WCHAR_T_API
-                LOGUNIT_TEST(encode5);
+	LOGUNIT_TEST(encode5);
 #endif
-                LOGUNIT_TEST(encode6);
-                LOGUNIT_TEST(testDecodeUTF8_1);
-                LOGUNIT_TEST(testDecodeUTF8_2);
-                LOGUNIT_TEST(testDecodeUTF8_3);
-                LOGUNIT_TEST(testDecodeUTF8_4);
+	LOGUNIT_TEST(encode6);
+	LOGUNIT_TEST(testDecodeUTF8_1);
+	LOGUNIT_TEST(testDecodeUTF8_2);
+	LOGUNIT_TEST(testDecodeUTF8_3);
+	LOGUNIT_TEST(testDecodeUTF8_4);
 #if LOG4CXX_UNICHAR_API
-                LOGUNIT_TEST(udecode2);
-                LOGUNIT_TEST(udecode4);
-                LOGUNIT_TEST(uencode1);
-                LOGUNIT_TEST(uencode3);
-                LOGUNIT_TEST(uencode5);
+	LOGUNIT_TEST(udecode2);
+	LOGUNIT_TEST(udecode4);
+	LOGUNIT_TEST(uencode1);
+	LOGUNIT_TEST(uencode3);
+	LOGUNIT_TEST(uencode5);
 #endif
 #if LOG4CXX_LOGCHAR_IS_UTF8
-                LOGUNIT_TEST(encodeCharsetName1);
-                LOGUNIT_TEST(encodeCharsetName2);
-                LOGUNIT_TEST(encodeCharsetName3);
+	LOGUNIT_TEST(encodeCharsetName1);
+	LOGUNIT_TEST(encodeCharsetName2);
+	LOGUNIT_TEST(encodeCharsetName3);
 #endif
-        LOGUNIT_TEST_SUITE_END();
+	LOGUNIT_TEST_SUITE_END();
 
 
 public:
-        void decode1() {
-          const char* greeting = "Hello, World";
-          LogString decoded(LOG4CXX_STR("foo\n"));
-          Transcoder::decode(greeting, decoded);
-          LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("foo\nHello, World"), decoded);
-        }
+	void decode1()
+	{
+		const char* greeting = "Hello, World";
+		LogString decoded(LOG4CXX_STR("foo\n"));
+		Transcoder::decode(greeting, decoded);
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("foo\nHello, World"), decoded);
+	}
 
 #if LOG4CXX_WCHAR_T_API
-        void decode2() {
-          const wchar_t* greeting = L"Hello, World";
-          LogString decoded(LOG4CXX_STR("foo\n"));
-          Transcoder::decode(greeting, decoded);
-          LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("foo\nHello, World"), decoded);
-        }
+	void decode2()
+	{
+		const wchar_t* greeting = L"Hello, World";
+		LogString decoded(LOG4CXX_STR("foo\n"));
+		Transcoder::decode(greeting, decoded);
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("foo\nHello, World"), decoded);
+	}
 #endif
 
-        void decode3() {
-           const char* nothing = "";
-           LogString decoded(LOG4CXX_STR("foo\n"));
-           Transcoder::decode(nothing, decoded);
-           LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("foo\n"), decoded);
-        }
+	void decode3()
+	{
+		const char* nothing = "";
+		LogString decoded(LOG4CXX_STR("foo\n"));
+		Transcoder::decode(nothing, decoded);
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("foo\n"), decoded);
+	}
 
 #if LOG4CXX_WCHAR_T_API
-        void decode4() {
-            const wchar_t* nothing = L"";
-            LogString decoded(LOG4CXX_STR("foo\n"));
-            Transcoder::decode(nothing, decoded);
-            LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("foo\n"), decoded);
-        }
+	void decode4()
+	{
+		const wchar_t* nothing = L"";
+		LogString decoded(LOG4CXX_STR("foo\n"));
+		Transcoder::decode(nothing, decoded);
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("foo\n"), decoded);
+	}
 #endif
 
 
-        enum { BUFSIZE = 255 };
+	enum { BUFSIZE = 255 };
 
-        void decode7() {
-            //
-            //   normal characters striding over a buffer boundary
-            //
-            std::string longMsg(BUFSIZE - 2, 'A');
-            longMsg.append("Hello");
-            LogString decoded;
-            Transcoder::decode(longMsg, decoded);
-            LOGUNIT_ASSERT_EQUAL((size_t) BUFSIZE + 3, decoded.length());
-            LOGUNIT_ASSERT_EQUAL(LogString(BUFSIZE -2, LOG4CXX_STR('A')),
-                  decoded.substr(0, BUFSIZE - 2));
-            LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("Hello"),
-                  decoded.substr(BUFSIZE -2 ));
-        }
+	void decode7()
+	{
+		//
+		//   normal characters striding over a buffer boundary
+		//
+		std::string longMsg(BUFSIZE - 2, 'A');
+		longMsg.append("Hello");
+		LogString decoded;
+		Transcoder::decode(longMsg, decoded);
+		LOGUNIT_ASSERT_EQUAL((size_t) BUFSIZE + 3, decoded.length());
+		LOGUNIT_ASSERT_EQUAL(LogString(BUFSIZE - 2, LOG4CXX_STR('A')),
+			decoded.substr(0, BUFSIZE - 2));
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("Hello"),
+			decoded.substr(BUFSIZE - 2 ));
+	}
 
-        void decode8() {
-            std::string msg("Hello, World.");
-            LogString actual;
-            Transcoder::decode(msg, actual);
-            LogString expected(LOG4CXX_STR("Hello, World."));
-            LOGUNIT_ASSERT_EQUAL(expected, actual);
-        }
+	void decode8()
+	{
+		std::string msg("Hello, World.");
+		LogString actual;
+		Transcoder::decode(msg, actual);
+		LogString expected(LOG4CXX_STR("Hello, World."));
+		LOGUNIT_ASSERT_EQUAL(expected, actual);
+	}
 
 
 #if LOG4CXX_WCHAR_T_API
-        void encode1() {
-          const LogString greeting(LOG4CXX_STR("Hello, World"));
-          std::wstring encoded;
-          Transcoder::encode(greeting, encoded);
-          LOGUNIT_ASSERT_EQUAL((std::wstring) L"Hello, World", encoded);
-        }
+	void encode1()
+	{
+		const LogString greeting(LOG4CXX_STR("Hello, World"));
+		std::wstring encoded;
+		Transcoder::encode(greeting, encoded);
+		LOGUNIT_ASSERT_EQUAL((std::wstring) L"Hello, World", encoded);
+	}
 #endif
 
-        void encode2() {
-          const LogString greeting(LOG4CXX_STR("Hello, World"));
-          std::string encoded;
-          Transcoder::encode(greeting, encoded);
-          LOGUNIT_ASSERT_EQUAL((std::string) "Hello, World", encoded);
-        }
+	void encode2()
+	{
+		const LogString greeting(LOG4CXX_STR("Hello, World"));
+		std::string encoded;
+		Transcoder::encode(greeting, encoded);
+		LOGUNIT_ASSERT_EQUAL((std::string) "Hello, World", encoded);
+	}
 
 #if LOG4CXX_WCHAR_T_API
-        void encode3() {
-          LogString greeting(BUFSIZE - 3, LOG4CXX_STR('A'));
-          greeting.append(LOG4CXX_STR("Hello"));
-          std::wstring encoded;
-          Transcoder::encode(greeting, encoded);
-          std::wstring manyAs(BUFSIZE - 3, L'A');
-          LOGUNIT_ASSERT_EQUAL(manyAs, encoded.substr(0, BUFSIZE - 3));
-          LOGUNIT_ASSERT_EQUAL(std::wstring(L"Hello"), encoded.substr(BUFSIZE - 3));
-        }
+	void encode3()
+	{
+		LogString greeting(BUFSIZE - 3, LOG4CXX_STR('A'));
+		greeting.append(LOG4CXX_STR("Hello"));
+		std::wstring encoded;
+		Transcoder::encode(greeting, encoded);
+		std::wstring manyAs(BUFSIZE - 3, L'A');
+		LOGUNIT_ASSERT_EQUAL(manyAs, encoded.substr(0, BUFSIZE - 3));
+		LOGUNIT_ASSERT_EQUAL(std::wstring(L"Hello"), encoded.substr(BUFSIZE - 3));
+	}
 #endif
 
-        void encode4() {
-          LogString greeting(BUFSIZE - 3, LOG4CXX_STR('A'));
-          greeting.append(LOG4CXX_STR("Hello"));
-          std::string encoded;
-          Transcoder::encode(greeting, encoded);
-          std::string manyAs(BUFSIZE - 3, 'A');
-          LOGUNIT_ASSERT_EQUAL(manyAs, encoded.substr(0, BUFSIZE - 3));
-          LOGUNIT_ASSERT_EQUAL(std::string("Hello"), encoded.substr(BUFSIZE - 3));
-        }
+	void encode4()
+	{
+		LogString greeting(BUFSIZE - 3, LOG4CXX_STR('A'));
+		greeting.append(LOG4CXX_STR("Hello"));
+		std::string encoded;
+		Transcoder::encode(greeting, encoded);
+		std::string manyAs(BUFSIZE - 3, 'A');
+		LOGUNIT_ASSERT_EQUAL(manyAs, encoded.substr(0, BUFSIZE - 3));
+		LOGUNIT_ASSERT_EQUAL(std::string("Hello"), encoded.substr(BUFSIZE - 3));
+	}
 
 #if LOG4CXX_WCHAR_T_API
-        void encode5() {
-          //   arbitrary, hopefully meaningless, characters from
-          //     Latin, Arabic, Armenian, Bengali, CJK and Cyrillic
-          const wchar_t greeting[] = { L'A', 0x0605, 0x0530, 0x984, 0x40E3, 0x400, 0 };
-          //
-          //  decode to LogString (UTF-16 or UTF-8)
-          //
-          LogString decoded;
-          Transcoder::decode(greeting, decoded);
-          //
-          //  decode to wstring
-          //
-          std::wstring encoded;
-          Transcoder::encode(decoded, encoded);
-          //
-          //   should be lossless
-          //
-          LOGUNIT_ASSERT_EQUAL((std::wstring) greeting, encoded);
-        }
+	void encode5()
+	{
+		//   arbitrary, hopefully meaningless, characters from
+		//     Latin, Arabic, Armenian, Bengali, CJK and Cyrillic
+		const wchar_t greeting[] = { L'A', 0x0605, 0x0530, 0x984, 0x40E3, 0x400, 0 };
+		//
+		//  decode to LogString (UTF-16 or UTF-8)
+		//
+		LogString decoded;
+		Transcoder::decode(greeting, decoded);
+		//
+		//  decode to wstring
+		//
+		std::wstring encoded;
+		Transcoder::encode(decoded, encoded);
+		//
+		//   should be lossless
+		//
+		LOGUNIT_ASSERT_EQUAL((std::wstring) greeting, encoded);
+	}
 #endif
 
-        void encode6() {
+	void encode6()
+	{
 #if LOG4CXX_LOGCHAR_IS_WCHAR || LOG4CXX_LOGCHAR_IS_UNICHAR
-          //   arbitrary, hopefully meaningless, characters from
-          //     Latin, Arabic, Armenian, Bengali, CJK and Cyrillic
-          const logchar greeting[] = { L'A', 0x0605, 0x0530, 0x984, 0x40E3, 0x400, 0 };
+		//   arbitrary, hopefully meaningless, characters from
+		//     Latin, Arabic, Armenian, Bengali, CJK and Cyrillic
+		const logchar greeting[] = { L'A', 0x0605, 0x0530, 0x984, 0x40E3, 0x400, 0 };
 #endif
 
 #if LOG4CXX_LOGCHAR_IS_UTF8
-          const char greeting[] = { 'A',
-                                    (char) 0xD8, (char) 0x85,
-                                    (char) 0xD4, (char) 0xB0,
-                                    (char) 0xE0, (char) 0xCC, (char) 0x84,
-                                    (char) 0xE8, (char) 0x87, (char) 0x83,
-                                    (char) 0xD0, (char) 0x80,
-                                    0 };
+		const char greeting[] = { 'A',
+				(char) 0xD8, (char) 0x85,
+				(char) 0xD4, (char) 0xB0,
+				(char) 0xE0, (char) 0xCC, (char) 0x84,
+				(char) 0xE8, (char) 0x87, (char) 0x83,
+				(char) 0xD0, (char) 0x80,
+				0
+			};
 #endif
 
-          //
-          //  decode to LogString (UTF-16 or UTF-8)
-          //
-          LogString decoded;
-          Transcoder::decode(greeting, decoded);
-          //
-          //  decode to wstring
-          //
-          std::string encoded;
-          //
-          //   likely 'A\u0605\u0530\u0984\u40E3\u0400'
-          //
-          Transcoder::encode(decoded, encoded);
-        }
+		//
+		//  decode to LogString (UTF-16 or UTF-8)
+		//
+		LogString decoded;
+		Transcoder::decode(greeting, decoded);
+		//
+		//  decode to wstring
+		//
+		std::string encoded;
+		//
+		//   likely 'A\u0605\u0530\u0984\u40E3\u0400'
+		//
+		Transcoder::encode(decoded, encoded);
+	}
 
-    void testDecodeUTF8_1() {
-        std::string src("a");
-        LogString out;
-        Transcoder::decodeUTF8(src, out);
-        LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("a")), out);
-    }
+	void testDecodeUTF8_1()
+	{
+		std::string src("a");
+		LogString out;
+		Transcoder::decodeUTF8(src, out);
+		LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("a")), out);
+	}
 
-    void testDecodeUTF8_2() {
-        std::string src(1, 0x80);
-        LogString out;
-        Transcoder::decodeUTF8(src, out);
-        LOGUNIT_ASSERT_EQUAL(LogString(1, Transcoder::LOSSCHAR), out);
-    }
+	void testDecodeUTF8_2()
+	{
+		std::string src(1, 0x80);
+		LogString out;
+		Transcoder::decodeUTF8(src, out);
+		LOGUNIT_ASSERT_EQUAL(LogString(1, Transcoder::LOSSCHAR), out);
+	}
 
-    void testDecodeUTF8_3() {
-        std::string src("\xC2");
-        LogString out;
-        Transcoder::decodeUTF8(src, out);
-        LOGUNIT_ASSERT_EQUAL(LogString(1, Transcoder::LOSSCHAR), out);
-    }
+	void testDecodeUTF8_3()
+	{
+		std::string src("\xC2");
+		LogString out;
+		Transcoder::decodeUTF8(src, out);
+		LOGUNIT_ASSERT_EQUAL(LogString(1, Transcoder::LOSSCHAR), out);
+	}
 
-    void testDecodeUTF8_4() {
-        std::string src("\xC2\xA9");
-        LogString out;
-        Transcoder::decodeUTF8(src, out);
-        LogString::const_iterator iter = out.begin();
-        unsigned int sv = Transcoder::decode(out, iter);
-        LOGUNIT_ASSERT_EQUAL((unsigned int) 0xA9, sv);
-        LOGUNIT_ASSERT_EQUAL(true, iter == out.end());
-    }
+	void testDecodeUTF8_4()
+	{
+		std::string src("\xC2\xA9");
+		LogString out;
+		Transcoder::decodeUTF8(src, out);
+		LogString::const_iterator iter = out.begin();
+		unsigned int sv = Transcoder::decode(out, iter);
+		LOGUNIT_ASSERT_EQUAL((unsigned int) 0xA9, sv);
+		LOGUNIT_ASSERT_EQUAL(true, iter == out.end());
+	}
 
 
 #if LOG4CXX_UNICHAR_API
-        void udecode2() {
-          const UniChar greeting[] = { 'H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd', 0 };
-          LogString decoded(LOG4CXX_STR("foo\n"));
-          Transcoder::decode(greeting, decoded);
-          LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("foo\nHello, World"), decoded);
-        }
+	void udecode2()
+	{
+		const UniChar greeting[] = { 'H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd', 0 };
+		LogString decoded(LOG4CXX_STR("foo\n"));
+		Transcoder::decode(greeting, decoded);
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("foo\nHello, World"), decoded);
+	}
 
-        void udecode4() {
-            const UniChar nothing[] = { 0 };
-            LogString decoded(LOG4CXX_STR("foo\n"));
-            Transcoder::decode(nothing, decoded);
-            LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("foo\n"), decoded);
-        }
+	void udecode4()
+	{
+		const UniChar nothing[] = { 0 };
+		LogString decoded(LOG4CXX_STR("foo\n"));
+		Transcoder::decode(nothing, decoded);
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("foo\n"), decoded);
+	}
 
-        void uencode1() {
-          const LogString greeting(LOG4CXX_STR("Hello, World"));
-          std::basic_string<UniChar> encoded;
-          Transcoder::encode(greeting, encoded);
-          const UniChar expected[] = { 'H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd', 0 };
-          LOGUNIT_ASSERT_EQUAL(std::basic_string<UniChar>(expected), encoded);
-        }
+	void uencode1()
+	{
+		const LogString greeting(LOG4CXX_STR("Hello, World"));
+		std::basic_string<UniChar> encoded;
+		Transcoder::encode(greeting, encoded);
+		const UniChar expected[] = { 'H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd', 0 };
+		LOGUNIT_ASSERT_EQUAL(std::basic_string<UniChar>(expected), encoded);
+	}
 
-        void uencode3() {
-          LogString greeting(BUFSIZE - 3, LOG4CXX_STR('A'));
-          greeting.append(LOG4CXX_STR("Hello"));
-          std::basic_string<UniChar> encoded;
-          Transcoder::encode(greeting, encoded);
-          std::basic_string<UniChar> manyAs(BUFSIZE - 3, 'A');
-          LOGUNIT_ASSERT_EQUAL(manyAs, encoded.substr(0, BUFSIZE - 3));
-          const UniChar hello[] = { 'H', 'e', 'l', 'l', 'o', 0 };
-          LOGUNIT_ASSERT_EQUAL(std::basic_string<UniChar>(hello), encoded.substr(BUFSIZE - 3));
-        }
+	void uencode3()
+	{
+		LogString greeting(BUFSIZE - 3, LOG4CXX_STR('A'));
+		greeting.append(LOG4CXX_STR("Hello"));
+		std::basic_string<UniChar> encoded;
+		Transcoder::encode(greeting, encoded);
+		std::basic_string<UniChar> manyAs(BUFSIZE - 3, 'A');
+		LOGUNIT_ASSERT_EQUAL(manyAs, encoded.substr(0, BUFSIZE - 3));
+		const UniChar hello[] = { 'H', 'e', 'l', 'l', 'o', 0 };
+		LOGUNIT_ASSERT_EQUAL(std::basic_string<UniChar>(hello), encoded.substr(BUFSIZE - 3));
+	}
 
-        void uencode5() {
-          //   arbitrary, hopefully meaningless, characters from
-          //     Latin, Arabic, Armenian, Bengali, CJK and Cyrillic
-          const UniChar greeting[] = { L'A', 0x0605, 0x0530, 0x984, 0x40E3, 0x400, 0 };
-          //
-          //  decode to LogString (UTF-16 or UTF-8)
-          //
-          LogString decoded;
-          Transcoder::decode(greeting, decoded);
-          //
-          //  decode to basic_string<UniChar>
-          //
-          std::basic_string<UniChar> encoded;
-          Transcoder::encode(decoded, encoded);
-          //
-          //   should be lossless
-          //
-          LOGUNIT_ASSERT_EQUAL(std::basic_string<UniChar>(greeting), encoded);
-        }
+	void uencode5()
+	{
+		//   arbitrary, hopefully meaningless, characters from
+		//     Latin, Arabic, Armenian, Bengali, CJK and Cyrillic
+		const UniChar greeting[] = { L'A', 0x0605, 0x0530, 0x984, 0x40E3, 0x400, 0 };
+		//
+		//  decode to LogString (UTF-16 or UTF-8)
+		//
+		LogString decoded;
+		Transcoder::decode(greeting, decoded);
+		//
+		//  decode to basic_string<UniChar>
+		//
+		std::basic_string<UniChar> encoded;
+		Transcoder::encode(decoded, encoded);
+		//
+		//   should be lossless
+		//
+		LOGUNIT_ASSERT_EQUAL(std::basic_string<UniChar>(greeting), encoded);
+	}
 #endif
 
 #if LOG4CXX_LOGCHAR_IS_UTF8
-        void encodeCharsetName1() {
-            const logchar utf8[] = { 0x75, 0x74, 0x66, 0x2D, 0x38, 0x00 };
-            std::string encoded(Transcoder::encodeCharsetName(LogString(utf8)));
-            LOGUNIT_ASSERT_EQUAL(std::string("utf-8"), encoded);
-        }
+	void encodeCharsetName1()
+	{
+		const logchar utf8[] = { 0x75, 0x74, 0x66, 0x2D, 0x38, 0x00 };
+		std::string encoded(Transcoder::encodeCharsetName(LogString(utf8)));
+		LOGUNIT_ASSERT_EQUAL(std::string("utf-8"), encoded);
+	}
 
-        void encodeCharsetName2() {
-            logchar lascii[0x60];
-            char ascii[0x60];
-            for(int i = 0; i < 0x5F; i++) {
-                lascii[i] = i + 0x20;
-                ascii[i] = i + 0x20;
-            }
-            lascii[0x5F] = 0;
-            ascii[0x5F] = 0;
-            std::string encoded(Transcoder::encodeCharsetName(LogString(ascii)));
-            LOGUNIT_ASSERT_EQUAL(std::string(" !\"#$%&'()*+,-./"), encoded.substr(0, 0x10));
-            if (0x40 == 'A') {
-                LOGUNIT_ASSERT_EQUAL(std::string(ascii), encoded);
-            }
-        }
+	void encodeCharsetName2()
+	{
+		logchar lascii[0x60];
+		char ascii[0x60];
 
-        void encodeCharsetName3() {
-            logchar unsupported[] = { 0x1F, 0x7F, static_cast<logchar>(0x80), static_cast<logchar>(0x81), 0x00 };
-            std::string encoded(Transcoder::encodeCharsetName(LogString(unsupported)));
-            LOGUNIT_ASSERT_EQUAL(std::string("????"), encoded);
-        }
+		for (int i = 0; i < 0x5F; i++)
+		{
+			lascii[i] = i + 0x20;
+			ascii[i] = i + 0x20;
+		}
+
+		lascii[0x5F] = 0;
+		ascii[0x5F] = 0;
+		std::string encoded(Transcoder::encodeCharsetName(LogString(ascii)));
+		LOGUNIT_ASSERT_EQUAL(std::string(" !\"#$%&'()*+,-./"), encoded.substr(0, 0x10));
+
+		if (0x40 == 'A')
+		{
+			LOGUNIT_ASSERT_EQUAL(std::string(ascii), encoded);
+		}
+	}
+
+	void encodeCharsetName3()
+	{
+		logchar unsupported[] = { 0x1F, 0x7F, static_cast<logchar>(0x80), static_cast<logchar>(0x81), 0x00 };
+		std::string encoded(Transcoder::encodeCharsetName(LogString(unsupported)));
+		LOGUNIT_ASSERT_EQUAL(std::string("????"), encoded);
+	}
 #endif
 
 };
diff --git a/src/test/cpp/hierarchytest.cpp b/src/test/cpp/hierarchytest.cpp
index 1475ca1..39bc118 100644
--- a/src/test/cpp/hierarchytest.cpp
+++ b/src/test/cpp/hierarchytest.cpp
@@ -25,31 +25,33 @@
 
 /**
  * Tests hierarchy.
- * 
+ *
  */
-LOGUNIT_CLASS(HierarchyTest) {
-  LOGUNIT_TEST_SUITE(HierarchyTest);
-          LOGUNIT_TEST(testGetParent);
-  LOGUNIT_TEST_SUITE_END();
+LOGUNIT_CLASS(HierarchyTest)
+{
+	LOGUNIT_TEST_SUITE(HierarchyTest);
+	LOGUNIT_TEST(testGetParent);
+	LOGUNIT_TEST_SUITE_END();
 public:
 
-    /**
-     * Tests getParent.
-     */
-  void testGetParent() {
-      //
-      //  Note: test inspired by LOGCXX-118.
-      //
-      LoggerPtr logger1(Logger::getLogger("HierarchyTest_testGetParent.logger1"));
-      LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("root")), logger1->getParent()->getName());
-      LoggerPtr logger2(Logger::getLogger("HierarchyTest_testGetParent.logger2"));
-      LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("root")), logger1->getParent()->getName());
-      LoggerPtr logger3(Logger::getLogger("HierarchyTest_testGetParent"));
-      LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("HierarchyTest_testGetParent")), 
-          logger1->getParent()->getName());
-      LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("HierarchyTest_testGetParent")), 
-          logger2->getParent()->getName());
-  }
+	/**
+	 * Tests getParent.
+	 */
+	void testGetParent()
+	{
+		//
+		//  Note: test inspired by LOGCXX-118.
+		//
+		LoggerPtr logger1(Logger::getLogger("HierarchyTest_testGetParent.logger1"));
+		LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("root")), logger1->getParent()->getName());
+		LoggerPtr logger2(Logger::getLogger("HierarchyTest_testGetParent.logger2"));
+		LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("root")), logger1->getParent()->getName());
+		LoggerPtr logger3(Logger::getLogger("HierarchyTest_testGetParent"));
+		LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("HierarchyTest_testGetParent")),
+			logger1->getParent()->getName());
+		LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("HierarchyTest_testGetParent")),
+			logger2->getParent()->getName());
+	}
 
 };
 
diff --git a/src/test/cpp/hierarchythresholdtestcase.cpp b/src/test/cpp/hierarchythresholdtestcase.cpp
index 89db0e6..a21dfa5 100644
--- a/src/test/cpp/hierarchythresholdtestcase.cpp
+++ b/src/test/cpp/hierarchythresholdtestcase.cpp
@@ -30,102 +30,102 @@
 */
 LOGUNIT_CLASS(HierarchyThresholdTestCase)
 {
-   LOGUNIT_TEST_SUITE(HierarchyThresholdTestCase);
-      LOGUNIT_TEST(test1);
-      LOGUNIT_TEST(test2);
-      LOGUNIT_TEST(test3);
-      LOGUNIT_TEST(test4);
-      LOGUNIT_TEST(test5);
-      LOGUNIT_TEST(test6);
-      LOGUNIT_TEST(test7);
-      LOGUNIT_TEST(test8);
-   LOGUNIT_TEST_SUITE_END();
+	LOGUNIT_TEST_SUITE(HierarchyThresholdTestCase);
+	LOGUNIT_TEST(test1);
+	LOGUNIT_TEST(test2);
+	LOGUNIT_TEST(test3);
+	LOGUNIT_TEST(test4);
+	LOGUNIT_TEST(test5);
+	LOGUNIT_TEST(test6);
+	LOGUNIT_TEST(test7);
+	LOGUNIT_TEST(test8);
+	LOGUNIT_TEST_SUITE_END();
 
 
 public:
-   void setUp()
-   {
-   }
+	void setUp()
+	{
+	}
 
-   void tearDown()
-   {
-      logger->getLoggerRepository()->resetConfiguration();
-   }
+	void tearDown()
+	{
+		logger->getLoggerRepository()->resetConfiguration();
+	}
 
-   void test1()
-   {
-      PropertyConfigurator::configure(LOG4CXX_FILE("input/hierarchyThreshold1.properties"));
-      common();
-      LOGUNIT_ASSERT(Compare::compare(TEMP, LOG4CXX_FILE("witness/hierarchyThreshold.1")));
-   }
+	void test1()
+	{
+		PropertyConfigurator::configure(LOG4CXX_FILE("input/hierarchyThreshold1.properties"));
+		common();
+		LOGUNIT_ASSERT(Compare::compare(TEMP, LOG4CXX_FILE("witness/hierarchyThreshold.1")));
+	}
 
-   void test2()
-   {
-      PropertyConfigurator::configure(LOG4CXX_FILE("input/hierarchyThreshold2.properties"));
-      common();
-      LOGUNIT_ASSERT(Compare::compare(TEMP, LOG4CXX_FILE("witness/hierarchyThreshold.2")));
-   }
+	void test2()
+	{
+		PropertyConfigurator::configure(LOG4CXX_FILE("input/hierarchyThreshold2.properties"));
+		common();
+		LOGUNIT_ASSERT(Compare::compare(TEMP, LOG4CXX_FILE("witness/hierarchyThreshold.2")));
+	}
 
-   void test3()
-   {
-      PropertyConfigurator::configure(LOG4CXX_FILE("input/hierarchyThreshold3.properties"));
-      common();
-      LOGUNIT_ASSERT(Compare::compare(TEMP, LOG4CXX_FILE("witness/hierarchyThreshold.3")));
-   }
+	void test3()
+	{
+		PropertyConfigurator::configure(LOG4CXX_FILE("input/hierarchyThreshold3.properties"));
+		common();
+		LOGUNIT_ASSERT(Compare::compare(TEMP, LOG4CXX_FILE("witness/hierarchyThreshold.3")));
+	}
 
-   void test4()
-   {
-      PropertyConfigurator::configure(LOG4CXX_FILE("input/hierarchyThreshold4.properties"));
-      common();
-      LOGUNIT_ASSERT(Compare::compare(TEMP, LOG4CXX_FILE("witness/hierarchyThreshold.4")));
-   }
+	void test4()
+	{
+		PropertyConfigurator::configure(LOG4CXX_FILE("input/hierarchyThreshold4.properties"));
+		common();
+		LOGUNIT_ASSERT(Compare::compare(TEMP, LOG4CXX_FILE("witness/hierarchyThreshold.4")));
+	}
 
-   void test5()
-   {
-      PropertyConfigurator::configure(LOG4CXX_FILE("input/hierarchyThreshold5.properties"));
-      common();
-      LOGUNIT_ASSERT(Compare::compare(TEMP, LOG4CXX_FILE("witness/hierarchyThreshold.5")));
-   }
+	void test5()
+	{
+		PropertyConfigurator::configure(LOG4CXX_FILE("input/hierarchyThreshold5.properties"));
+		common();
+		LOGUNIT_ASSERT(Compare::compare(TEMP, LOG4CXX_FILE("witness/hierarchyThreshold.5")));
+	}
 
-   void test6()
-   {
-      PropertyConfigurator::configure(LOG4CXX_FILE("input/hierarchyThreshold6.properties"));
-      common();
-      LOGUNIT_ASSERT(Compare::compare(TEMP, LOG4CXX_FILE("witness/hierarchyThreshold.6")));
-   }
+	void test6()
+	{
+		PropertyConfigurator::configure(LOG4CXX_FILE("input/hierarchyThreshold6.properties"));
+		common();
+		LOGUNIT_ASSERT(Compare::compare(TEMP, LOG4CXX_FILE("witness/hierarchyThreshold.6")));
+	}
 
-   void test7()
-   {
-      PropertyConfigurator::configure(LOG4CXX_FILE("input/hierarchyThreshold7.properties"));
-      common();
-      LOGUNIT_ASSERT(Compare::compare(TEMP, LOG4CXX_FILE("witness/hierarchyThreshold.7")));
-   }
+	void test7()
+	{
+		PropertyConfigurator::configure(LOG4CXX_FILE("input/hierarchyThreshold7.properties"));
+		common();
+		LOGUNIT_ASSERT(Compare::compare(TEMP, LOG4CXX_FILE("witness/hierarchyThreshold.7")));
+	}
 
-   void test8()
-   {
-      PropertyConfigurator::configure(LOG4CXX_FILE("input/hierarchyThreshold8.properties"));
-      common();
-      LOGUNIT_ASSERT(Compare::compare(TEMP, LOG4CXX_FILE("witness/hierarchyThreshold.8")));
-   }
+	void test8()
+	{
+		PropertyConfigurator::configure(LOG4CXX_FILE("input/hierarchyThreshold8.properties"));
+		common();
+		LOGUNIT_ASSERT(Compare::compare(TEMP, LOG4CXX_FILE("witness/hierarchyThreshold.8")));
+	}
 
-   static void common()
-   {
-      logger->log(XLevel::getTrace(), LOG4CXX_TEST_STR("m0"));
-      logger->debug(LOG4CXX_TEST_STR("m1"));
-      logger->info(LOG4CXX_TEST_STR("m2"));
-      logger->warn(LOG4CXX_TEST_STR("m3"));
-      logger->error(LOG4CXX_TEST_STR("m4"));
-      logger->fatal(LOG4CXX_TEST_STR("m5"));
-   }
+	static void common()
+	{
+		logger->log(XLevel::getTrace(), LOG4CXX_TEST_STR("m0"));
+		logger->debug(LOG4CXX_TEST_STR("m1"));
+		logger->info(LOG4CXX_TEST_STR("m2"));
+		logger->warn(LOG4CXX_TEST_STR("m3"));
+		logger->error(LOG4CXX_TEST_STR("m4"));
+		logger->fatal(LOG4CXX_TEST_STR("m5"));
+	}
 
 private:
-   static File TEMP;
-   static LoggerPtr logger;
+	static File TEMP;
+	static LoggerPtr logger;
 };
 
 File HierarchyThresholdTestCase::TEMP(LOG4CXX_FILE("output/temp"));
 
 LoggerPtr HierarchyThresholdTestCase::logger =
-   Logger::getLogger(LOG4CXX_TEST_STR("HierarchyThresholdTestCase"));
+	Logger::getLogger(LOG4CXX_TEST_STR("HierarchyThresholdTestCase"));
 
 LOGUNIT_TEST_SUITE_REGISTRATION(HierarchyThresholdTestCase);
diff --git a/src/test/cpp/insertwide.h b/src/test/cpp/insertwide.h
index 3bcc802..c53b75a 100644
--- a/src/test/cpp/insertwide.h
+++ b/src/test/cpp/insertwide.h
@@ -23,12 +23,12 @@
 
 #if LOG4CXX_WCHAR_T_API
 std::ostream& operator<<(std::ostream& os,
-                               const std::wstring& str);
+	const std::wstring& str);
 #endif
 
 #if LOG4CXX_LOGCHAR_IS_UNICHAR  || LOG4CXX_UNICHAR_API || LOG4CXX_CFSTRING_API
 std::ostream& operator<<(std::ostream& os,
-                               const std::basic_string<log4cxx::UniChar>& str);
+	const std::basic_string<log4cxx::UniChar>& str);
 #endif
 
 #endif
diff --git a/src/test/cpp/jsonlayouttest.cpp b/src/test/cpp/jsonlayouttest.cpp
index de1d074..a40db66 100644
--- a/src/test/cpp/jsonlayouttest.cpp
+++ b/src/test/cpp/jsonlayouttest.cpp
@@ -101,22 +101,22 @@
 	 */
 	void testAppendQuotedEscapedStringWithPrintableChars()
 	{
-		LogString s1(LOG4CXX_STR("foo"));	/*  foo */
+		LogString s1(LOG4CXX_STR("foo"));   /*  foo */
 		LogString s2;
-		appendQuotedEscapedString(s2, s1);	/*  "foo"  */
+		appendQuotedEscapedString(s2, s1);  /*  "foo"  */
 		LOGUNIT_ASSERT_EQUAL(LOG4CXX_STR("\"foo\""), s2);
 
 		LogString s3;
-		appendQuotedEscapedString(s3, s2);	/*  "\"foo\""  */
+		appendQuotedEscapedString(s3, s2);  /*  "\"foo\""  */
 		LOGUNIT_ASSERT_EQUAL(LOG4CXX_STR("\"\\\"foo\\\"\""), s3);
 
-		LogString t1(LOG4CXX_STR("bar\"baz"));	/*  bar"baz */
+		LogString t1(LOG4CXX_STR("bar\"baz"));  /*  bar"baz */
 		LogString t2;
-		appendQuotedEscapedString(t2, t1);		/*  "bar\"baz"  */
+		appendQuotedEscapedString(t2, t1);      /*  "bar\"baz"  */
 		LOGUNIT_ASSERT_EQUAL(LOG4CXX_STR("\"bar\\\"baz\""), t2);
 
 		LogString t3;
-		appendQuotedEscapedString(t3, t2);		/*  "\"bar\\\"baz\""    */
+		appendQuotedEscapedString(t3, t2);      /*  "\"bar\\\"baz\""    */
 		LOGUNIT_ASSERT_EQUAL(LOG4CXX_STR("\"\\\"bar\\\\\\\"baz\\\"\""), t3);
 	}
 
@@ -176,7 +176,7 @@
 
 		LogString output1;
 		LogString expected1 = LOG4CXX_STR(", \"context_map\": { "
-			"\"key1\": \"value1\", \"key2\": \"value2\" }");
+				"\"key1\": \"value1\", \"key2\": \"value2\" }");
 
 		appendSerializedMDC(output1, event1);
 		LOGUNIT_ASSERT_EQUAL(expected1, output1);
@@ -199,19 +199,19 @@
 		LogString expected1;
 
 		expected1
-			.append(LOG4CXX_STR(","))
-			.append(LOG4CXX_EOL)
-			.append(ppIndentL1)
-			.append(LOG4CXX_STR("\"context_map\": {"))
-			.append(LOG4CXX_EOL)
-			.append(ppIndentL2)
-			.append(LOG4CXX_STR("\"key1\": \"value1\","))
-			.append(LOG4CXX_EOL)
-			.append(ppIndentL2)
-			.append(LOG4CXX_STR("\"key2\": \"value2\""))
-			.append(LOG4CXX_EOL)
-			.append(ppIndentL1)
-			.append(LOG4CXX_STR("}"));
+		.append(LOG4CXX_STR(","))
+		.append(LOG4CXX_EOL)
+		.append(ppIndentL1)
+		.append(LOG4CXX_STR("\"context_map\": {"))
+		.append(LOG4CXX_EOL)
+		.append(ppIndentL2)
+		.append(LOG4CXX_STR("\"key1\": \"value1\","))
+		.append(LOG4CXX_EOL)
+		.append(ppIndentL2)
+		.append(LOG4CXX_STR("\"key2\": \"value2\""))
+		.append(LOG4CXX_EOL)
+		.append(ppIndentL1)
+		.append(LOG4CXX_STR("}"));
 
 		setPrettyPrint(true);
 		appendSerializedMDC(output1, event1);
@@ -258,16 +258,16 @@
 		LogString expected1;
 
 		expected1
-			.append(LOG4CXX_STR(","))
-			.append(LOG4CXX_EOL)
-			.append(ppIndentL1)
-			.append(LOG4CXX_STR("\"context_stack\": ["))
-			.append(LOG4CXX_EOL)
-			.append(ppIndentL2)
-			.append(LOG4CXX_STR("\"one two three\""))
-			.append(LOG4CXX_EOL)
-			.append(ppIndentL1)
-			.append(LOG4CXX_STR("]"));
+		.append(LOG4CXX_STR(","))
+		.append(LOG4CXX_EOL)
+		.append(ppIndentL1)
+		.append(LOG4CXX_STR("\"context_stack\": ["))
+		.append(LOG4CXX_EOL)
+		.append(ppIndentL2)
+		.append(LOG4CXX_STR("\"one two three\""))
+		.append(LOG4CXX_EOL)
+		.append(ppIndentL1)
+		.append(LOG4CXX_STR("]"));
 
 		setPrettyPrint(true);
 		appendSerializedNDC(output1, event1);
@@ -291,11 +291,11 @@
 		LogString expected1;
 
 		expected1
-			.append(LOG4CXX_STR("\"location_info\": { "))
-			.append(LOG4CXX_STR("\"file\": \"FooFile\", "))
-			.append(LOG4CXX_STR("\"line\": \"42\", "))
-			.append(LOG4CXX_STR("\"class\": \"\", "))
-			.append(LOG4CXX_STR("\"method\": \"BarFunc\" }"));
+		.append(LOG4CXX_STR("\"location_info\": { "))
+		.append(LOG4CXX_STR("\"file\": \"FooFile\", "))
+		.append(LOG4CXX_STR("\"line\": \"42\", "))
+		.append(LOG4CXX_STR("\"class\": \"\", "))
+		.append(LOG4CXX_STR("\"method\": \"BarFunc\" }"));
 
 		appendSerializedLocationInfo(output1, event1, p);
 		LOGUNIT_ASSERT_EQUAL(expected1, output1);
@@ -317,23 +317,23 @@
 		LogString expected1;
 
 		expected1
-			.append(ppIndentL1)
-			.append(LOG4CXX_STR("\"location_info\": {"))
-			.append(LOG4CXX_EOL)
-			.append(ppIndentL2)
-			.append(LOG4CXX_STR("\"file\": \"FooFile\","))
-			.append(LOG4CXX_EOL)
-			.append(ppIndentL2)
-			.append(LOG4CXX_STR("\"line\": \"42\","))
-			.append(LOG4CXX_EOL)
-			.append(ppIndentL2)
-			.append(LOG4CXX_STR("\"class\": \"\","))
-			.append(LOG4CXX_EOL)
-			.append(ppIndentL2)
-			.append(LOG4CXX_STR("\"method\": \"BarFunc\""))
-			.append(LOG4CXX_EOL)
-			.append(ppIndentL1)
-			.append(LOG4CXX_STR("}"));
+		.append(ppIndentL1)
+		.append(LOG4CXX_STR("\"location_info\": {"))
+		.append(LOG4CXX_EOL)
+		.append(ppIndentL2)
+		.append(LOG4CXX_STR("\"file\": \"FooFile\","))
+		.append(LOG4CXX_EOL)
+		.append(ppIndentL2)
+		.append(LOG4CXX_STR("\"line\": \"42\","))
+		.append(LOG4CXX_EOL)
+		.append(ppIndentL2)
+		.append(LOG4CXX_STR("\"class\": \"\","))
+		.append(LOG4CXX_EOL)
+		.append(ppIndentL2)
+		.append(LOG4CXX_STR("\"method\": \"BarFunc\""))
+		.append(LOG4CXX_EOL)
+		.append(ppIndentL1)
+		.append(LOG4CXX_STR("}"));
 
 		setPrettyPrint(true);
 		appendSerializedLocationInfo(output1, event1, p);
@@ -368,12 +368,12 @@
 		LogString expected1;
 
 		expected1
-			.append(LOG4CXX_STR("{ \"timestamp\": \""))
-			.append(timestamp)
-			.append(LOG4CXX_STR("\", "))
-			.append(LOG4CXX_STR("\"level\": \"INFO\", "))
-			.append(LOG4CXX_STR("\"logger\": \"Logger\", "))
-			.append(LOG4CXX_STR("\"message\": \"A message goes here.\""));
+		.append(LOG4CXX_STR("{ \"timestamp\": \""))
+		.append(timestamp)
+		.append(LOG4CXX_STR("\", "))
+		.append(LOG4CXX_STR("\"level\": \"INFO\", "))
+		.append(LOG4CXX_STR("\"logger\": \"Logger\", "))
+		.append(LOG4CXX_STR("\"message\": \"A message goes here.\""));
 
 		setLocationInfo(true);
 
@@ -416,21 +416,21 @@
 		LogString expected1;
 
 		expected1
-			.append(LOG4CXX_STR("{"))
-			.append(LOG4CXX_EOL)
-			.append(ppIndentL1)
-			.append(LOG4CXX_STR("\"timestamp\": \""))
-			.append(timestamp)
-			.append(LOG4CXX_STR("\","))
-			.append(LOG4CXX_EOL)
-			.append(ppIndentL1)
-			.append(LOG4CXX_STR("\"level\": \"INFO\","))
-			.append(LOG4CXX_EOL)
-			.append(ppIndentL1)
-			.append(LOG4CXX_STR("\"logger\": \"Logger\","))
-			.append(LOG4CXX_EOL)
-			.append(ppIndentL1)
-			.append(LOG4CXX_STR("\"message\": \"A message goes here.\""));
+		.append(LOG4CXX_STR("{"))
+		.append(LOG4CXX_EOL)
+		.append(ppIndentL1)
+		.append(LOG4CXX_STR("\"timestamp\": \""))
+		.append(timestamp)
+		.append(LOG4CXX_STR("\","))
+		.append(LOG4CXX_EOL)
+		.append(ppIndentL1)
+		.append(LOG4CXX_STR("\"level\": \"INFO\","))
+		.append(LOG4CXX_EOL)
+		.append(ppIndentL1)
+		.append(LOG4CXX_STR("\"logger\": \"Logger\","))
+		.append(LOG4CXX_EOL)
+		.append(ppIndentL1)
+		.append(LOG4CXX_STR("\"message\": \"A message goes here.\""));
 
 		setPrettyPrint(true);
 		setLocationInfo(true);
diff --git a/src/test/cpp/l7dtestcase.cpp b/src/test/cpp/l7dtestcase.cpp
index 7c13ab5..4f595c2 100644
--- a/src/test/cpp/l7dtestcase.cpp
+++ b/src/test/cpp/l7dtestcase.cpp
@@ -37,71 +37,71 @@
 
 LOGUNIT_CLASS(L7dTestCase)
 {
-        LOGUNIT_TEST_SUITE(L7dTestCase);
-                LOGUNIT_TEST(test1);
-        LOGUNIT_TEST_SUITE_END();
+	LOGUNIT_TEST_SUITE(L7dTestCase);
+	LOGUNIT_TEST(test1);
+	LOGUNIT_TEST_SUITE_END();
 
-        LoggerPtr root;
-        ResourceBundlePtr bundles[3];
+	LoggerPtr root;
+	ResourceBundlePtr bundles[3];
 
 public:
-        void setUp()
-        {
-                Locale localeUS(LOG4CXX_STR("en"), LOG4CXX_STR("US"));
-                bundles[0] =
-                        ResourceBundle::getBundle(LOG4CXX_STR("L7D"), localeUS);
-                LOGUNIT_ASSERT(bundles[0] != 0);
- 
-                Locale localeFR(LOG4CXX_STR("fr"), LOG4CXX_STR("FR"));
-                bundles[1] =
-                        ResourceBundle::getBundle(LOG4CXX_STR("L7D"), localeFR);
-                LOGUNIT_ASSERT(bundles[1] != 0);
+	void setUp()
+	{
+		Locale localeUS(LOG4CXX_STR("en"), LOG4CXX_STR("US"));
+		bundles[0] =
+			ResourceBundle::getBundle(LOG4CXX_STR("L7D"), localeUS);
+		LOGUNIT_ASSERT(bundles[0] != 0);
 
-                Locale localeCH(LOG4CXX_STR("fr"), LOG4CXX_STR("CH"));
-                bundles[2] =
-                        ResourceBundle::getBundle(LOG4CXX_STR("L7D"), localeCH);
-                LOGUNIT_ASSERT(bundles[2] != 0);
+		Locale localeFR(LOG4CXX_STR("fr"), LOG4CXX_STR("FR"));
+		bundles[1] =
+			ResourceBundle::getBundle(LOG4CXX_STR("L7D"), localeFR);
+		LOGUNIT_ASSERT(bundles[1] != 0);
 
-                root = Logger::getRootLogger();
-        }
+		Locale localeCH(LOG4CXX_STR("fr"), LOG4CXX_STR("CH"));
+		bundles[2] =
+			ResourceBundle::getBundle(LOG4CXX_STR("L7D"), localeCH);
+		LOGUNIT_ASSERT(bundles[2] != 0);
 
-        void tearDown()
-        {
-                root->getLoggerRepository()->resetConfiguration();
-        }
+		root = Logger::getRootLogger();
+	}
 
-        void test1()
-        {
-                PropertyConfigurator::configure(LOG4CXX_FILE("input/l7d1.properties"));
+	void tearDown()
+	{
+		root->getLoggerRepository()->resetConfiguration();
+	}
 
-                log4cxx::helpers::Pool pool;
+	void test1()
+	{
+		PropertyConfigurator::configure(LOG4CXX_FILE("input/l7d1.properties"));
 
-                for (int i = 0; i < 3; i++)
-                {
-                        root->setResourceBundle(bundles[i]);
+		log4cxx::helpers::Pool pool;
 
-                        LOG4CXX_L7DLOG(root, Level::getDebug(), LOG4CXX_TEST_STR("bogus1"));
-                        LOG4CXX_L7DLOG(root, Level::getInfo(), LOG4CXX_TEST_STR("test"));
-                        LOG4CXX_L7DLOG(root, Level::getWarn(), LOG4CXX_TEST_STR("hello_world"));
+		for (int i = 0; i < 3; i++)
+		{
+			root->setResourceBundle(bundles[i]);
+
+			LOG4CXX_L7DLOG(root, Level::getDebug(), LOG4CXX_TEST_STR("bogus1"));
+			LOG4CXX_L7DLOG(root, Level::getInfo(), LOG4CXX_TEST_STR("test"));
+			LOG4CXX_L7DLOG(root, Level::getWarn(), LOG4CXX_TEST_STR("hello_world"));
 
 
-                        StringBuffer os;
-                        os << (i + 1);
-                        LOG4CXX_L7DLOG2(root, Level::getDebug(), LOG4CXX_TEST_STR("msg1"), os.str().c_str(),
-                                 LOG4CXX_TEST_STR("log4j"));
-                        LOG4CXX_L7DLOG2(root, Level::getError(), LOG4CXX_TEST_STR("bogusMsg"), os.str().c_str(),
-                                 LOG4CXX_TEST_STR("log4j"));
-                        LOG4CXX_L7DLOG2(root, Level::getError(), LOG4CXX_TEST_STR("msg1"), os.str().c_str(),
-                                 LOG4CXX_TEST_STR("log4j"));
-                        LOG4CXX_L7DLOG(root, Level::getInfo(), LOG4CXX_TEST_STR("bogus2"));
+			StringBuffer os;
+			os << (i + 1);
+			LOG4CXX_L7DLOG2(root, Level::getDebug(), LOG4CXX_TEST_STR("msg1"), os.str().c_str(),
+				LOG4CXX_TEST_STR("log4j"));
+			LOG4CXX_L7DLOG2(root, Level::getError(), LOG4CXX_TEST_STR("bogusMsg"), os.str().c_str(),
+				LOG4CXX_TEST_STR("log4j"));
+			LOG4CXX_L7DLOG2(root, Level::getError(), LOG4CXX_TEST_STR("msg1"), os.str().c_str(),
+				LOG4CXX_TEST_STR("log4j"));
+			LOG4CXX_L7DLOG(root, Level::getInfo(), LOG4CXX_TEST_STR("bogus2"));
 
-                        LOG4CXX_L7DLOG3(root, Level::getError(), LOG4CXX_TEST_STR("msg3"), os.str().c_str(),
-                                 LOG4CXX_TEST_STR("log4j"), LOG4CXX_TEST_STR("log4cxx"));
-                }
+			LOG4CXX_L7DLOG3(root, Level::getError(), LOG4CXX_TEST_STR("msg3"), os.str().c_str(),
+				LOG4CXX_TEST_STR("log4j"), LOG4CXX_TEST_STR("log4cxx"));
+		}
 
-                LOGUNIT_ASSERT(Compare::compare(LOG4CXX_FILE("output/temp"),
-                LOG4CXX_FILE("witness/l7d.1")));
-        }
+		LOGUNIT_ASSERT(Compare::compare(LOG4CXX_FILE("output/temp"),
+				LOG4CXX_FILE("witness/l7d.1")));
+	}
 
 };
 
diff --git a/src/test/cpp/leveltestcase.cpp b/src/test/cpp/leveltestcase.cpp
index 7de78aa..e9f90ea 100644
--- a/src/test/cpp/leveltestcase.cpp
+++ b/src/test/cpp/leveltestcase.cpp
@@ -21,108 +21,116 @@
 #include "logunit.h"
 
 #if LOG4CXX_CFSTRING_API
-#include <CoreFoundation/CFString.h>
+	#include <CoreFoundation/CFString.h>
 #endif
 
 using namespace log4cxx;
 
 LOGUNIT_CLASS(LevelTestCase)
 {
-        LOGUNIT_TEST_SUITE(LevelTestCase);
-                LOGUNIT_TEST(testToLevelFatal);
-                LOGUNIT_TEST(testTraceInt);
-                LOGUNIT_TEST(testTrace);
-                LOGUNIT_TEST(testIntToTrace);
-                LOGUNIT_TEST(testStringToTrace);
+	LOGUNIT_TEST_SUITE(LevelTestCase);
+	LOGUNIT_TEST(testToLevelFatal);
+	LOGUNIT_TEST(testTraceInt);
+	LOGUNIT_TEST(testTrace);
+	LOGUNIT_TEST(testIntToTrace);
+	LOGUNIT_TEST(testStringToTrace);
 #if LOG4CXX_WCHAR_T_API
-                LOGUNIT_TEST(testWideStringToTrace);
+	LOGUNIT_TEST(testWideStringToTrace);
 #endif
 #if LOG4CXX_UNICHAR_API
-                LOGUNIT_TEST(testUniCharStringToTrace);
+	LOGUNIT_TEST(testUniCharStringToTrace);
 #endif
 #if LOG4CXX_CFSTRING_API
-                LOGUNIT_TEST(testCFStringToTrace);
+	LOGUNIT_TEST(testCFStringToTrace);
 #endif
-                LOGUNIT_TEST(testTrimmedToTrace);
-        LOGUNIT_TEST_SUITE_END();
+	LOGUNIT_TEST(testTrimmedToTrace);
+	LOGUNIT_TEST_SUITE_END();
 
 public:
-        void testToLevelFatal()
-        {
-                LevelPtr level(Level::toLevel(LOG4CXX_TEST_STR("fATal")));
-                LOGUNIT_ASSERT_EQUAL((int) Level::FATAL_INT, level->toInt());
-        }
+	void testToLevelFatal()
+	{
+		LevelPtr level(Level::toLevel(LOG4CXX_TEST_STR("fATal")));
+		LOGUNIT_ASSERT_EQUAL((int) Level::FATAL_INT, level->toInt());
+	}
 
-    /**
-     * Tests Level::TRACE_INT.
-     */
-  void testTraceInt() {
-      LOGUNIT_ASSERT_EQUAL(5000, (int) Level::TRACE_INT);
-  }
+	/**
+	 * Tests Level::TRACE_INT.
+	 */
+	void testTraceInt()
+	{
+		LOGUNIT_ASSERT_EQUAL(5000, (int) Level::TRACE_INT);
+	}
 
-    /**
-     * Tests Level.TRACE.
-     */
-  void testTrace() {
-      LOGUNIT_ASSERT(Level::getTrace()->toString() == LOG4CXX_STR("TRACE"));
-      LOGUNIT_ASSERT_EQUAL(5000, Level::getTrace()->toInt());
-      LOGUNIT_ASSERT_EQUAL(7, Level::getTrace()->getSyslogEquivalent());
-  }
+	/**
+	 * Tests Level.TRACE.
+	 */
+	void testTrace()
+	{
+		LOGUNIT_ASSERT(Level::getTrace()->toString() == LOG4CXX_STR("TRACE"));
+		LOGUNIT_ASSERT_EQUAL(5000, Level::getTrace()->toInt());
+		LOGUNIT_ASSERT_EQUAL(7, Level::getTrace()->getSyslogEquivalent());
+	}
 
-    /**
-     * Tests Level.toLevel(Level.TRACE_INT).
-     */
-  void testIntToTrace() {
-      LevelPtr trace(Level::toLevel(5000));
-      LOGUNIT_ASSERT(trace->toString() == LOG4CXX_STR("TRACE"));
-  }
+	/**
+	 * Tests Level.toLevel(Level.TRACE_INT).
+	 */
+	void testIntToTrace()
+	{
+		LevelPtr trace(Level::toLevel(5000));
+		LOGUNIT_ASSERT(trace->toString() == LOG4CXX_STR("TRACE"));
+	}
 
-    /**
-     * Tests Level.toLevel("TRACE");
-     */
-  void testStringToTrace() {
-        LevelPtr trace(Level::toLevel("TRACE"));
-      LOGUNIT_ASSERT(trace->toString() == LOG4CXX_STR("TRACE"));
-  }
+	/**
+	 * Tests Level.toLevel("TRACE");
+	 */
+	void testStringToTrace()
+	{
+		LevelPtr trace(Level::toLevel("TRACE"));
+		LOGUNIT_ASSERT(trace->toString() == LOG4CXX_STR("TRACE"));
+	}
 
 #if LOG4CXX_WCHAR_T_API
-    /**
-     * Tests Level.toLevel(L"TRACE");
-     */
-  void testWideStringToTrace() {
-        LevelPtr trace(Level::toLevel(L"TRACE"));
-        LOGUNIT_ASSERT(trace->toString() == LOG4CXX_STR("TRACE"));
-  }
+	/**
+	 * Tests Level.toLevel(L"TRACE");
+	 */
+	void testWideStringToTrace()
+	{
+		LevelPtr trace(Level::toLevel(L"TRACE"));
+		LOGUNIT_ASSERT(trace->toString() == LOG4CXX_STR("TRACE"));
+	}
 #endif
 
 #if LOG4CXX_UNICHAR_API
-    /**
-     * Tests Level.toLevel("TRACE");
-     */
-  void testUniCharStringToTrace() {
-        const log4cxx::UniChar name[] = { 'T', 'R', 'A', 'C', 'E', 0 };
-        LevelPtr trace(Level::toLevel(name));
-        LOGUNIT_ASSERT(trace->toString() == LOG4CXX_STR("TRACE"));
-  }
+	/**
+	 * Tests Level.toLevel("TRACE");
+	 */
+	void testUniCharStringToTrace()
+	{
+		const log4cxx::UniChar name[] = { 'T', 'R', 'A', 'C', 'E', 0 };
+		LevelPtr trace(Level::toLevel(name));
+		LOGUNIT_ASSERT(trace->toString() == LOG4CXX_STR("TRACE"));
+	}
 #endif
 
 #if LOG4CXX_CFSTRING_API
-    /**
-     * Tests Level.toLevel(CFSTR("TRACE"));
-     */
-  void testCFStringToTrace() {
-        LevelPtr trace(Level::toLevel(CFSTR("TRACE")));
-        LOGUNIT_ASSERT(trace->toString() == LOG4CXX_STR("TRACE"));
-  }
+	/**
+	 * Tests Level.toLevel(CFSTR("TRACE"));
+	 */
+	void testCFStringToTrace()
+	{
+		LevelPtr trace(Level::toLevel(CFSTR("TRACE")));
+		LOGUNIT_ASSERT(trace->toString() == LOG4CXX_STR("TRACE"));
+	}
 #endif
 
-    /**
-     * Tests Level.toLevel("TRACE ");
-     */
-  void testTrimmedToTrace() {
-        LevelPtr trace(Level::toLevel("TRACE "));
-      LOGUNIT_ASSERT(trace->toString() == LOG4CXX_STR("TRACE"));
-  }
+	/**
+	 * Tests Level.toLevel("TRACE ");
+	 */
+	void testTrimmedToTrace()
+	{
+		LevelPtr trace(Level::toLevel("TRACE "));
+		LOGUNIT_ASSERT(trace->toString() == LOG4CXX_STR("TRACE"));
+	}
 
 };
 
diff --git a/src/test/cpp/loggertestcase.cpp b/src/test/cpp/loggertestcase.cpp
index 399d697..e36886d 100644
--- a/src/test/cpp/loggertestcase.cpp
+++ b/src/test/cpp/loggertestcase.cpp
@@ -40,424 +40,431 @@
 
 class CountingAppender : public AppenderSkeleton
 {
-public:
-        int counter;
+	public:
+		int counter;
 
-        CountingAppender() : counter(0)
-                {}
+		CountingAppender() : counter(0)
+		{}
 
-        void close()
-                {}
+		void close()
+		{}
 
-        void append(const spi::LoggingEventPtr& /*event*/, Pool& /*p*/)
-                { counter++; }
+		void append(const spi::LoggingEventPtr& /*event*/, Pool& /*p*/)
+		{
+			counter++;
+		}
 
-        bool requiresLayout() const
-                { return true; }
+		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();
+	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 setUp()
+	{
+	}
 
-        void tearDown()
-        {
-                BasicConfigurator::resetConfiguration();
-                a1 = 0;
-                a2 = 0;
-        logger = 0;
-        }
+	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);
+	/**
+	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);
-        }
+		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"));
+	/**
+	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"));
+		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);
-        }
+		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);
+	/**
+	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);
-        }
+		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"));
+	/**
+	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();
+		CountingAppenderPtr ca1 = new CountingAppender();
+		CountingAppenderPtr ca2 = new CountingAppender();
 
-                a->addAppender(ca1);
-                abc->addAppender(ca2);
+		a->addAppender(ca1);
+		abc->addAppender(ca2);
 
-                LOGUNIT_ASSERT_EQUAL(ca1->counter, 0);
-                LOGUNIT_ASSERT_EQUAL(ca2->counter, 0);
+		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);
+		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);
+		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);
-        }
+		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"));
+	/**
+	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();
+		CountingAppenderPtr caRoot = new CountingAppender();
+		CountingAppenderPtr caA = new CountingAppender();
+		CountingAppenderPtr caABC = new CountingAppender();
 
-                root->addAppender(caRoot);
-                a->addAppender(caA);
-                abc->addAppender(caABC);
+		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);
+		LOGUNIT_ASSERT_EQUAL(caRoot->counter, 0);
+		LOGUNIT_ASSERT_EQUAL(caA->counter, 0);
+		LOGUNIT_ASSERT_EQUAL(caABC->counter, 0);
 
-                ab->setAdditivity(false);
+		ab->setAdditivity(false);
 
-                a->debug(MSG);
-                LOGUNIT_ASSERT_EQUAL(caRoot->counter, 1);
-                LOGUNIT_ASSERT_EQUAL(caA->counter, 1);
-                LOGUNIT_ASSERT_EQUAL(caABC->counter, 0);
+		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);
+		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);
-        }
+		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);
+	void testDisable1()
+	{
+		CountingAppenderPtr caRoot = new CountingAppender();
+		LoggerPtr root = Logger::getRootLogger();
+		root->addAppender(caRoot);
 
-                LoggerRepositoryPtr h = LogManager::getLoggerRepository();
+		LoggerRepositoryPtr h = LogManager::getLoggerRepository();
 
-                //h.disableDebug();
-                h->setThreshold(Level::getInfo());
-                LOGUNIT_ASSERT_EQUAL(caRoot->counter, 0);
+		//h.disableDebug();
+		h->setThreshold(Level::getInfo());
+		LOGUNIT_ASSERT_EQUAL(caRoot->counter, 0);
 
-                root->debug(MSG);
-                LOGUNIT_ASSERT_EQUAL(caRoot->counter, 0);
-                root->info(MSG);
-                LOGUNIT_ASSERT_EQUAL(caRoot->counter, 1);
-                root->log(Level::getWarn(), MSG);
-                LOGUNIT_ASSERT_EQUAL(caRoot->counter, 2);
-                root->warn(MSG);
-                LOGUNIT_ASSERT_EQUAL(caRoot->counter, 3);
+		root->debug(MSG);
+		LOGUNIT_ASSERT_EQUAL(caRoot->counter, 0);
+		root->info(MSG);
+		LOGUNIT_ASSERT_EQUAL(caRoot->counter, 1);
+		root->log(Level::getWarn(), MSG);
+		LOGUNIT_ASSERT_EQUAL(caRoot->counter, 2);
+		root->warn(MSG);
+		LOGUNIT_ASSERT_EQUAL(caRoot->counter, 3);
 
-                //h.disableInfo();
-                h->setThreshold(Level::getWarn());
-                root->debug(MSG);
-                LOGUNIT_ASSERT_EQUAL(caRoot->counter, 3);
-                root->info(MSG);
-                LOGUNIT_ASSERT_EQUAL(caRoot->counter, 3);
-                root->log(Level::getWarn(), MSG);
-                LOGUNIT_ASSERT_EQUAL(caRoot->counter, 4);
-                root->error(MSG);
-                LOGUNIT_ASSERT_EQUAL(caRoot->counter, 5);
-                root->log(Level::getError(), MSG);
-                LOGUNIT_ASSERT_EQUAL(caRoot->counter, 6);
+		//h.disableInfo();
+		h->setThreshold(Level::getWarn());
+		root->debug(MSG);
+		LOGUNIT_ASSERT_EQUAL(caRoot->counter, 3);
+		root->info(MSG);
+		LOGUNIT_ASSERT_EQUAL(caRoot->counter, 3);
+		root->log(Level::getWarn(), MSG);
+		LOGUNIT_ASSERT_EQUAL(caRoot->counter, 4);
+		root->error(MSG);
+		LOGUNIT_ASSERT_EQUAL(caRoot->counter, 5);
+		root->log(Level::getError(), MSG);
+		LOGUNIT_ASSERT_EQUAL(caRoot->counter, 6);
 
-                //h.disableAll();
-                h->setThreshold(Level::getOff());
-                root->debug(MSG);
-                LOGUNIT_ASSERT_EQUAL(caRoot->counter, 6);
-                root->info(MSG);
-                LOGUNIT_ASSERT_EQUAL(caRoot->counter, 6);
-                root->log(Level::getWarn(), MSG);
-                LOGUNIT_ASSERT_EQUAL(caRoot->counter, 6);
-                root->error(MSG);
-                LOGUNIT_ASSERT_EQUAL(caRoot->counter, 6);
-                root->log(Level::getFatal(), MSG);
-                LOGUNIT_ASSERT_EQUAL(caRoot->counter, 6);
-                root->log(Level::getFatal(), MSG);
-                LOGUNIT_ASSERT_EQUAL(caRoot->counter, 6);
+		//h.disableAll();
+		h->setThreshold(Level::getOff());
+		root->debug(MSG);
+		LOGUNIT_ASSERT_EQUAL(caRoot->counter, 6);
+		root->info(MSG);
+		LOGUNIT_ASSERT_EQUAL(caRoot->counter, 6);
+		root->log(Level::getWarn(), MSG);
+		LOGUNIT_ASSERT_EQUAL(caRoot->counter, 6);
+		root->error(MSG);
+		LOGUNIT_ASSERT_EQUAL(caRoot->counter, 6);
+		root->log(Level::getFatal(), MSG);
+		LOGUNIT_ASSERT_EQUAL(caRoot->counter, 6);
+		root->log(Level::getFatal(), MSG);
+		LOGUNIT_ASSERT_EQUAL(caRoot->counter, 6);
 
-                //h.disable(Level::getFatalLevel());
-                h->setThreshold(Level::getOff());
-                root->debug(MSG);
-                LOGUNIT_ASSERT_EQUAL(caRoot->counter, 6);
-                root->info(MSG);
-                LOGUNIT_ASSERT_EQUAL(caRoot->counter, 6);
-                root->log(Level::getWarn(), MSG);
-                LOGUNIT_ASSERT_EQUAL(caRoot->counter, 6);
-                root->error(MSG);
-                LOGUNIT_ASSERT_EQUAL(caRoot->counter, 6);
-                root->log(Level::getWarn(), MSG);
-                LOGUNIT_ASSERT_EQUAL(caRoot->counter, 6);
-                root->log(Level::getFatal(), MSG);
-                LOGUNIT_ASSERT_EQUAL(caRoot->counter, 6);
-        }
+		//h.disable(Level::getFatalLevel());
+		h->setThreshold(Level::getOff());
+		root->debug(MSG);
+		LOGUNIT_ASSERT_EQUAL(caRoot->counter, 6);
+		root->info(MSG);
+		LOGUNIT_ASSERT_EQUAL(caRoot->counter, 6);
+		root->log(Level::getWarn(), MSG);
+		LOGUNIT_ASSERT_EQUAL(caRoot->counter, 6);
+		root->error(MSG);
+		LOGUNIT_ASSERT_EQUAL(caRoot->counter, 6);
+		root->log(Level::getWarn(), MSG);
+		LOGUNIT_ASSERT_EQUAL(caRoot->counter, 6);
+		root->log(Level::getFatal(), MSG);
+		LOGUNIT_ASSERT_EQUAL(caRoot->counter, 6);
+	}
 
 
-        ResourceBundlePtr getBundle(const LogString& lang, const LogString& region)
-        {
-             Locale l(lang, region);
-             ResourceBundlePtr bundle(
-                 PropertyResourceBundle::getBundle(LOG4CXX_STR("L7D"),l));
-             LOGUNIT_ASSERT(bundle != 0);
-             return bundle;
-        }
+	ResourceBundlePtr getBundle(const LogString & lang, const LogString & region)
+	{
+		Locale l(lang, region);
+		ResourceBundlePtr bundle(
+			PropertyResourceBundle::getBundle(LOG4CXX_STR("L7D"), l));
+		LOGUNIT_ASSERT(bundle != 0);
+		return bundle;
+	}
 
-        void testRB1()
-        {
-                ResourceBundlePtr rbUS(getBundle(LOG4CXX_STR("en"), LOG4CXX_STR("US")));
-                ResourceBundlePtr rbFR(getBundle(LOG4CXX_STR("fr"), LOG4CXX_STR("FR")));
-                ResourceBundlePtr rbCH(getBundle(LOG4CXX_STR("fr"), LOG4CXX_STR("CH")));
+	void testRB1()
+	{
+		ResourceBundlePtr rbUS(getBundle(LOG4CXX_STR("en"), LOG4CXX_STR("US")));
+		ResourceBundlePtr rbFR(getBundle(LOG4CXX_STR("fr"), LOG4CXX_STR("FR")));
+		ResourceBundlePtr rbCH(getBundle(LOG4CXX_STR("fr"), LOG4CXX_STR("CH")));
 
-                LoggerPtr root = Logger::getRootLogger();
-                root->setResourceBundle(rbUS);
+		LoggerPtr root = Logger::getRootLogger();
+		root->setResourceBundle(rbUS);
 
-                ResourceBundlePtr t = root->getResourceBundle();
-                LOGUNIT_ASSERT(t == rbUS);
+		ResourceBundlePtr t = root->getResourceBundle();
+		LOGUNIT_ASSERT(t == rbUS);
 
-                LoggerPtr x = Logger::getLogger(LOG4CXX_TEST_STR("x"));
-                LoggerPtr x_y = Logger::getLogger(LOG4CXX_TEST_STR("x.y"));
-                LoggerPtr x_y_z = Logger::getLogger(LOG4CXX_TEST_STR("x.y.z"));
+		LoggerPtr x = Logger::getLogger(LOG4CXX_TEST_STR("x"));
+		LoggerPtr x_y = Logger::getLogger(LOG4CXX_TEST_STR("x.y"));
+		LoggerPtr x_y_z = Logger::getLogger(LOG4CXX_TEST_STR("x.y.z"));
 
-                t = x->getResourceBundle();
-                LOGUNIT_ASSERT(t == rbUS);
-                t = x_y->getResourceBundle();
-                LOGUNIT_ASSERT(t == rbUS);
-                t = x_y_z->getResourceBundle();
-                LOGUNIT_ASSERT(t == rbUS);
-        }
+		t = x->getResourceBundle();
+		LOGUNIT_ASSERT(t == rbUS);
+		t = x_y->getResourceBundle();
+		LOGUNIT_ASSERT(t == rbUS);
+		t = x_y_z->getResourceBundle();
+		LOGUNIT_ASSERT(t == rbUS);
+	}
 
-        void testRB2()
-        {
-                LoggerPtr root = Logger::getRootLogger();
-                ResourceBundlePtr rbUS(getBundle(LOG4CXX_STR("en"), LOG4CXX_STR("US")));
-                ResourceBundlePtr rbFR(getBundle(LOG4CXX_STR("fr"), LOG4CXX_STR("FR")));
-                ResourceBundlePtr rbCH(getBundle(LOG4CXX_STR("fr"), LOG4CXX_STR("CH")));
+	void testRB2()
+	{
+		LoggerPtr root = Logger::getRootLogger();
+		ResourceBundlePtr rbUS(getBundle(LOG4CXX_STR("en"), LOG4CXX_STR("US")));
+		ResourceBundlePtr rbFR(getBundle(LOG4CXX_STR("fr"), LOG4CXX_STR("FR")));
+		ResourceBundlePtr rbCH(getBundle(LOG4CXX_STR("fr"), LOG4CXX_STR("CH")));
 
-                root->setResourceBundle(rbUS);
+		root->setResourceBundle(rbUS);
 
-                ResourceBundlePtr t = root->getResourceBundle();
-                LOGUNIT_ASSERT(t == rbUS);
+		ResourceBundlePtr t = root->getResourceBundle();
+		LOGUNIT_ASSERT(t == rbUS);
 
-                LoggerPtr x = Logger::getLogger(LOG4CXX_TEST_STR("x"));
-                LoggerPtr x_y = Logger::getLogger(LOG4CXX_TEST_STR("x.y"));
-                LoggerPtr x_y_z = Logger::getLogger(LOG4CXX_TEST_STR("x.y.z"));
+		LoggerPtr x = Logger::getLogger(LOG4CXX_TEST_STR("x"));
+		LoggerPtr x_y = Logger::getLogger(LOG4CXX_TEST_STR("x.y"));
+		LoggerPtr x_y_z = Logger::getLogger(LOG4CXX_TEST_STR("x.y.z"));
 
-                x_y->setResourceBundle(rbFR);
-                t = x->getResourceBundle();
-                LOGUNIT_ASSERT(t == rbUS);
-                t = x_y->getResourceBundle();
-                LOGUNIT_ASSERT(t == rbFR);
-                t = x_y_z->getResourceBundle();
-                LOGUNIT_ASSERT(t == rbFR);
-        }
+		x_y->setResourceBundle(rbFR);
+		t = x->getResourceBundle();
+		LOGUNIT_ASSERT(t == rbUS);
+		t = x_y->getResourceBundle();
+		LOGUNIT_ASSERT(t == rbFR);
+		t = x_y_z->getResourceBundle();
+		LOGUNIT_ASSERT(t == rbFR);
+	}
 
-        void testRB3()
-        {
-                ResourceBundlePtr rbUS(getBundle(LOG4CXX_STR("en"), LOG4CXX_STR("US")));
-                ResourceBundlePtr rbFR(getBundle(LOG4CXX_STR("fr"), LOG4CXX_STR("FR")));
-                ResourceBundlePtr rbCH(getBundle(LOG4CXX_STR("fr"), LOG4CXX_STR("CH")));
+	void testRB3()
+	{
+		ResourceBundlePtr rbUS(getBundle(LOG4CXX_STR("en"), LOG4CXX_STR("US")));
+		ResourceBundlePtr rbFR(getBundle(LOG4CXX_STR("fr"), LOG4CXX_STR("FR")));
+		ResourceBundlePtr rbCH(getBundle(LOG4CXX_STR("fr"), LOG4CXX_STR("CH")));
 
-                LoggerPtr root = Logger::getRootLogger();
-                root->setResourceBundle(rbUS);
+		LoggerPtr root = Logger::getRootLogger();
+		root->setResourceBundle(rbUS);
 
-                ResourceBundlePtr t = root->getResourceBundle();
-                LOGUNIT_ASSERT(t == rbUS);
+		ResourceBundlePtr t = root->getResourceBundle();
+		LOGUNIT_ASSERT(t == rbUS);
 
-                LoggerPtr x = Logger::getLogger(LOG4CXX_TEST_STR("x"));
-                LoggerPtr x_y = Logger::getLogger(LOG4CXX_TEST_STR("x.y"));
-                LoggerPtr x_y_z = Logger::getLogger(LOG4CXX_TEST_STR("x.y.z"));
+		LoggerPtr x = Logger::getLogger(LOG4CXX_TEST_STR("x"));
+		LoggerPtr x_y = Logger::getLogger(LOG4CXX_TEST_STR("x.y"));
+		LoggerPtr x_y_z = Logger::getLogger(LOG4CXX_TEST_STR("x.y.z"));
 
-                x_y->setResourceBundle(rbFR);
-                x_y_z->setResourceBundle(rbCH);
-                t = x->getResourceBundle();
-                LOGUNIT_ASSERT(t == rbUS);
-                t = x_y->getResourceBundle();
-                LOGUNIT_ASSERT(t == rbFR);
-                t = x_y_z->getResourceBundle();
-                LOGUNIT_ASSERT(t == rbCH);
-        }
+		x_y->setResourceBundle(rbFR);
+		x_y_z->setResourceBundle(rbCH);
+		t = x->getResourceBundle();
+		LOGUNIT_ASSERT(t == rbUS);
+		t = x_y->getResourceBundle();
+		LOGUNIT_ASSERT(t == rbFR);
+		t = x_y_z->getResourceBundle();
+		LOGUNIT_ASSERT(t == rbCH);
+	}
 
-        void testExists()
-        {
-                LoggerPtr a = Logger::getLogger(LOG4CXX_TEST_STR("a"));
-                LoggerPtr a_b = Logger::getLogger(LOG4CXX_TEST_STR("a.b"));
-                LoggerPtr a_b_c = Logger::getLogger(LOG4CXX_TEST_STR("a.b.c"));
+	void testExists()
+	{
+		LoggerPtr a = Logger::getLogger(LOG4CXX_TEST_STR("a"));
+		LoggerPtr a_b = Logger::getLogger(LOG4CXX_TEST_STR("a.b"));
+		LoggerPtr a_b_c = Logger::getLogger(LOG4CXX_TEST_STR("a.b.c"));
 
-                LoggerPtr t;
-                t = LogManager::exists(LOG4CXX_TEST_STR("xx"));
-                LOGUNIT_ASSERT(t == 0);
-                t = LogManager::exists(LOG4CXX_TEST_STR("a"));
-                LOGUNIT_ASSERT_EQUAL(a, t);
-                t = LogManager::exists(LOG4CXX_TEST_STR("a.b"));
-                LOGUNIT_ASSERT_EQUAL(a_b, t);
-                t = LogManager::exists(LOG4CXX_TEST_STR("a.b.c"));
-                LOGUNIT_ASSERT_EQUAL(a_b_c, t);
-        }
+		LoggerPtr t;
+		t = LogManager::exists(LOG4CXX_TEST_STR("xx"));
+		LOGUNIT_ASSERT(t == 0);
+		t = LogManager::exists(LOG4CXX_TEST_STR("a"));
+		LOGUNIT_ASSERT_EQUAL(a, t);
+		t = LogManager::exists(LOG4CXX_TEST_STR("a.b"));
+		LOGUNIT_ASSERT_EQUAL(a_b, t);
+		t = LogManager::exists(LOG4CXX_TEST_STR("a.b.c"));
+		LOGUNIT_ASSERT_EQUAL(a_b_c, t);
+	}
 
-        void testHierarchy1()
-        {
-                LoggerRepositoryPtr h = new Hierarchy();
-                LoggerPtr root(h->getRootLogger());
-                root->setLevel(Level::getError());
-                LoggerPtr a0 = h->getLogger(LOG4CXX_STR("a"));
-                LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("a"), a0->getName());
-                LOGUNIT_ASSERT(a0->getLevel() == 0);
-                LOGUNIT_ASSERT(Level::getError() == a0->getEffectiveLevel());
+	void testHierarchy1()
+	{
+		LoggerRepositoryPtr h = new Hierarchy();
+		LoggerPtr root(h->getRootLogger());
+		root->setLevel(Level::getError());
+		LoggerPtr a0 = h->getLogger(LOG4CXX_STR("a"));
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("a"), a0->getName());
+		LOGUNIT_ASSERT(a0->getLevel() == 0);
+		LOGUNIT_ASSERT(Level::getError() == a0->getEffectiveLevel());
 
-                LoggerPtr a11 = h->getLogger(LOG4CXX_STR("a"));
-                LOGUNIT_ASSERT_EQUAL(a0, a11);
-        }
-        
-        void compileTestForLOGCXX202() const {
-           //
-           //   prior to fix, these line would compile. 
-           //
-           (*logger).info("Hello, World.");
-           ((Logger*) logger)->info("Hello, World.");
-           //
-           //   this one would not.
-           //
-           logger->info("Hello, World.");
-        }
-        
-        
-  /**
-   * Tests logger.trace(Object).
-   * 
-   */
-  void testTrace() {
-      VectorAppenderPtr appender = new VectorAppender();
-      LoggerPtr root = Logger::getRootLogger();
-      root->addAppender(appender);
-      root->setLevel(Level::getInfo());
+		LoggerPtr a11 = h->getLogger(LOG4CXX_STR("a"));
+		LOGUNIT_ASSERT_EQUAL(a0, a11);
+	}
 
-      LoggerPtr tracer = Logger::getLogger("com.example.Tracer");
-      tracer->setLevel(Level::getTrace());
+	void compileTestForLOGCXX202() const
+	{
+		//
+		//   prior to fix, these line would compile.
+		//
+		(*logger).info("Hello, World.");
+		((Logger*) logger)->info("Hello, World.");
+		//
+		//   this one would not.
+		//
+		logger->info("Hello, World.");
+	}
 
-      LOG4CXX_TRACE(tracer, "Message 1");
-      LOG4CXX_TRACE(root, "Discarded Message");
-      LOG4CXX_TRACE(root, "Discarded Message");
 
-      std::vector<LoggingEventPtr> msgs(appender->vector);
-      LOGUNIT_ASSERT_EQUAL((size_t) 1, msgs.size());
-      LoggingEventPtr event = msgs[0];
-      LOGUNIT_ASSERT_EQUAL((int) Level::TRACE_INT, event->getLevel()->toInt());
-      LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("Message 1")), event->getMessage());
-  }
+	/**
+	 * Tests logger.trace(Object).
+	 *
+	 */
+	void testTrace()
+	{
+		VectorAppenderPtr appender = new VectorAppender();
+		LoggerPtr root = Logger::getRootLogger();
+		root->addAppender(appender);
+		root->setLevel(Level::getInfo());
 
-    /**
-     * Tests isTraceEnabled.
-     * 
-     */
-    void testIsTraceEnabled() {
-        VectorAppenderPtr appender = new VectorAppender();
-        LoggerPtr root = Logger::getRootLogger();
-        root->addAppender(appender);
-        root->setLevel(Level::getInfo());
+		LoggerPtr tracer = Logger::getLogger("com.example.Tracer");
+		tracer->setLevel(Level::getTrace());
 
-        LoggerPtr tracer = Logger::getLogger("com.example.Tracer");
-        tracer->setLevel(Level::getTrace());
+		LOG4CXX_TRACE(tracer, "Message 1");
+		LOG4CXX_TRACE(root, "Discarded Message");
+		LOG4CXX_TRACE(root, "Discarded Message");
 
-        LOGUNIT_ASSERT_EQUAL(true, tracer->isTraceEnabled());
-        LOGUNIT_ASSERT_EQUAL(false, root->isTraceEnabled());
-    }
+		std::vector<LoggingEventPtr> msgs(appender->vector);
+		LOGUNIT_ASSERT_EQUAL((size_t) 1, msgs.size());
+		LoggingEventPtr event = msgs[0];
+		LOGUNIT_ASSERT_EQUAL((int) Level::TRACE_INT, event->getLevel()->toInt());
+		LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("Message 1")), event->getMessage());
+	}
+
+	/**
+	 * Tests isTraceEnabled.
+	 *
+	 */
+	void testIsTraceEnabled()
+	{
+		VectorAppenderPtr appender = new VectorAppender();
+		LoggerPtr root = Logger::getRootLogger();
+		root->addAppender(appender);
+		root->setLevel(Level::getInfo());
+
+		LoggerPtr tracer = Logger::getLogger("com.example.Tracer");
+		tracer->setLevel(Level::getTrace());
+
+		LOGUNIT_ASSERT_EQUAL(true, tracer->isTraceEnabled());
+		LOGUNIT_ASSERT_EQUAL(false, root->isTraceEnabled());
+	}
 
 protected:
-        static LogString MSG;
-        LoggerPtr logger;
-        AppenderPtr a1;
-        AppenderPtr a2;
+	static LogString MSG;
+	LoggerPtr logger;
+	AppenderPtr a1;
+	AppenderPtr a2;
 };
 
 LogString LoggerTestCase::MSG(LOG4CXX_STR("M"));
diff --git a/src/test/cpp/logunit.cpp b/src/test/cpp/logunit.cpp
index 138bf7b..6d57a64 100644
--- a/src/test/cpp/logunit.cpp
+++ b/src/test/cpp/logunit.cpp
@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 #if defined(_MSC_VER)
-#pragma warning ( disable: 4231 4251 4275 4786 )
+	#pragma warning ( disable: 4231 4251 4275 4786 )
 #endif
 
 #include "logunit.h"
@@ -25,89 +25,111 @@
 #include <stdlib.h>
 #include <locale.h>
 
-void initialize() {
-    setlocale(LC_CTYPE, "");
-    const char* ctype = setlocale(LC_CTYPE, 0);
-    if (ctype == 0) {
-        puts("LC_CTYPE: NULL");
-    } else {
-        printf("LC_CTYPE: %s\n", ctype);
-    }
-    apr_initialize();
+void initialize()
+{
+	setlocale(LC_CTYPE, "");
+	const char* ctype = setlocale(LC_CTYPE, 0);
+
+	if (ctype == 0)
+	{
+		puts("LC_CTYPE: NULL");
+	}
+	else
+	{
+		printf("LC_CTYPE: %s\n", ctype);
+	}
+
+	apr_initialize();
 }
 
 extern const char** testlist;
 
-static bool suite_sort(const LogUnit::SuiteList::value_type& lhs, const LogUnit::SuiteList::value_type& rhs) {
-    return lhs.first < rhs.first;
+static bool suite_sort(const LogUnit::SuiteList::value_type& lhs, const LogUnit::SuiteList::value_type& rhs)
+{
+	return lhs.first < rhs.first;
 }
 
-abts_suite* abts_run_suites(abts_suite* suite) {
-    LogUnit::SuiteList sorted(LogUnit::getAllSuites());
+abts_suite* abts_run_suites(abts_suite* suite)
+{
+	LogUnit::SuiteList sorted(LogUnit::getAllSuites());
 
 #if !defined(_MSC_VER)
-    std::sort(sorted.begin(), sorted.end(), suite_sort);
+	std::sort(sorted.begin(), sorted.end(), suite_sort);
 #endif
-    
-    for(LogUnit::SuiteList::const_iterator iter = sorted.begin();
-        iter != sorted.end();
-        iter++) {
-        //
-        //   if there is an explicit testlist or if the suite is not by default disabled
-        //         pump suite through filter
-        if(testlist || !iter->second->isDisabled()) {
-            suite = iter->second->run(suite);
-        }
-    }
-    apr_terminate();
-    return suite;
+
+	for (LogUnit::SuiteList::const_iterator iter = sorted.begin();
+		iter != sorted.end();
+		iter++)
+	{
+		//
+		//   if there is an explicit testlist or if the suite is not by default disabled
+		//         pump suite through filter
+		if (testlist || !iter->second->isDisabled())
+		{
+			suite = iter->second->run(suite);
+		}
+	}
+
+	apr_terminate();
+	return suite;
 }
 
 using namespace LogUnit;
 using namespace std;
 
 TestException::TestException() {}
-TestException::TestException(const TestException& src) : std::exception(src) {
+TestException::TestException(const TestException& src) : std::exception(src)
+{
 }
 
-TestException& TestException::operator=(const TestException& src) {
-    exception::operator=(src);
-    return *this;
+TestException& TestException::operator=(const TestException& src)
+{
+	exception::operator=(src);
+	return *this;
 }
 
 
 AssertException::AssertException(std::string message, int line) : msg(message), lineno(line) {}
 
-AssertException::AssertException(bool expected, const char* actualExpr, int line) : msg(actualExpr), lineno(line) {
-   if (expected) {
-        msg.append(" was expected to be true, was false.");
-   } else {
-        msg.append(" was expected to be true, was false.");
-   }
+AssertException::AssertException(bool expected, const char* actualExpr, int line) : msg(actualExpr), lineno(line)
+{
+	if (expected)
+	{
+		msg.append(" was expected to be true, was false.");
+	}
+	else
+	{
+		msg.append(" was expected to be true, was false.");
+	}
 }
 
-AssertException::AssertException(const AssertException& src) 
-    : std::exception(src), 
-      msg(src.msg), 
-     lineno(src.lineno) {
+AssertException::AssertException(const AssertException& src)
+	: std::exception(src),
+	  msg(src.msg),
+	  lineno(src.lineno)
+{
 }
 
-AssertException::~AssertException() throw() {
+AssertException::~AssertException() throw()
+{
 }
 
-AssertException& AssertException::operator=(const AssertException& src) {
-    exception::operator=(src);
-    msg = src.msg;
-    lineno = src.lineno;
-    return *this;
+AssertException& AssertException::operator=(const AssertException& src)
+{
+	exception::operator=(src);
+	msg = src.msg;
+	lineno = src.lineno;
+	return *this;
 }
 
-std::string AssertException::getMessage() const {
-    return msg;
+std::string AssertException::getMessage() const
+{
+	return msg;
 }
 
-int AssertException::getLine() const {
-    return lineno;
+int AssertException::getLine() const
+{
+	return lineno;
 }
 
 
@@ -115,128 +137,160 @@
 
 TestFixture::TestFixture() : tc(0) {}
 TestFixture::~TestFixture() {}
-void TestFixture::setCase(abts_case* newtc) {
-      tc = newtc;
+void TestFixture::setCase(abts_case* newtc)
+{
+	tc = newtc;
 }
 void TestFixture::setUp() {}
 void TestFixture::tearDown() {}
 
-void TestFixture::assertEquals(const char* expected, 
-     const char* actual, 
-     const char* expectedExpr,
-     const char* actualExpr,
-     int lineno) {
-    abts_str_equal(tc, expected, actual, lineno);
-    if ((expected == 0 || actual != 0) ||
-        (expected != 0 || actual == 0) ||
-        (expected != 0 && strcmp(expected, actual) != 0)) {
-        throw TestException();
-    }
+void TestFixture::assertEquals(const char* expected,
+	const char* actual,
+	const char* expectedExpr,
+	const char* actualExpr,
+	int lineno)
+{
+	abts_str_equal(tc, expected, actual, lineno);
+
+	if ((expected == 0 || actual != 0) ||
+		(expected != 0 || actual == 0) ||
+		(expected != 0 && strcmp(expected, actual) != 0))
+	{
+		throw TestException();
+	}
 }
 
-void TestFixture::assertEquals(const std::string expected, 
-     const std::string actual, 
-     const char* expectedExpr,
-     const char* actualExpr,
-     int lineno) {
-    abts_str_equal(tc, expected.c_str(), actual.c_str(), lineno);
-    if (expected != actual) {
-        throw TestException();
-    }
+void TestFixture::assertEquals(const std::string expected,
+	const std::string actual,
+	const char* expectedExpr,
+	const char* actualExpr,
+	int lineno)
+{
+	abts_str_equal(tc, expected.c_str(), actual.c_str(), lineno);
+
+	if (expected != actual)
+	{
+		throw TestException();
+	}
 }
 
 template<class S>
-static void transcode(std::string& dst, const S& src) {
-        for(typename S::const_iterator iter = src.begin();
-            iter != src.end();
-            iter++) {
-            if (*iter <= 0x7F) {
-                dst.append(1, (char) *iter);
-             } else {
-                dst.append(1, '?');
-            }
-        }
+static void transcode(std::string& dst, const S& src)
+{
+	for (typename S::const_iterator iter = src.begin();
+		iter != src.end();
+		iter++)
+	{
+		if (*iter <= 0x7F)
+		{
+			dst.append(1, (char) *iter);
+		}
+		else
+		{
+			dst.append(1, '?');
+		}
+	}
 }
 
-#if LOG4CXX_LOGCHAR_IS_WCHAR || LOG4CXX_WCHAR_T_API       
-void TestFixture::assertEquals(const std::wstring expected, 
-    const std::wstring actual, 
-    const char* expectedExpr,
-    const char* actualExpr,
-    int lineno) {
-    if (expected != actual) {
-        std::string exp, act;
-      transcode(exp, expected);
-      transcode(act, actual);
-        abts_str_equal(tc, exp.c_str(), act.c_str(), lineno);
-        throw TestException();
-    }
+#if LOG4CXX_LOGCHAR_IS_WCHAR || LOG4CXX_WCHAR_T_API
+void TestFixture::assertEquals(const std::wstring expected,
+	const std::wstring actual,
+	const char* expectedExpr,
+	const char* actualExpr,
+	int lineno)
+{
+	if (expected != actual)
+	{
+		std::string exp, act;
+		transcode(exp, expected);
+		transcode(act, actual);
+		abts_str_equal(tc, exp.c_str(), act.c_str(), lineno);
+		throw TestException();
+	}
 }
-#endif        
+#endif
 #if LOG4CXX_LOGCHAR_IS_UNICHAR || LOG4CXX_UNICHAR_API || LOG4CXX_CFSTRING_API
-void TestFixture::assertEquals(const std::basic_string<log4cxx::UniChar> expected, 
-     const std::basic_string<log4cxx::UniChar> actual,      
-     const char* expectedExpr,
-     const char* actualExpr,
-int lineno) {
-    if (expected != actual) {
-        std::string exp, act;
-      transcode(exp, expected);
-      transcode(act, actual);
-        abts_str_equal(tc, exp.c_str(), act.c_str(), lineno);
-        throw TestException();
-    }
+void TestFixture::assertEquals(const std::basic_string<log4cxx::UniChar> expected,
+	const std::basic_string<log4cxx::UniChar> actual,
+	const char* expectedExpr,
+	const char* actualExpr,
+	int lineno)
+{
+	if (expected != actual)
+	{
+		std::string exp, act;
+		transcode(exp, expected);
+		transcode(act, actual);
+		abts_str_equal(tc, exp.c_str(), act.c_str(), lineno);
+		throw TestException();
+	}
 }
-#endif        
+#endif
 
 
-void TestFixture::assertEquals(const int expected, const int actual, int lineno) {
-    abts_int_equal(tc, expected, actual, lineno);
-    if (expected != actual) {
-        throw TestException();
-    }
+void TestFixture::assertEquals(const int expected, const int actual, int lineno)
+{
+	abts_int_equal(tc, expected, actual, lineno);
+
+	if (expected != actual)
+	{
+		throw TestException();
+	}
 }
 
 
-LogUnit::TestSuite::TestSuite(const char* fname) : filename(fname), disabled(false) {
+LogUnit::TestSuite::TestSuite(const char* fname) : filename(fname), disabled(false)
+{
 #if defined(_WIN32)
-    for(size_t i = filename.find('\\');
-        i != std::string::npos;
-        i = filename.find('\\', i+1)) {
-        filename.replace(i, 1, 1, '/');
-    }
+
+	for (size_t i = filename.find('\\');
+		i != std::string::npos;
+		i = filename.find('\\', i + 1))
+	{
+		filename.replace(i, 1, 1, '/');
+	}
+
 #endif
 }
 
-void LogUnit::TestSuite::addTest(const char*, test_func func) {
-   test_funcs.push_back(func);
+void LogUnit::TestSuite::addTest(const char*, test_func func)
+{
+	test_funcs.push_back(func);
 }
 
-std::string LogUnit::TestSuite::getName() const {
-   return filename;
+std::string LogUnit::TestSuite::getName() const
+{
+	return filename;
 }
 
-void LogUnit::TestSuite::setDisabled(bool newVal) {
-    disabled = newVal;
+void LogUnit::TestSuite::setDisabled(bool newVal)
+{
+	disabled = newVal;
 }
 
-bool LogUnit::TestSuite::isDisabled() const {
-    return disabled;
+bool LogUnit::TestSuite::isDisabled() const
+{
+	return disabled;
 }
 
-abts_suite* TestSuite::run(abts_suite* suite) const {
-    suite = abts_add_suite(suite, filename.c_str());
-    for(TestList::const_iterator iter = test_funcs.begin();
-        iter != test_funcs.end();
-        iter++) {
-        abts_run_test(suite, *iter, NULL);
-    }
-    return suite;
+abts_suite* TestSuite::run(abts_suite* suite) const
+{
+	suite = abts_add_suite(suite, filename.c_str());
+
+	for (TestList::const_iterator iter = test_funcs.begin();
+		iter != test_funcs.end();
+		iter++)
+	{
+		abts_run_test(suite, *iter, NULL);
+	}
+
+	return suite;
 }
 
 
-LogUnit::SuiteList& LogUnit::getAllSuites() {
-    static LogUnit::SuiteList allSuites;
-    return allSuites;
+LogUnit::SuiteList& LogUnit::getAllSuites()
+{
+	static LogUnit::SuiteList allSuites;
+	return allSuites;
 }
 
diff --git a/src/test/cpp/logunit.h b/src/test/cpp/logunit.h
index abfaa40..8987e15 100644
--- a/src/test/cpp/logunit.h
+++ b/src/test/cpp/logunit.h
@@ -20,8 +20,8 @@
 
 
 #if defined(_MSC_VER)
-#pragma warning (push)
-#pragma warning ( disable: 4231 4251 4275 4786 )
+	#pragma warning (push)
+	#pragma warning ( disable: 4231 4251 4275 4786 )
 #endif
 
 #include "abts.h"
@@ -33,215 +33,250 @@
 
 #include <log4cxx/logstring.h>
 
-namespace LogUnit {
-    class TestException : public std::exception {
-    public:
-        TestException();
-        TestException(const TestException&);
-        TestException& operator=(const TestException&);
-    };
-    class AssertException : public std::exception {
-    public:
-        AssertException(std::string msg, int lineno);
-        AssertException(bool expected, const char* actualExpr, int lineno);
-        AssertException(const AssertException&);
-        AssertException& operator=(const AssertException&);
-        virtual ~AssertException() throw();
-        std::string getMessage() const;
-        int getLine() const;
-    private:
-        std::string msg;
-        int lineno;
-    };
-    class TestFixture {
-    public:
-        TestFixture();
-        virtual ~TestFixture();
-        void setCase(abts_case* tc);
-        virtual void setUp();
-        virtual void tearDown();
+namespace LogUnit
+{
+class TestException : public std::exception
+{
+	public:
+		TestException();
+		TestException(const TestException&);
+		TestException& operator=(const TestException&);
+};
+class AssertException : public std::exception
+{
+	public:
+		AssertException(std::string msg, int lineno);
+		AssertException(bool expected, const char* actualExpr, int lineno);
+		AssertException(const AssertException&);
+		AssertException& operator=(const AssertException&);
+		virtual ~AssertException() throw();
+		std::string getMessage() const;
+		int getLine() const;
+	private:
+		std::string msg;
+		int lineno;
+};
+class TestFixture
+{
+	public:
+		TestFixture();
+		virtual ~TestFixture();
+		void setCase(abts_case* tc);
+		virtual void setUp();
+		virtual void tearDown();
 
-        void assertEquals(const int expected, const int actual, int lineno);
-        void assertEquals(const std::string expected,
-            const std::string actual,
-            const char* expectedExpr,
-            const char* actualExpr,
-            int lineno);
-        void assertEquals(const char* expected,
-            const char* actual,
-            const char* expectedExpr,
-            const char* actualExpr,
-            int lineno);
+		void assertEquals(const int expected, const int actual, int lineno);
+		void assertEquals(const std::string expected,
+			const std::string actual,
+			const char* expectedExpr,
+			const char* actualExpr,
+			int lineno);
+		void assertEquals(const char* expected,
+			const char* actual,
+			const char* expectedExpr,
+			const char* actualExpr,
+			int lineno);
 #if LOG4CXX_LOGCHAR_IS_WCHAR || LOG4CXX_WCHAR_T_API
-        void assertEquals(const std::wstring expected,
-            const std::wstring actual,
-            const char* expectedExpr,
-            const char* actualExpr,
-            int lineno);
+		void assertEquals(const std::wstring expected,
+			const std::wstring actual,
+			const char* expectedExpr,
+			const char* actualExpr,
+			int lineno);
 #endif
 #if LOG4CXX_LOGCHAR_IS_UNICHAR || LOG4CXX_UNICHAR_API || LOG4CXX_CFSTRING_API
-        void assertEquals(const std::basic_string<log4cxx::UniChar> expected,
-             const std::basic_string<log4cxx::UniChar> actual,
-             const char* expectedExpr,
-             const char* actualExpr, int lineno);
+		void assertEquals(const std::basic_string<log4cxx::UniChar> expected,
+			const std::basic_string<log4cxx::UniChar> actual,
+			const char* expectedExpr,
+			const char* actualExpr, int lineno);
 #endif
-        template<class T>
-        void assertEquals(const T& expected,
-             const T& actual,
-             const char* expectedExpr,
-             const char* actualExpr,
-             int lineno) {
-             if (expected != actual) {
-                std::string msg(expectedExpr);
-                msg.append(" != ");
-                msg.append(actualExpr);
-                abts_fail(tc, msg.c_str(), lineno);
-             }
-        }
-    private:
-        TestFixture(const TestFixture&);
-        TestFixture& operator=(const TestFixture&);
-        abts_case* tc;
-    };
-    template<class T>
-    void runTest(abts_case* tc, void (T::*func)()) {
-        T ti;
-        ti.setCase(tc);
-        ti.setUp();
-        try {
-          (ti.*func)();
-        } catch(TestException&) {
-        } catch(AssertException& fx) {
-            abts_fail(tc, fx.getMessage().c_str(), fx.getLine());
-        } catch(std::exception& e) {
-            const char* what = e.what();
-            std::ostringstream oss;
-            oss << "Unexpected std::exception: "
-                << (what ? what : "what() == NULL");
-            abts_fail(tc, oss.str().c_str(), -1);
-        } catch(...) {
-            abts_fail(tc, "Unexpected exception", -1);
-        }
-        ti.tearDown();
-    }
-    template<class T, class X>
-    void runTestWithException(abts_case* tc, void (T::*func)()) {
-        T ti;
-        ti.setCase(tc);
-        ti.setUp();
-        try {
-          (ti.*func)();
-        } catch(TestException&) {
-        } catch(AssertException& fx) {
-            abts_fail(tc, fx.getMessage().c_str(), fx.getLine());
-        } catch(X&) {
-        } catch(...) {
-            abts_fail(tc, "Unexpected exception", -1);
-        }
-        ti.tearDown();
-    }
-    class TestSuite {
-    public:
-        TestSuite(const char* filename);
-        void addTest(const char* testName, test_func func);
-        abts_suite* run(abts_suite* suite) const;
-        std::string getName() const;
-        void setDisabled(bool newVal);
-        bool isDisabled() const;
-    private:
-        TestSuite(const TestSuite&);
-        TestSuite& operator=(const TestSuite&);
-        typedef std::vector<test_func> TestList;
-        TestList test_funcs;
-        std::string filename;
-        bool disabled;
-    };
-    typedef std::vector< std::pair<std::string, const TestSuite*> > SuiteList;
-    SuiteList& getAllSuites();
-    template<class T>
-    class RegisterSuite {
-    public:
-        RegisterSuite() {
-            T::populateSuite();
-            TestSuite* suite = T::getSuite();
-            LogUnit::getAllSuites().push_back(SuiteList::value_type(suite->getName(), suite));
-        }
-    };
-    template<class T>
-    class RegisterDisabledSuite {
-    public:
-        RegisterDisabledSuite() {
-            T::populateSuite();
-            TestSuite* suite = T::getSuite();
-            suite->setDisabled(true);
-            LogUnit::getAllSuites().push_back(SuiteList::value_type(suite->getName(), suite));
-        }
-    };
+		template<class T>
+		void assertEquals(const T& expected,
+			const T& actual,
+			const char* expectedExpr,
+			const char* actualExpr,
+			int lineno)
+		{
+			if (expected != actual)
+			{
+				std::string msg(expectedExpr);
+				msg.append(" != ");
+				msg.append(actualExpr);
+				abts_fail(tc, msg.c_str(), lineno);
+			}
+		}
+	private:
+		TestFixture(const TestFixture&);
+		TestFixture& operator=(const TestFixture&);
+		abts_case* tc;
+};
+template<class T>
+void runTest(abts_case* tc, void (T::*func)())
+{
+	T ti;
+	ti.setCase(tc);
+	ti.setUp();
+
+	try
+	{
+		(ti.*func)();
+	}
+	catch (TestException&)
+	{
+	}
+	catch (AssertException& fx)
+	{
+		abts_fail(tc, fx.getMessage().c_str(), fx.getLine());
+	}
+	catch (std::exception& e)
+	{
+		const char* what = e.what();
+		std::ostringstream oss;
+		oss << "Unexpected std::exception: "
+			<< (what ? what : "what() == NULL");
+		abts_fail(tc, oss.str().c_str(), -1);
+	}
+	catch (...)
+	{
+		abts_fail(tc, "Unexpected exception", -1);
+	}
+
+	ti.tearDown();
+}
+template<class T, class X>
+void runTestWithException(abts_case* tc, void (T::*func)())
+{
+	T ti;
+	ti.setCase(tc);
+	ti.setUp();
+
+	try
+	{
+		(ti.*func)();
+	}
+	catch (TestException&)
+	{
+	}
+	catch (AssertException& fx)
+	{
+		abts_fail(tc, fx.getMessage().c_str(), fx.getLine());
+	}
+	catch (X&)
+	{
+	}
+	catch (...)
+	{
+		abts_fail(tc, "Unexpected exception", -1);
+	}
+
+	ti.tearDown();
+}
+class TestSuite
+{
+	public:
+		TestSuite(const char* filename);
+		void addTest(const char* testName, test_func func);
+		abts_suite* run(abts_suite* suite) const;
+		std::string getName() const;
+		void setDisabled(bool newVal);
+		bool isDisabled() const;
+	private:
+		TestSuite(const TestSuite&);
+		TestSuite& operator=(const TestSuite&);
+		typedef std::vector<test_func> TestList;
+		TestList test_funcs;
+		std::string filename;
+		bool disabled;
+};
+typedef std::vector< std::pair<std::string, const TestSuite*> > SuiteList;
+SuiteList& getAllSuites();
+template<class T>
+class RegisterSuite
+{
+	public:
+		RegisterSuite()
+		{
+			T::populateSuite();
+			TestSuite* suite = T::getSuite();
+			LogUnit::getAllSuites().push_back(SuiteList::value_type(suite->getName(), suite));
+		}
+};
+template<class T>
+class RegisterDisabledSuite
+{
+	public:
+		RegisterDisabledSuite()
+		{
+			T::populateSuite();
+			TestSuite* suite = T::getSuite();
+			suite->setDisabled(true);
+			LogUnit::getAllSuites().push_back(SuiteList::value_type(suite->getName(), suite));
+		}
+};
 }
 
 #define LOGUNIT_CLASS(x) class x : public LogUnit::TestFixture
 
 
 #define LOGUNIT_TEST_SUITE(TF)                        \
-public:                                               \
-     static LogUnit::TestSuite* getSuite() {          \
-        static LogUnit::TestSuite suite(__FILE__);    \
-        return &suite;                                \
-     }                                                \
-     private:                                         \
-     class RegisterSuite {                            \
-     public:                                          \
-        typedef TF ThisFixture
+	public:                                               \
+	static LogUnit::TestSuite* getSuite() {          \
+		static LogUnit::TestSuite suite(__FILE__);    \
+		return &suite;                                \
+	}                                                \
+	private:                                         \
+	class RegisterSuite {                            \
+		public:                                          \
+			typedef TF ThisFixture
 
 #define LOGUNIT_TEST(testName)          \
-     class testName ## Registration {   \
-     public:                            \
-        testName ## Registration() {    \
-            ThisFixture::getSuite()->addTest(#testName, &testName ## Registration :: run); \
-        }                               \
-        static void run(abts_case* tc, void*) { \
-            LogUnit::runTest<ThisFixture>(tc, &ThisFixture::testName); \
-        }                                       \
-    } register ## testName
+	class testName ## Registration {   \
+		public:                            \
+			testName ## Registration() {    \
+				ThisFixture::getSuite()->addTest(#testName, &testName ## Registration :: run); \
+			}                               \
+			static void run(abts_case* tc, void*) { \
+				LogUnit::runTest<ThisFixture>(tc, &ThisFixture::testName); \
+			}                                       \
+	} register ## testName
 
 #define LOGUNIT_TEST_EXCEPTION(testName, Exception)  \
-     class testName ## Registration {   \
-     public:                            \
-        testName ## Registration() {    \
-            ThisFixture::getSuite()->addTest(#testName, &testName ## Registration :: run); \
-        }                               \
-        static void run(abts_case* tc, void*) { \
-            LogUnit::runTestWithException<ThisFixture, Exception>(tc, &ThisFixture::testName); \
-        }                                       \
-    } register ## testName
+	class testName ## Registration {   \
+		public:                            \
+			testName ## Registration() {    \
+				ThisFixture::getSuite()->addTest(#testName, &testName ## Registration :: run); \
+			}                               \
+			static void run(abts_case* tc, void*) { \
+				LogUnit::runTestWithException<ThisFixture, Exception>(tc, &ThisFixture::testName); \
+			}                                       \
+	} register ## testName
 
 
 #define LOGUNIT_TEST_SUITE_END() \
-    };                             \
-    public:                        \
-    static void populateSuite() {         \
-        static RegisterSuite registration; \
-    }                                      \
-    private:                               \
-    void nop()
+	};                             \
+	public:                        \
+	static void populateSuite() {         \
+		static RegisterSuite registration; \
+	}                                      \
+	private:                               \
+	void nop()
 
 
 #define LOGUNIT_TEST_SUITE_REGISTRATION(TF) \
-static LogUnit::RegisterSuite<TF> registration;
+	static LogUnit::RegisterSuite<TF> registration;
 
 #define LOGUNIT_TEST_SUITE_REGISTRATION_DISABLED(TF) \
-static LogUnit::RegisterDisabledSuite<TF> registration;
+	static LogUnit::RegisterDisabledSuite<TF> registration;
 
 
-#define LOGUNIT_ASSERT(		x)									{ if (!(x)) throw LogUnit::AssertException(true, #x, __LINE__);	}
-#define LOGUNIT_ASSERT_SRCL(x, srcLine)							{ if (!(x)) throw LogUnit::AssertException(true, #x, srcLine);	}
-#define LOGUNIT_ASSERT_EQUAL(		expected, actual)			assertEquals(expected, actual, #expected, #actual, __LINE__)
-#define LOGUNIT_ASSERT_EQUAL_SRCL(	expected, actual, srcLine)	assertEquals(expected, actual, #expected, #actual, srcLine)
-#define LOGUNIT_FAIL(msg)										throw LogUnit::AssertException(msg, __LINE__)
+#define LOGUNIT_ASSERT(     x)                                  { if (!(x)) throw LogUnit::AssertException(true, #x, __LINE__); }
+#define LOGUNIT_ASSERT_SRCL(x, srcLine)                         { if (!(x)) throw LogUnit::AssertException(true, #x, srcLine);  }
+#define LOGUNIT_ASSERT_EQUAL(       expected, actual)           assertEquals(expected, actual, #expected, #actual, __LINE__)
+#define LOGUNIT_ASSERT_EQUAL_SRCL(  expected, actual, srcLine)  assertEquals(expected, actual, #expected, #actual, srcLine)
+#define LOGUNIT_FAIL(msg)                                       throw LogUnit::AssertException(msg, __LINE__)
 
 
 #if defined(_MSC_VER)
-#pragma warning (pop)
+	#pragma warning (pop)
 #endif
 
 #endif
diff --git a/src/test/cpp/mdctestcase.cpp b/src/test/cpp/mdctestcase.cpp
index b3a066e..b0f861e 100644
--- a/src/test/cpp/mdctestcase.cpp
+++ b/src/test/cpp/mdctestcase.cpp
@@ -30,31 +30,33 @@
 
 LOGUNIT_CLASS(MDCTestCase)
 {
-        LOGUNIT_TEST_SUITE(MDCTestCase);
-                LOGUNIT_TEST(test1);
-        LOGUNIT_TEST_SUITE_END();
+	LOGUNIT_TEST_SUITE(MDCTestCase);
+	LOGUNIT_TEST(test1);
+	LOGUNIT_TEST_SUITE_END();
 
 public:
 
-        void setUp() {
-        }
+	void setUp()
+	{
+	}
 
-        void tearDown() {
-            Logger::getRootLogger()->getLoggerRepository()->resetConfiguration();
-        }
+	void tearDown()
+	{
+		Logger::getRootLogger()->getLoggerRepository()->resetConfiguration();
+	}
 
-        /**
-         *   log4cxx 0.10.0 did not replace previously set value.
-         */
-        void test1()
-        {
-                std::string key("key1");
-                std::string expected("value2");
-                MDC::put(key, "value1");
-                MDC::put(key, expected);
-                std::string actual(MDC::get(key));
-                LOGUNIT_ASSERT_EQUAL(expected, actual);
-        }
+	/**
+	 *   log4cxx 0.10.0 did not replace previously set value.
+	 */
+	void test1()
+	{
+		std::string key("key1");
+		std::string expected("value2");
+		MDC::put(key, "value1");
+		MDC::put(key, expected);
+		std::string actual(MDC::get(key));
+		LOGUNIT_ASSERT_EQUAL(expected, actual);
+	}
 };
 
 LOGUNIT_TEST_SUITE_REGISTRATION(MDCTestCase);
diff --git a/src/test/cpp/minimumtestcase.cpp b/src/test/cpp/minimumtestcase.cpp
index 2d08cc4..0064804 100644
--- a/src/test/cpp/minimumtestcase.cpp
+++ b/src/test/cpp/minimumtestcase.cpp
@@ -41,204 +41,205 @@
 
 
 #define TTCC_PAT  \
-        ABSOLUTE_DATE_AND_TIME_PAT \
-        " \\[0x[0-9A-F]*]\\ (DEBUG|INFO|WARN|ERROR|FATAL) .* - Message [0-9]\\{1,2\\}"
+	ABSOLUTE_DATE_AND_TIME_PAT \
+	" \\[0x[0-9A-F]*]\\ (DEBUG|INFO|WARN|ERROR|FATAL) .* - Message [0-9]\\{1,2\\}"
 
 #define TTCC2_PAT \
-        ABSOLUTE_DATE_AND_TIME_PAT \
-        " \\[0x[0-9A-F]*]\\ (DEBUG|INFO|WARN|ERROR|FATAL) .* - " \
-        "Messages should bear numbers 0 through 23\\."
+	ABSOLUTE_DATE_AND_TIME_PAT \
+	" \\[0x[0-9A-F]*]\\ (DEBUG|INFO|WARN|ERROR|FATAL) .* - " \
+	"Messages should bear numbers 0 through 23\\."
 
 
 LOGUNIT_CLASS(MinimumTestCase)
 {
-        LOGUNIT_TEST_SUITE(MinimumTestCase);
-                LOGUNIT_TEST(simple);
-                LOGUNIT_TEST(ttcc);
-        LOGUNIT_TEST_SUITE_END();
+	LOGUNIT_TEST_SUITE(MinimumTestCase);
+	LOGUNIT_TEST(simple);
+	LOGUNIT_TEST(ttcc);
+	LOGUNIT_TEST_SUITE_END();
 
 public:
-        void setUp()
-        {
-                root = Logger::getRootLogger();
-                root->removeAllAppenders();
-        }
+	void setUp()
+	{
+		root = Logger::getRootLogger();
+		root->removeAllAppenders();
+	}
 
-        void tearDown()
-        {
-                root->getLoggerRepository()->resetConfiguration();
-        }
+	void tearDown()
+	{
+		root->getLoggerRepository()->resetConfiguration();
+	}
 
-        void simple()
-        {
-                LayoutPtr layout = new SimpleLayout();
-                AppenderPtr appender = new FileAppender(layout, LOG4CXX_STR("output/simple"), false);
-                root->addAppender(appender);
-                common();
+	void simple()
+	{
+		LayoutPtr layout = new SimpleLayout();
+		AppenderPtr appender = new FileAppender(layout, LOG4CXX_STR("output/simple"), false);
+		root->addAppender(appender);
+		common();
 
-                LOGUNIT_ASSERT(Compare::compare(LOG4CXX_FILE("output/simple"), LOG4CXX_FILE("witness/simple")));
-        }
+		LOGUNIT_ASSERT(Compare::compare(LOG4CXX_FILE("output/simple"), LOG4CXX_FILE("witness/simple")));
+	}
 
-        void ttcc()
-        {
-                LayoutPtr layout =
-                        new TTCCLayout(LOG4CXX_STR("DATE"));
-                AppenderPtr appender = new FileAppender(layout, LOG4CXX_STR("output/ttcc"), false);
-                root->addAppender(appender);
-                common();
+	void ttcc()
+	{
+		LayoutPtr layout =
+			new TTCCLayout(LOG4CXX_STR("DATE"));
+		AppenderPtr appender = new FileAppender(layout, LOG4CXX_STR("output/ttcc"), false);
+		root->addAppender(appender);
+		common();
 
-                ControlFilter filter1;
-                filter1 << TTCC_PAT << TTCC2_PAT;
-                AbsoluteDateAndTimeFilter filter2;
-                ThreadFilter filter3;
+		ControlFilter filter1;
+		filter1 << TTCC_PAT << TTCC2_PAT;
+		AbsoluteDateAndTimeFilter filter2;
+		ThreadFilter filter3;
 
-                std::vector<Filter *> filters;
-                filters.push_back(&filter1);
-                filters.push_back(&filter2);
-                filters.push_back(&filter3);
+		std::vector<Filter*> filters;
+		filters.push_back(&filter1);
+		filters.push_back(&filter2);
+		filters.push_back(&filter3);
 
-                try
-                {
-                        const File output("output/ttcc");
-                        Transformer::transform(output, FILTERED, filters);
-                }
-                catch(std::exception& e)
-                {
-                        std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
-                        throw;
-                }
+		try
+		{
+			const File output("output/ttcc");
+			Transformer::transform(output, FILTERED, filters);
+		}
+		catch (std::exception& e)
+		{
+			std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
+			throw;
+		}
 
-                const File witness("witness/ttcc");
-                LOGUNIT_ASSERT(Compare::compare(FILTERED, witness));
-        }
+		const File witness("witness/ttcc");
+		LOGUNIT_ASSERT(Compare::compare(FILTERED, witness));
+	}
 
-        std::string createMessage(int i, Pool& pool) {
-             std::string msg("Message ");
-             msg.append(pool.itoa(i));
-             return msg;
-        }
+	std::string createMessage(int i, Pool & pool)
+	{
+		std::string msg("Message ");
+		msg.append(pool.itoa(i));
+		return msg;
+	}
 
-        void common()
-        {
-                int i = 0;
+	void common()
+	{
+		int i = 0;
 
-                // In the lines below, the logger names are chosen as an aid in
-                // remembering their level values. In general, the logger names
-                // have no bearing to level values.
-                LoggerPtr ERRlogger = Logger::getLogger(LOG4CXX_TEST_STR("ERR"));
-                ERRlogger->setLevel(Level::getError());
+		// In the lines below, the logger names are chosen as an aid in
+		// remembering their level values. In general, the logger names
+		// have no bearing to level values.
+		LoggerPtr ERRlogger = Logger::getLogger(LOG4CXX_TEST_STR("ERR"));
+		ERRlogger->setLevel(Level::getError());
 
-                LoggerPtr INF = Logger::getLogger(LOG4CXX_TEST_STR("INF"));
-                INF->setLevel(Level::getInfo());
+		LoggerPtr INF = Logger::getLogger(LOG4CXX_TEST_STR("INF"));
+		INF->setLevel(Level::getInfo());
 
-                LoggerPtr INF_ERR = Logger::getLogger(LOG4CXX_TEST_STR("INF.ERR"));
-                INF_ERR->setLevel(Level::getError());
+		LoggerPtr INF_ERR = Logger::getLogger(LOG4CXX_TEST_STR("INF.ERR"));
+		INF_ERR->setLevel(Level::getError());
 
-                LoggerPtr DEB = Logger::getLogger(LOG4CXX_TEST_STR("DEB"));
-                DEB->setLevel(Level::getDebug());
+		LoggerPtr DEB = Logger::getLogger(LOG4CXX_TEST_STR("DEB"));
+		DEB->setLevel(Level::getDebug());
 
-                // Note: categories with undefined level
-                LoggerPtr INF_UNDEF = Logger::getLogger(LOG4CXX_TEST_STR("INF.UNDEF"));
-                LoggerPtr INF_ERR_UNDEF = Logger::getLogger(LOG4CXX_TEST_STR("INF.ERR.UNDEF"));
-                LoggerPtr UNDEF = Logger::getLogger(LOG4CXX_TEST_STR("UNDEF"));
+		// Note: categories with undefined level
+		LoggerPtr INF_UNDEF = Logger::getLogger(LOG4CXX_TEST_STR("INF.UNDEF"));
+		LoggerPtr INF_ERR_UNDEF = Logger::getLogger(LOG4CXX_TEST_STR("INF.ERR.UNDEF"));
+		LoggerPtr UNDEF = Logger::getLogger(LOG4CXX_TEST_STR("UNDEF"));
 
-                std::string msg("Message ");
+		std::string msg("Message ");
 
-                Pool pool;
+		Pool pool;
 
-                // These should all log.----------------------------
-                LOG4CXX_FATAL(ERRlogger, createMessage(i, pool));
-                i++; //0
-                LOG4CXX_ERROR(ERRlogger, createMessage(i, pool));
-                i++;
+		// These should all log.----------------------------
+		LOG4CXX_FATAL(ERRlogger, createMessage(i, pool));
+		i++; //0
+		LOG4CXX_ERROR(ERRlogger, createMessage(i, pool));
+		i++;
 
-                LOG4CXX_FATAL(INF, createMessage(i, pool));
-                i++; // 2
-                LOG4CXX_ERROR(INF, createMessage(i, pool));
-                i++;
-                LOG4CXX_WARN(INF, createMessage(i, pool));
-                i++;
-                LOG4CXX_INFO(INF, createMessage(i, pool));
-                i++;
+		LOG4CXX_FATAL(INF, createMessage(i, pool));
+		i++; // 2
+		LOG4CXX_ERROR(INF, createMessage(i, pool));
+		i++;
+		LOG4CXX_WARN(INF, createMessage(i, pool));
+		i++;
+		LOG4CXX_INFO(INF, createMessage(i, pool));
+		i++;
 
-                LOG4CXX_FATAL(INF_UNDEF, createMessage(i, pool));
-                i++; //6
-                LOG4CXX_ERROR(INF_UNDEF, createMessage(i, pool));
-                i++;
-                LOG4CXX_WARN(INF_UNDEF, createMessage(i, pool));
-                i++;
-                LOG4CXX_INFO(INF_UNDEF, createMessage(i, pool));
-                i++;
+		LOG4CXX_FATAL(INF_UNDEF, createMessage(i, pool));
+		i++; //6
+		LOG4CXX_ERROR(INF_UNDEF, createMessage(i, pool));
+		i++;
+		LOG4CXX_WARN(INF_UNDEF, createMessage(i, pool));
+		i++;
+		LOG4CXX_INFO(INF_UNDEF, createMessage(i, pool));
+		i++;
 
-                LOG4CXX_FATAL(INF_ERR, createMessage(i, pool));
-                i++; // 10
-                LOG4CXX_ERROR(INF_ERR, createMessage(i, pool));
-                i++;
+		LOG4CXX_FATAL(INF_ERR, createMessage(i, pool));
+		i++; // 10
+		LOG4CXX_ERROR(INF_ERR, createMessage(i, pool));
+		i++;
 
-                LOG4CXX_FATAL(INF_ERR_UNDEF, createMessage(i, pool));
-                i++;
-                LOG4CXX_ERROR(INF_ERR_UNDEF, createMessage(i, pool));
-                i++;
+		LOG4CXX_FATAL(INF_ERR_UNDEF, createMessage(i, pool));
+		i++;
+		LOG4CXX_ERROR(INF_ERR_UNDEF, createMessage(i, pool));
+		i++;
 
-                LOG4CXX_FATAL(DEB, createMessage(i, pool));
-                i++; //14
-                LOG4CXX_ERROR(DEB, createMessage(i, pool));
-                i++;
-                LOG4CXX_WARN(DEB, createMessage(i, pool));
-                i++;
-                LOG4CXX_INFO(DEB, createMessage(i, pool));
-                i++;
-                LOG4CXX_DEBUG(DEB, createMessage(i, pool));
-                i++;
+		LOG4CXX_FATAL(DEB, createMessage(i, pool));
+		i++; //14
+		LOG4CXX_ERROR(DEB, createMessage(i, pool));
+		i++;
+		LOG4CXX_WARN(DEB, createMessage(i, pool));
+		i++;
+		LOG4CXX_INFO(DEB, createMessage(i, pool));
+		i++;
+		LOG4CXX_DEBUG(DEB, createMessage(i, pool));
+		i++;
 
-                // defaultLevel=DEBUG
-                LOG4CXX_FATAL(UNDEF, createMessage(i, pool));
-                i++; // 19
-                LOG4CXX_ERROR(UNDEF, createMessage(i, pool));
-                i++;
-                LOG4CXX_WARN(UNDEF, createMessage(i, pool));
-                i++;
-                LOG4CXX_INFO(UNDEF, createMessage(i, pool));
-                i++;
-                LOG4CXX_DEBUG(UNDEF, createMessage(i, pool));
-                i++;
+		// defaultLevel=DEBUG
+		LOG4CXX_FATAL(UNDEF, createMessage(i, pool));
+		i++; // 19
+		LOG4CXX_ERROR(UNDEF, createMessage(i, pool));
+		i++;
+		LOG4CXX_WARN(UNDEF, createMessage(i, pool));
+		i++;
+		LOG4CXX_INFO(UNDEF, createMessage(i, pool));
+		i++;
+		LOG4CXX_DEBUG(UNDEF, createMessage(i, pool));
+		i++;
 
-                // -------------------------------------------------
-                // The following should not log
-                LOG4CXX_WARN(ERRlogger, createMessage(i, pool));
-                i++;
-                LOG4CXX_INFO(ERRlogger, createMessage(i, pool));
-                i++;
-                LOG4CXX_DEBUG(ERRlogger, createMessage(i, pool));
-                i++;
+		// -------------------------------------------------
+		// The following should not log
+		LOG4CXX_WARN(ERRlogger, createMessage(i, pool));
+		i++;
+		LOG4CXX_INFO(ERRlogger, createMessage(i, pool));
+		i++;
+		LOG4CXX_DEBUG(ERRlogger, createMessage(i, pool));
+		i++;
 
-                LOG4CXX_DEBUG(INF, createMessage(i, pool));
-                i++;
-                LOG4CXX_DEBUG(INF_UNDEF, createMessage(i, pool));
-                i++;
+		LOG4CXX_DEBUG(INF, createMessage(i, pool));
+		i++;
+		LOG4CXX_DEBUG(INF_UNDEF, createMessage(i, pool));
+		i++;
 
-                LOG4CXX_WARN(INF_ERR, createMessage(i, pool));
-                i++;
-                LOG4CXX_INFO(INF_ERR, createMessage(i, pool));
-                i++;
-                LOG4CXX_DEBUG(INF_ERR, createMessage(i, pool));
-                i++;
-                LOG4CXX_WARN(INF_ERR_UNDEF, createMessage(i, pool));
-                i++;
-                LOG4CXX_INFO(INF_ERR_UNDEF, createMessage(i, pool));
-                i++;
-                LOG4CXX_DEBUG(INF_ERR_UNDEF, createMessage(i, pool));
-                i++;
+		LOG4CXX_WARN(INF_ERR, createMessage(i, pool));
+		i++;
+		LOG4CXX_INFO(INF_ERR, createMessage(i, pool));
+		i++;
+		LOG4CXX_DEBUG(INF_ERR, createMessage(i, pool));
+		i++;
+		LOG4CXX_WARN(INF_ERR_UNDEF, createMessage(i, pool));
+		i++;
+		LOG4CXX_INFO(INF_ERR_UNDEF, createMessage(i, pool));
+		i++;
+		LOG4CXX_DEBUG(INF_ERR_UNDEF, createMessage(i, pool));
+		i++;
 
-                // -------------------------------------------------
-                LOG4CXX_INFO(INF, LOG4CXX_TEST_STR("Messages should bear numbers 0 through 23."));
-   }
+		// -------------------------------------------------
+		LOG4CXX_INFO(INF, LOG4CXX_TEST_STR("Messages should bear numbers 0 through 23."));
+	}
 
-   LoggerPtr root;
-   LoggerPtr logger;
+	LoggerPtr root;
+	LoggerPtr logger;
 
 private:
-   static const File FILTERED;
+	static const File FILTERED;
 };
 
 
diff --git a/src/test/cpp/ndctestcase.cpp b/src/test/cpp/ndctestcase.cpp
index fd55942..562125d 100644
--- a/src/test/cpp/ndctestcase.cpp
+++ b/src/test/cpp/ndctestcase.cpp
@@ -30,76 +30,82 @@
 
 LOGUNIT_CLASS(NDCTestCase)
 {
-         static File TEMP;
-         static LoggerPtr logger;
+	static File TEMP;
+	static LoggerPtr logger;
 
-        LOGUNIT_TEST_SUITE(NDCTestCase);
-                LOGUNIT_TEST(testPushPop);
-                LOGUNIT_TEST(test1);
-                LOGUNIT_TEST(testInherit);
-        LOGUNIT_TEST_SUITE_END();
+	LOGUNIT_TEST_SUITE(NDCTestCase);
+	LOGUNIT_TEST(testPushPop);
+	LOGUNIT_TEST(test1);
+	LOGUNIT_TEST(testInherit);
+	LOGUNIT_TEST_SUITE_END();
 
 public:
 
-        void setUp() {
-        }
+	void setUp()
+	{
+	}
 
-        void tearDown() {
-            logger->getLoggerRepository()->resetConfiguration();
-        }
+	void tearDown()
+	{
+		logger->getLoggerRepository()->resetConfiguration();
+	}
 
-        /**
-         *   Push and pop a value from the NDC
-         */
-        void testPushPop()
-        {
-                NDC::push("trivial context");
-                LogString actual(NDC::pop());
-                LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("trivial context"), actual);
-        }
+	/**
+	 *   Push and pop a value from the NDC
+	 */
+	void testPushPop()
+	{
+		NDC::push("trivial context");
+		LogString actual(NDC::pop());
+		LOGUNIT_ASSERT_EQUAL((LogString) LOG4CXX_STR("trivial context"), actual);
+	}
 
 
-        void test1()  {
-            PropertyConfigurator::configure(File("input/ndc/NDC1.properties"));
-            common();
-            LOGUNIT_ASSERT(Compare::compare(TEMP, File("witness/ndc/NDC.1")));
-        }
+	void test1()
+	{
+		PropertyConfigurator::configure(File("input/ndc/NDC1.properties"));
+		common();
+		LOGUNIT_ASSERT(Compare::compare(TEMP, File("witness/ndc/NDC.1")));
+	}
 
-        static void common() {
-            commonLog();
-            NDC::push("n1");
-            commonLog();
-            NDC::push("n2");
-            NDC::push("n3");
-            commonLog();
-            NDC::pop();
-            commonLog();
-            NDC::clear();
-            commonLog();
-        }
+	static void common()
+	{
+		commonLog();
+		NDC::push("n1");
+		commonLog();
+		NDC::push("n2");
+		NDC::push("n3");
+		commonLog();
+		NDC::pop();
+		commonLog();
+		NDC::clear();
+		commonLog();
+	}
 
-        static void commonLog() {
-            LOG4CXX_DEBUG(logger, "m1");
-            LOG4CXX_INFO(logger, "m2");
-            LOG4CXX_WARN(logger, "m3");
-            LOG4CXX_ERROR(logger, "m4");
-            LOG4CXX_FATAL(logger, "m5");
-        }
-        
-        void testInherit() {
-           NDC::push("hello");
-           NDC::push("world");
-           NDC::Stack* clone = NDC::cloneStack();
-           NDC::clear();
-           NDC::push("discard");
-           NDC::inherit(clone);
-           LogString expected1(LOG4CXX_STR("world"));
-           LOGUNIT_ASSERT_EQUAL(expected1, NDC::pop());
-           LogString expected2(LOG4CXX_STR("hello"));
-           LOGUNIT_ASSERT_EQUAL(expected2, NDC::pop());
-           LogString expected3;
-           LOGUNIT_ASSERT_EQUAL(expected3, NDC::pop());
-        }
+	static void commonLog()
+	{
+		LOG4CXX_DEBUG(logger, "m1");
+		LOG4CXX_INFO(logger, "m2");
+		LOG4CXX_WARN(logger, "m3");
+		LOG4CXX_ERROR(logger, "m4");
+		LOG4CXX_FATAL(logger, "m5");
+	}
+
+	void testInherit()
+	{
+		NDC::push("hello");
+		NDC::push("world");
+		NDC::Stack* clone = NDC::cloneStack();
+		NDC::clear();
+		NDC::push("discard");
+		NDC::inherit(clone);
+		LogString expected1(LOG4CXX_STR("world"));
+		LOGUNIT_ASSERT_EQUAL(expected1, NDC::pop());
+		LogString expected2(LOG4CXX_STR("hello"));
+		LOGUNIT_ASSERT_EQUAL(expected2, NDC::pop());
+		LogString expected3;
+		LOGUNIT_ASSERT_EQUAL(expected3, NDC::pop());
+	}
 
 };
 
diff --git a/src/test/cpp/net/smtpappendertestcase.cpp b/src/test/cpp/net/smtpappendertestcase.cpp
index e2ebe43..2259b22 100644
--- a/src/test/cpp/net/smtpappendertestcase.cpp
+++ b/src/test/cpp/net/smtpappendertestcase.cpp
@@ -32,31 +32,35 @@
 using namespace log4cxx::xml;
 using namespace log4cxx::spi;
 
-namespace log4cxx {
-    namespace net {
+namespace log4cxx
+{
+namespace net
+{
 
-                class MockTriggeringEventEvaluator :
-                        public virtual spi::TriggeringEventEvaluator,
-                        public virtual helpers::ObjectImpl
-                {
-                public:
-                        DECLARE_LOG4CXX_OBJECT(MockTriggeringEventEvaluator)
-                        BEGIN_LOG4CXX_CAST_MAP()
-                                LOG4CXX_CAST_ENTRY(MockTriggeringEventEvaluator)
-                                LOG4CXX_CAST_ENTRY(spi::TriggeringEventEvaluator)
-                        END_LOG4CXX_CAST_MAP()
+class MockTriggeringEventEvaluator :
+	public virtual spi::TriggeringEventEvaluator,
+	public virtual helpers::ObjectImpl
+{
+	public:
+		DECLARE_LOG4CXX_OBJECT(MockTriggeringEventEvaluator)
+		BEGIN_LOG4CXX_CAST_MAP()
+		LOG4CXX_CAST_ENTRY(MockTriggeringEventEvaluator)
+		LOG4CXX_CAST_ENTRY(spi::TriggeringEventEvaluator)
+		END_LOG4CXX_CAST_MAP()
 
-                        MockTriggeringEventEvaluator() {
-                        }
+		MockTriggeringEventEvaluator()
+		{
+		}
 
-                        virtual bool isTriggeringEvent(const spi::LoggingEventPtr& event) {
-                            return true;
-                        }
-                private:
-                         MockTriggeringEventEvaluator(const MockTriggeringEventEvaluator&);
-                         MockTriggeringEventEvaluator& operator=(const MockTriggeringEventEvaluator&);
-                };
-    }
+		virtual bool isTriggeringEvent(const spi::LoggingEventPtr& event)
+		{
+			return true;
+		}
+	private:
+		MockTriggeringEventEvaluator(const MockTriggeringEventEvaluator&);
+		MockTriggeringEventEvaluator& operator=(const MockTriggeringEventEvaluator&);
+};
+}
 }
 
 IMPLEMENT_LOG4CXX_OBJECT(MockTriggeringEventEvaluator)
@@ -67,53 +71,58 @@
  */
 class SMTPAppenderTestCase : public AppenderSkeletonTestCase
 {
-   LOGUNIT_TEST_SUITE(SMTPAppenderTestCase);
-                //
-                //    tests inherited from AppenderSkeletonTestCase
-                //
-                LOGUNIT_TEST(testDefaultThreshold);
-                LOGUNIT_TEST(testSetOptionThreshold);
-                LOGUNIT_TEST(testTrigger);
-                LOGUNIT_TEST(testInvalid);
-   LOGUNIT_TEST_SUITE_END();
+		LOGUNIT_TEST_SUITE(SMTPAppenderTestCase);
+		//
+		//    tests inherited from AppenderSkeletonTestCase
+		//
+		LOGUNIT_TEST(testDefaultThreshold);
+		LOGUNIT_TEST(testSetOptionThreshold);
+		LOGUNIT_TEST(testTrigger);
+		LOGUNIT_TEST(testInvalid);
+		LOGUNIT_TEST_SUITE_END();
 
 
-public:
+	public:
 
-        AppenderSkeleton* createAppenderSkeleton() const {
-          return new log4cxx::net::SMTPAppender();
-        }
-        
-   void setUp() {
-   }
-   
-   void tearDown() {
-       LogManager::resetConfiguration();
-   }
+		AppenderSkeleton* createAppenderSkeleton() const
+		{
+			return new log4cxx::net::SMTPAppender();
+		}
 
-    /**
-     * Tests that triggeringPolicy element will set evaluator.
-     */
-  void testTrigger() {
-      DOMConfigurator::configure("input/xml/smtpAppender1.xml");
-      SMTPAppenderPtr appender(Logger::getRootLogger()->getAppender(LOG4CXX_STR("A1")));
-      TriggeringEventEvaluatorPtr evaluator(appender->getEvaluator());
-      LOGUNIT_ASSERT_EQUAL(true, evaluator->instanceof(MockTriggeringEventEvaluator::getStaticClass()));
-  }
-  
-  void testInvalid() {
-      SMTPAppenderPtr appender(new SMTPAppender());
-      appender->setSMTPHost(LOG4CXX_STR("smtp.invalid"));
-      appender->setTo(LOG4CXX_STR("you@example.invalid"));
-      appender->setFrom(LOG4CXX_STR("me@example.invalid"));
-      appender->setLayout(new TTCCLayout());
-      Pool p;
-      appender->activateOptions(p);
-      LoggerPtr root(Logger::getRootLogger());
-      root->addAppender(appender);
-      LOG4CXX_INFO(root, "Hello, World.")
-      LOG4CXX_ERROR(root, "Sending Message")
-  }
+		void setUp()
+		{
+		}
+
+		void tearDown()
+		{
+			LogManager::resetConfiguration();
+		}
+
+		/**
+		 * Tests that triggeringPolicy element will set evaluator.
+		 */
+		void testTrigger()
+		{
+			DOMConfigurator::configure("input/xml/smtpAppender1.xml");
+			SMTPAppenderPtr appender(Logger::getRootLogger()->getAppender(LOG4CXX_STR("A1")));
+			TriggeringEventEvaluatorPtr evaluator(appender->getEvaluator());
+			LOGUNIT_ASSERT_EQUAL(true, evaluator->instanceof(MockTriggeringEventEvaluator::getStaticClass()));
+		}
+
+		void testInvalid()
+		{
+			SMTPAppenderPtr appender(new SMTPAppender());
+			appender->setSMTPHost(LOG4CXX_STR("smtp.invalid"));
+			appender->setTo(LOG4CXX_STR("you@example.invalid"));
+			appender->setFrom(LOG4CXX_STR("me@example.invalid"));
+			appender->setLayout(new TTCCLayout());
+			Pool p;
+			appender->activateOptions(p);
+			LoggerPtr root(Logger::getRootLogger());
+			root->addAppender(appender);
+			LOG4CXX_INFO(root, "Hello, World.")
+			LOG4CXX_ERROR(root, "Sending Message")
+		}
 
 };
 
diff --git a/src/test/cpp/net/socketappendertestcase.cpp b/src/test/cpp/net/socketappendertestcase.cpp
index 195ba99..fe3753c 100644
--- a/src/test/cpp/net/socketappendertestcase.cpp
+++ b/src/test/cpp/net/socketappendertestcase.cpp
@@ -28,21 +28,22 @@
  */
 class SocketAppenderTestCase : public AppenderSkeletonTestCase
 {
-   LOGUNIT_TEST_SUITE(SocketAppenderTestCase);
-                //
-                //    tests inherited from AppenderSkeletonTestCase
-                //
-                LOGUNIT_TEST(testDefaultThreshold);
-                LOGUNIT_TEST(testSetOptionThreshold);
+		LOGUNIT_TEST_SUITE(SocketAppenderTestCase);
+		//
+		//    tests inherited from AppenderSkeletonTestCase
+		//
+		LOGUNIT_TEST(testDefaultThreshold);
+		LOGUNIT_TEST(testSetOptionThreshold);
 
-   LOGUNIT_TEST_SUITE_END();
+		LOGUNIT_TEST_SUITE_END();
 
 
-public:
+	public:
 
-        AppenderSkeleton* createAppenderSkeleton() const {
-          return new log4cxx::net::SocketAppender();
-        }
+		AppenderSkeleton* createAppenderSkeleton() const
+		{
+			return new log4cxx::net::SocketAppender();
+		}
 };
 
 LOGUNIT_TEST_SUITE_REGISTRATION(SocketAppenderTestCase);
diff --git a/src/test/cpp/net/sockethubappendertestcase.cpp b/src/test/cpp/net/sockethubappendertestcase.cpp
index d7b86f7..816193d 100644
--- a/src/test/cpp/net/sockethubappendertestcase.cpp
+++ b/src/test/cpp/net/sockethubappendertestcase.cpp
@@ -30,51 +30,58 @@
  */
 class SocketHubAppenderTestCase : public AppenderSkeletonTestCase
 {
-   LOGUNIT_TEST_SUITE(SocketHubAppenderTestCase);
-                //
-                //    tests inherited from AppenderSkeletonTestCase
-                //
-                LOGUNIT_TEST(testDefaultThreshold);
-                LOGUNIT_TEST(testSetOptionThreshold);
-                LOGUNIT_TEST(testActivateClose);
-                LOGUNIT_TEST(testActivateSleepClose);
-                LOGUNIT_TEST(testActivateWriteClose);
-   LOGUNIT_TEST_SUITE_END();
+		LOGUNIT_TEST_SUITE(SocketHubAppenderTestCase);
+		//
+		//    tests inherited from AppenderSkeletonTestCase
+		//
+		LOGUNIT_TEST(testDefaultThreshold);
+		LOGUNIT_TEST(testSetOptionThreshold);
+		LOGUNIT_TEST(testActivateClose);
+		LOGUNIT_TEST(testActivateSleepClose);
+		LOGUNIT_TEST(testActivateWriteClose);
+		LOGUNIT_TEST_SUITE_END();
 
 
-public:
+	public:
 
-        AppenderSkeleton* createAppenderSkeleton() const {
-          return new log4cxx::net::SocketHubAppender();
-        }
+		AppenderSkeleton* createAppenderSkeleton() const
+		{
+			return new log4cxx::net::SocketHubAppender();
+		}
 
-        void testActivateClose() {
-            SocketHubAppenderPtr hubAppender(new SocketHubAppender());
-            Pool p;
-            hubAppender->activateOptions(p);
-            hubAppender->close();
-        }
+		void testActivateClose()
+		{
+			SocketHubAppenderPtr hubAppender(new SocketHubAppender());
+			Pool p;
+			hubAppender->activateOptions(p);
+			hubAppender->close();
+		}
 
-        void testActivateSleepClose() {
-            SocketHubAppenderPtr hubAppender(new SocketHubAppender());
-            Pool p;
-            hubAppender->activateOptions(p);
-            Thread::sleep(1000);
-            hubAppender->close();
-        }
+		void testActivateSleepClose()
+		{
+			SocketHubAppenderPtr hubAppender(new SocketHubAppender());
+			Pool p;
+			hubAppender->activateOptions(p);
+			Thread::sleep(1000);
+			hubAppender->close();
+		}
 
-        
-        void testActivateWriteClose() {
-            SocketHubAppenderPtr hubAppender(new SocketHubAppender());
-            Pool p;
-            hubAppender->activateOptions(p);
-            LoggerPtr root(Logger::getRootLogger());
-            root->addAppender(hubAppender);
-            for(int i = 0; i < 50; i++) {
-                LOG4CXX_INFO(root, "Hello, World " << i);
-            }
-            hubAppender->close();
-        }
+
+		void testActivateWriteClose()
+		{
+			SocketHubAppenderPtr hubAppender(new SocketHubAppender());
+			Pool p;
+			hubAppender->activateOptions(p);
+			LoggerPtr root(Logger::getRootLogger());
+			root->addAppender(hubAppender);
+
+			for (int i = 0; i < 50; i++)
+			{
+				LOG4CXX_INFO(root, "Hello, World " << i);
+			}
+
+			hubAppender->close();
+		}
 };
 
 LOGUNIT_TEST_SUITE_REGISTRATION(SocketHubAppenderTestCase);
diff --git a/src/test/cpp/net/socketserverstarter.cpp b/src/test/cpp/net/socketserverstarter.cpp
index a8c2ae0..923459f 100644
--- a/src/test/cpp/net/socketserverstarter.cpp
+++ b/src/test/cpp/net/socketserverstarter.cpp
@@ -29,136 +29,174 @@
 
 LOGUNIT_CLASS(SocketServerStarter)
 {
-   LOGUNIT_TEST_SUITE(SocketServerStarter);
-      LOGUNIT_TEST(startServer);
-   LOGUNIT_TEST_SUITE_END();
+	LOGUNIT_TEST_SUITE(SocketServerStarter);
+	LOGUNIT_TEST(startServer);
+	LOGUNIT_TEST_SUITE_END();
 
 public:
-   void setUp()
-   {
-   }
+	void setUp()
+	{
+	}
 
-   void tearDown()
-   {
-   }
+	void tearDown()
+	{
+	}
 
-   void startServer()
-   {
-     helpers::Pool p;
-     apr_pool_t* pool = p.getAPRPool();
-     char* cmd = NULL;
-     apr_status_t stat = apr_env_get(&cmd, "SOCKET_SERVER_COMMAND", pool);
-     char* param_file = NULL;
-     stat = apr_env_get(&param_file, "SOCKET_SERVER_PARAMETER_FILE", pool);
+	void startServer()
+	{
+		helpers::Pool p;
+		apr_pool_t* pool = p.getAPRPool();
+		char* cmd = NULL;
+		apr_status_t stat = apr_env_get(&cmd, "SOCKET_SERVER_COMMAND", pool);
+		char* param_file = NULL;
+		stat = apr_env_get(&param_file, "SOCKET_SERVER_PARAMETER_FILE", pool);
 
-     // prepare to launch the server
-     //
-     apr_proc_t server_pid;
-     apr_procattr_t* attr = NULL;
-     stat = apr_procattr_create(&attr, pool);
-     if (stat != APR_SUCCESS)
-         LOGUNIT_FAIL("apr_procattr_create failed");
-     stat = apr_procattr_io_set(attr, APR_NO_PIPE, APR_NO_PIPE, APR_NO_PIPE);
-     if (stat != APR_SUCCESS)
-         LOGUNIT_FAIL("apr_procattr_io_set failed");
+		// prepare to launch the server
+		//
+		apr_proc_t server_pid;
+		apr_procattr_t* attr = NULL;
+		stat = apr_procattr_create(&attr, pool);
 
-     //fprintf(stdout, "SOCKET_SERVER_COMMAND=%s\n", cmd);
-     stat = apr_procattr_cmdtype_set(attr, APR_PROGRAM);
-     if (stat != APR_SUCCESS)
-         LOGUNIT_FAIL("apr_procattr_cmdtype_set failed");
+		if (stat != APR_SUCCESS)
+		{
+			LOGUNIT_FAIL("apr_procattr_create failed");
+		}
 
-     if (cmd && *cmd)
-     {
-          // convert the space separated cmd string to the argument list
-          //
-          static const int MaxArgumentCount = 14;
-          char** argv = (char**)apr_palloc(pool, (MaxArgumentCount + 1) * sizeof(*argv));
-          char* pcmd = apr_pstrdup(pool, cmd);
-          int i = 0;
-          for (; i < MaxArgumentCount && pcmd && *pcmd; ++i)
-          {
-              char separ = ' ';
-              while(separ == *pcmd)
-              {
-                *pcmd = 0;
-                ++pcmd;
-              }
-              if ('"' == *pcmd || '\'' == *pcmd)
-              {
-                 separ = *pcmd;
-                 ++pcmd;
-              }
-              argv[i] = pcmd;
-              if (NULL != (pcmd = strchr(pcmd, separ)))
-              {
-                *pcmd = 0;
-                ++pcmd;
-                while(' ' == *pcmd)
-                {
-                  *pcmd = 0;
-                  ++pcmd;
-                }
-              }
-          }
-          argv[i] = 0;
-          stat = apr_proc_create(&server_pid, argv[0], argv, NULL, attr, pool);
+		stat = apr_procattr_io_set(attr, APR_NO_PIPE, APR_NO_PIPE, APR_NO_PIPE);
 
+		if (stat != APR_SUCCESS)
+		{
+			LOGUNIT_FAIL("apr_procattr_io_set failed");
+		}
 
-          if (stat == APR_SUCCESS) // Allow server time to load
-              apr_sleep(1000000); // 1 seconds
-          else
-              fprintf(stderr, "apr_proc_create failed to start %s\n", argv[0]);
-     }
-     else if (param_file && *param_file)
-     {
-          // Build the argument list from param_file
-          //
-          //fprintf(stderr, "Processing: %s\n", param_file);
-          std::ifstream in(param_file);
-          std::vector<std::string> params;
-          while (in)
-          {
-              params.push_back(std::string());
-              std::string& line = params.back();
-              std::getline(in, line);
-              while (!line.empty() && (' ' == line[0] || '\t' == line[0]))
-                 line.erase(0, 1);
-              while (!line.empty() && (' ' == line[line.size() - 1] || '\t' == line[line.size() - 1]))
-                 line.erase(line.size() - 1, 1);
-              if (line.empty())
-                  params.pop_back();
-          }
-          const char** argv = (const char**)apr_palloc(pool, (params.size() + 1) * sizeof(*argv));
-          int i = 0;
-          for (; i < params.size(); ++i)
-          {
-              argv[i] = params[i].c_str();
-              //fprintf(stderr, "argv[%i]: %s\n", i, argv[i]);
-          }
-          argv[i] = 0;
-          stat = apr_proc_create(&server_pid, argv[0], argv, NULL, attr, pool);
+		//fprintf(stdout, "SOCKET_SERVER_COMMAND=%s\n", cmd);
+		stat = apr_procattr_cmdtype_set(attr, APR_PROGRAM);
 
+		if (stat != APR_SUCCESS)
+		{
+			LOGUNIT_FAIL("apr_procattr_cmdtype_set failed");
+		}
 
-          if (stat == APR_SUCCESS) // Allow server time to load
-              apr_sleep(1000000); // 1 seconds
-          else
-              fprintf(stderr, "apr_proc_create failed to start %s\n", argv[0]);
-      }
-      else
-      {
-          fputs("Either:\n", stderr);
-          fputs(" The environment variable SOCKET_SERVER_COMMAND"
-               " must contain the server process path"
-               " followed by space separated command arguments\n", stderr);
-          fputs("Or:\n", stderr);
-          fputs(" The file named in the environment variable SOCKET_SERVER_PARAMETER_FILE"
-               " must contain a line per argument starting with the server process path"
-               " followed by lines containing command arguments\n", stderr);
-          stat = -1;
-      }
+		if (!(cmd && *cmd) && !(param_file && *param_file))
+		{
+			fputs("Either:\n", stderr);
+			fputs(" The environment variable SOCKET_SERVER_COMMAND"
+				" must contain the server process path"
+				" followed by space separated command arguments\n", stderr);
+			fputs("Or:\n", stderr);
+			fputs(" The file named in the environment variable SOCKET_SERVER_PARAMETER_FILE"
+				" must contain a line per argument starting with the server process path"
+				" followed by lines containing command arguments\n", stderr);
+			LOGUNIT_FAIL("Neither SOCKET_SERVER_COMMAND nor SOCKET_SERVER_PARAMETER_FILE available.");
+		}
 
-      LOGUNIT_ASSERT(stat == APR_SUCCESS);
-   }
+		if (cmd && *cmd)
+		{
+			// convert the space separated cmd string to the argument list
+			//
+			static const int MaxArgumentCount = 14;
+			char** argv = (char**)apr_palloc(pool, (MaxArgumentCount + 1) * sizeof(*argv));
+			char* pcmd = apr_pstrdup(pool, cmd);
+			int i = 0;
+
+			for (; i < MaxArgumentCount && pcmd && *pcmd; ++i)
+			{
+				char separ = ' ';
+
+				while (separ == *pcmd)
+				{
+					*pcmd = 0;
+					++pcmd;
+				}
+
+				if ('"' == *pcmd || '\'' == *pcmd)
+				{
+					separ = *pcmd;
+					++pcmd;
+				}
+
+				argv[i] = pcmd;
+
+				if (NULL != (pcmd = strchr(pcmd, separ)))
+				{
+					*pcmd = 0;
+					++pcmd;
+
+					while (' ' == *pcmd)
+					{
+						*pcmd = 0;
+						++pcmd;
+					}
+				}
+			}
+
+			argv[i] = 0;
+			stat = apr_proc_create(&server_pid, argv[0], argv, NULL, attr, pool);
+
+			if (stat == APR_SUCCESS) // Allow server time to load
+			{
+				apr_sleep(1000000);    // 1 seconds
+			}
+			else
+			{
+				fprintf(stderr, "apr_proc_create failed to start %s\n", argv[0]);
+			}
+		}
+
+		if (param_file && *param_file)
+		{
+			// Build the argument list from param_file
+			//
+			//fprintf(stderr, "Processing: %s\n", param_file);
+			std::ifstream in(param_file);
+			std::vector<std::string> params;
+
+			while (in)
+			{
+				params.push_back(std::string());
+				std::string& line = params.back();
+				std::getline(in, line);
+
+				while (!line.empty() && (' ' == line[0] || '\t' == line[0]))
+				{
+					line.erase(0, 1);
+				}
+
+				while (!line.empty() && (' ' == line[line.size() - 1] || '\t' == line[line.size() - 1]))
+				{
+					line.erase(line.size() - 1, 1);
+				}
+
+				if (line.empty())
+				{
+					params.pop_back();
+				}
+			}
+
+			const char** argv = (const char**)apr_palloc(pool, (params.size() + 1) * sizeof(*argv));
+			int i = 0;
+
+			for (; i < params.size(); ++i)
+			{
+				argv[i] = params[i].c_str();
+				//fprintf(stderr, "argv[%i]: %s\n", i, argv[i]);
+			}
+
+			argv[i] = 0;
+			stat = apr_proc_create(&server_pid, argv[0], argv, NULL, attr, pool);
+
+			if (stat == APR_SUCCESS) // Allow server time to load
+			{
+				apr_sleep(1000000);    // 1 seconds
+			}
+			else
+			{
+				fprintf(stderr, "apr_proc_create failed to start %s\n", argv[0]);
+			}
+		}
+
+		LOGUNIT_ASSERT(stat == APR_SUCCESS);
+	}
 };
 
 
diff --git a/src/test/cpp/net/socketservertestcase.cpp b/src/test/cpp/net/socketservertestcase.cpp
index d46b378..fb31bd0 100644
--- a/src/test/cpp/net/socketservertestcase.cpp
+++ b/src/test/cpp/net/socketservertestcase.cpp
@@ -40,11 +40,11 @@
 
 //Define INT64_C for compilers that don't have it
 #if (!defined(INT64_C))
-#define INT64_C(value)  value ## LL
+	#define INT64_C(value)  value ## LL
 #endif
 
 #if defined(WIN32) || defined(_WIN32)
-#include <windows.h>
+	#include <windows.h>
 #endif
 
 using namespace log4cxx;
@@ -55,423 +55,423 @@
 // %5p %x [%t] %c %m%n
 // DEBUG T1 [thread] org.apache.log4j.net.SocketAppenderTestCase Message 1
 #define PAT1 \
-        REGEX_STR("^(DEBUG| INFO| WARN|ERROR|FATAL|LETHAL) T1 \\[0x[0-9A-F]*]\\ ") \
-        REGEX_STR(".* Message [0-9]\\{1,2\\}")
+	REGEX_STR("^(DEBUG| INFO| WARN|ERROR|FATAL|LETHAL) T1 \\[0x[0-9A-F]*]\\ ") \
+	REGEX_STR(".* Message [0-9]\\{1,2\\}")
 
 // DEBUG T2 [thread] patternlayouttest.cpp(?) Message 1
 #define PAT2 \
-        REGEX_STR("^(DEBUG| INFO| WARN|ERROR|FATAL|LETHAL) T2 \\[0x[0-9A-F]*]\\ ") \
-        REGEX_STR(".*socketservertestcase.cpp\\([0-9]\\{1,4\\}\\) Message [0-9]\\{1,2\\}")
+	REGEX_STR("^(DEBUG| INFO| WARN|ERROR|FATAL|LETHAL) T2 \\[0x[0-9A-F]*]\\ ") \
+	REGEX_STR(".*socketservertestcase.cpp\\([0-9]\\{1,4\\}\\) Message [0-9]\\{1,2\\}")
 
 // DEBUG T3 [thread] patternlayouttest.cpp(?) Message 1
 #define PAT3 \
-        REGEX_STR("^(DEBUG| INFO| WARN|ERROR|FATAL|LETHAL) T3 \\[0x[0-9A-F]*]\\ ") \
-        REGEX_STR(".*socketservertestcase.cpp\\([0-9]\\{1,4\\}\\) Message [0-9]\\{1,2\\}")
+	REGEX_STR("^(DEBUG| INFO| WARN|ERROR|FATAL|LETHAL) T3 \\[0x[0-9A-F]*]\\ ") \
+	REGEX_STR(".*socketservertestcase.cpp\\([0-9]\\{1,4\\}\\) Message [0-9]\\{1,2\\}")
 
 // DEBUG some T4 MDC-TEST4 [thread] SocketAppenderTestCase - Message 1
 // DEBUG some T4 MDC-TEST4 [thread] SocketAppenderTestCase - Message 1
 #define PAT4 \
-        REGEX_STR("^(DEBUG| INFO| WARN|ERROR|FATAL|LETHAL) some T4 MDC-TEST4 \\[0x[0-9A-F]*]\\") \
-        REGEX_STR(" (root|SocketServerTestCase) - Message [0-9]\\{1,2\\}")
+	REGEX_STR("^(DEBUG| INFO| WARN|ERROR|FATAL|LETHAL) some T4 MDC-TEST4 \\[0x[0-9A-F]*]\\") \
+	REGEX_STR(" (root|SocketServerTestCase) - Message [0-9]\\{1,2\\}")
 #define PAT5 \
-        REGEX_STR("^(DEBUG| INFO| WARN|ERROR|FATAL|LETHAL) some5 T5 MDC-TEST5 \\[0x[0-9A-F]*]\\") \
-        REGEX_STR(" (root|SocketServerTestCase) - Message [0-9]\\{1,2\\}")
+	REGEX_STR("^(DEBUG| INFO| WARN|ERROR|FATAL|LETHAL) some5 T5 MDC-TEST5 \\[0x[0-9A-F]*]\\") \
+	REGEX_STR(" (root|SocketServerTestCase) - Message [0-9]\\{1,2\\}")
 #define PAT6 \
-        REGEX_STR("^(DEBUG| INFO| WARN|ERROR|FATAL|LETHAL) some6 T6 client-test6 MDC-TEST6") \
-        REGEX_STR(" \\[0x[0-9A-F]*]\\ (root|SocketServerTestCase) - Message [0-9]\\{1,2\\}")
+	REGEX_STR("^(DEBUG| INFO| WARN|ERROR|FATAL|LETHAL) some6 T6 client-test6 MDC-TEST6") \
+	REGEX_STR(" \\[0x[0-9A-F]*]\\ (root|SocketServerTestCase) - Message [0-9]\\{1,2\\}")
 #define PAT7 \
-        REGEX_STR("^(DEBUG| INFO| WARN|ERROR|FATAL|LETHAL) some7 T7 client-test7 MDC-TEST7") \
-        REGEX_STR(" \\[0x[0-9A-F]*]\\ (root|SocketServerTestCase) - Message [0-9]\\{1,2\\}")
+	REGEX_STR("^(DEBUG| INFO| WARN|ERROR|FATAL|LETHAL) some7 T7 client-test7 MDC-TEST7") \
+	REGEX_STR(" \\[0x[0-9A-F]*]\\ (root|SocketServerTestCase) - Message [0-9]\\{1,2\\}")
 
 // DEBUG some8 T8 shortSocketServer MDC-TEST7 [thread] SocketServerTestCase - Message 1
 #define PAT8 \
-        REGEX_STR("^(DEBUG| INFO| WARN|ERROR|FATAL|LETHAL) some8 T8 shortSocketServer") \
-        REGEX_STR(" MDC-TEST8 \\[0x[0-9A-F]*]\\ (root|SocketServerTestCase) - Message [0-9]\\{1,2\\}")
+	REGEX_STR("^(DEBUG| INFO| WARN|ERROR|FATAL|LETHAL) some8 T8 shortSocketServer") \
+	REGEX_STR(" MDC-TEST8 \\[0x[0-9A-F]*]\\ (root|SocketServerTestCase) - Message [0-9]\\{1,2\\}")
 
 
 
 /**
  *  This test checks receipt of SocketAppender messages by the ShortSocketServer
  *  class from log4j.  That class must be started externally to this class
- *  for this test to succeed. 
+ *  for this test to succeed.
  */
 LOGUNIT_CLASS(SocketServerTestCase)
 {
-        LOGUNIT_TEST_SUITE(SocketServerTestCase);
-                LOGUNIT_TEST(test1);
-                LOGUNIT_TEST(test2);
-                LOGUNIT_TEST(test3);
-                LOGUNIT_TEST(test4);
-                LOGUNIT_TEST(test5);
-                LOGUNIT_TEST(test6);
-                LOGUNIT_TEST(test7);
-                LOGUNIT_TEST(test8);
-        LOGUNIT_TEST_SUITE_END();
+	LOGUNIT_TEST_SUITE(SocketServerTestCase);
+	LOGUNIT_TEST(test1);
+	LOGUNIT_TEST(test2);
+	LOGUNIT_TEST(test3);
+	LOGUNIT_TEST(test4);
+	LOGUNIT_TEST(test5);
+	LOGUNIT_TEST(test6);
+	LOGUNIT_TEST(test7);
+	LOGUNIT_TEST(test8);
+	LOGUNIT_TEST_SUITE_END();
 
-        SocketAppenderPtr socketAppender;
-        LoggerPtr logger;
-        LoggerPtr root;
+	SocketAppenderPtr socketAppender;
+	LoggerPtr logger;
+	LoggerPtr root;
 
-        class LineNumberFilter : public Filter {
-        public:
-                LineNumberFilter() {
-                    patterns.push_back(PatternReplacement("cpp:[0-9]*", "cpp:XXX"));
-                }
-        };
+	class LineNumberFilter : public Filter
+	{
+		public:
+			LineNumberFilter()
+			{
+				patterns.push_back(PatternReplacement("cpp:[0-9]*", "cpp:XXX"));
+			}
+	};
 
 public:
-        void setUp()
-        {
-                logger = Logger::getLogger(LOG4CXX_STR("org.apache.log4j.net.SocketServerTestCase"));
-                root = Logger::getRootLogger();
-        }
+	void setUp()
+	{
+		logger = Logger::getLogger(LOG4CXX_STR("org.apache.log4j.net.SocketServerTestCase"));
+		root = Logger::getRootLogger();
+	}
 
-        void tearDown()
-        {
-                socketAppender = 0;
-                root->getLoggerRepository()->resetConfiguration();
-                logger = 0;
-                root = 0;
-        }
+	void tearDown()
+	{
+		socketAppender = 0;
+		root->getLoggerRepository()->resetConfiguration();
+		logger = 0;
+		root = 0;
+	}
 
-        /**
-        The pattern on the server side: %5p %x [%t] %c %m%n.
+	/**
+	We are testing NDC functionality across the wire.
+	*/
+	void test1()
+	{
+		SocketAppenderPtr socketAppender1 =
+			new SocketAppender(LOG4CXX_STR("localhost"), PORT);
+		root->addAppender(socketAppender1);
+		common("test1", LOG4CXX_STR("T1"), LOG4CXX_STR("key1"), LOG4CXX_STR("MDC-TEST1"));
+		delay(1);
 
-        We are testing NDC functionality across the wire.
-        */
-        void test1()
-        {
-                SocketAppenderPtr socketAppender1 =
-                        new SocketAppender(LOG4CXX_STR("localhost"), PORT);
-                root->addAppender(socketAppender1);
-                common("test1", LOG4CXX_STR("T1"), LOG4CXX_STR("key1"), LOG4CXX_STR("MDC-TEST1"));
-                delay(1);
+		ControlFilter cf;
+		cf << PAT1;
 
-                ControlFilter cf;
-                cf << PAT1;
+		ThreadFilter threadFilter;
 
-                ThreadFilter threadFilter;
+		std::vector<Filter*> filters;
+		filters.push_back(&cf);
+		filters.push_back(&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;
+		}
 
-                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.1")));
+	}
 
-                LOGUNIT_ASSERT(Compare::compare(FILTERED, LOG4CXX_FILE("witness/socketServer.1")));
-        }
+	void test2()
+	{
+		SocketAppenderPtr socketAppender1 =
+			new SocketAppender(LOG4CXX_STR("localhost"), PORT);
+		root->addAppender(socketAppender1);
+		common("test2", LOG4CXX_STR("T2"), LOG4CXX_STR("key2"), LOG4CXX_STR("MDC-TEST2"));
+		delay(1);
 
-        void test2()
-        {
-                SocketAppenderPtr socketAppender1 =
-                        new SocketAppender(LOG4CXX_STR("localhost"), PORT);
-                root->addAppender(socketAppender1);
-                common("test2", LOG4CXX_STR("T2"), LOG4CXX_STR("key2"), LOG4CXX_STR("MDC-TEST2"));
-                delay(1);
+		ControlFilter cf;
+		cf << PAT2;
 
-                ControlFilter cf;
-                cf << PAT2;
+		ThreadFilter threadFilter;
+		LineNumberFilter lineNumberFilter;
+		LogString thisFile;
+		FilenameFilter filenameFilter(__FILE__, "socketservertestcase.cpp");
 
-                ThreadFilter threadFilter;
-                LineNumberFilter lineNumberFilter;
-                LogString thisFile;
-                FilenameFilter filenameFilter(__FILE__, "socketservertestcase.cpp");
+		std::vector<Filter*> filters;
+		filters.push_back(&filenameFilter);
+		filters.push_back(&cf);
+		filters.push_back(&threadFilter);
+		filters.push_back(&lineNumberFilter);
 
-                std::vector<Filter *> filters;
-                filters.push_back(&filenameFilter);
-                filters.push_back(&cf);
-                filters.push_back(&threadFilter);
-                filters.push_back(&lineNumberFilter);
+		try
+		{
+			Transformer::transform(TEMP, FILTERED, filters);
+		}
+		catch (UnexpectedFormatException& e)
+		{
+			std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
+			throw;
+		}
 
-                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.2")));
+	}
 
-                LOGUNIT_ASSERT(Compare::compare(FILTERED, LOG4CXX_FILE("witness/socketServer.2")));
-        }
+	void test3()
+	{
+		SocketAppenderPtr socketAppender1 =
+			new SocketAppender(LOG4CXX_STR("localhost"), PORT);
+		root->addAppender(socketAppender1);
+		common("test3", LOG4CXX_STR("T3"), LOG4CXX_STR("key3"), LOG4CXX_STR("MDC-TEST3"));
+		delay(1);
 
-        void test3()
-        {
-                SocketAppenderPtr socketAppender1 =
-                        new SocketAppender(LOG4CXX_STR("localhost"), PORT);
-                root->addAppender(socketAppender1);
-                common("test3", LOG4CXX_STR("T3"), LOG4CXX_STR("key3"), LOG4CXX_STR("MDC-TEST3"));
-                delay(1);
+		ControlFilter cf;
+		cf << PAT3;
 
-                ControlFilter cf;
-                cf << PAT3;
+		ThreadFilter threadFilter;
+		LineNumberFilter lineNumberFilter;
+		LogString thisFile;
+		FilenameFilter filenameFilter(__FILE__, "socketservertestcase.cpp");
 
-                ThreadFilter threadFilter;
-                LineNumberFilter lineNumberFilter;
-                LogString thisFile;
-                FilenameFilter filenameFilter(__FILE__, "socketservertestcase.cpp");
+		std::vector<Filter*> filters;
+		filters.push_back(&filenameFilter);
+		filters.push_back(&cf);
+		filters.push_back(&threadFilter);
+		filters.push_back(&lineNumberFilter);
 
-                std::vector<Filter *> filters;
-                filters.push_back(&filenameFilter);
-                filters.push_back(&cf);
-                filters.push_back(&threadFilter);
-                filters.push_back(&lineNumberFilter);
+		try
+		{
+			Transformer::transform(TEMP, FILTERED, filters);
+		}
+		catch (UnexpectedFormatException& e)
+		{
+			std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
+			throw;
+		}
 
-                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.3")));
+	}
 
-                LOGUNIT_ASSERT(Compare::compare(FILTERED, LOG4CXX_FILE("witness/socketServer.3")));
-        }
+	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);
 
-        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;
 
-                ControlFilter cf;
-                cf << PAT4;
+		ThreadFilter threadFilter;
 
-                ThreadFilter threadFilter;
+		std::vector<Filter*> filters;
+		filters.push_back(&cf);
+		filters.push_back(&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;
+		}
 
-                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")));
+	}
 
-                LOGUNIT_ASSERT(Compare::compare(FILTERED, LOG4CXX_FILE("witness/socketServer.4")));
-        }
+	void test5()
+	{
+		SocketAppenderPtr socketAppender1 =
+			new SocketAppender(LOG4CXX_STR("localhost"), PORT);
+		AsyncAppenderPtr asyncAppender = new AsyncAppender();
 
-        void test5()
-        {
-                SocketAppenderPtr socketAppender1 =
-                        new SocketAppender(LOG4CXX_STR("localhost"), PORT);
-                AsyncAppenderPtr asyncAppender = new AsyncAppender();
+		root->addAppender(socketAppender1);
+		root->addAppender(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);
 
-                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")));
+	}
 
-                ControlFilter cf;
-                cf << PAT5;
+	void test6()
+	{
+		SocketAppenderPtr socketAppender1 =
+			new SocketAppender(LOG4CXX_STR("localhost"), PORT);
+		AsyncAppenderPtr asyncAppender = new AsyncAppender();
 
-                ThreadFilter threadFilter;
+		root->addAppender(socketAppender1);
+		root->addAppender(asyncAppender);
 
-                std::vector<Filter *> filters;
-                filters.push_back(&cf);
-                filters.push_back(&threadFilter);
+		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);
 
-                try
-                {
-                        Transformer::transform(TEMP, FILTERED, filters);
-                }
-                catch(UnexpectedFormatException& e)
-                {
-                        std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
-                        throw;
-                }
+		ControlFilter cf;
+		cf << PAT6;
 
-                LOGUNIT_ASSERT(Compare::compare(FILTERED, LOG4CXX_FILE("witness/socketServer.5")));
-        }
+		ThreadFilter threadFilter;
 
-        void test6()
-        {
-                SocketAppenderPtr socketAppender1 =
-                        new SocketAppender(LOG4CXX_STR("localhost"), PORT);
-                AsyncAppenderPtr asyncAppender = new AsyncAppender();
+		std::vector<Filter*> filters;
+		filters.push_back(&cf);
+		filters.push_back(&threadFilter);
 
-                root->addAppender(socketAppender1);
-                root->addAppender(asyncAppender);
+		try
+		{
+			Transformer::transform(TEMP, FILTERED, filters);
+		}
+		catch (UnexpectedFormatException& e)
+		{
+			std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
+			throw;
+		}
 
-                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);
+		LOGUNIT_ASSERT(Compare::compare(FILTERED, LOG4CXX_FILE("witness/socketServer.6")));
+	}
 
-                ControlFilter cf;
-                cf << PAT6;
+	void test7()
+	{
+		SocketAppenderPtr socketAppender1 =
+			new SocketAppender(LOG4CXX_STR("localhost"), PORT);
+		AsyncAppenderPtr asyncAppender = new AsyncAppender();
 
-                ThreadFilter threadFilter;
+		root->addAppender(socketAppender1);
+		root->addAppender(asyncAppender);
 
-                std::vector<Filter *> filters;
-                filters.push_back(&cf);
-                filters.push_back(&threadFilter);
+		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);
 
-                try
-                {
-                        Transformer::transform(TEMP, FILTERED, filters);
-                }
-                catch(UnexpectedFormatException& e)
-                {
-                        std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
-                        throw;
-                }
+		ControlFilter cf;
+		cf << PAT7;
 
-                LOGUNIT_ASSERT(Compare::compare(FILTERED, LOG4CXX_FILE("witness/socketServer.6")));
-        }
+		ThreadFilter threadFilter;
 
-        void test7()
-        {
-                SocketAppenderPtr socketAppender1 =
-                        new SocketAppender(LOG4CXX_STR("localhost"), PORT);
-                AsyncAppenderPtr asyncAppender = new AsyncAppender();
+		std::vector<Filter*> filters;
+		filters.push_back(&cf);
+		filters.push_back(&threadFilter);
 
-                root->addAppender(socketAppender1);
-                root->addAppender(asyncAppender);
+		try
+		{
+			Transformer::transform(TEMP, FILTERED, filters);
+		}
+		catch (UnexpectedFormatException& e)
+		{
+			std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
+			throw;
+		}
 
-                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);
+		LOGUNIT_ASSERT(Compare::compare(FILTERED, LOG4CXX_FILE("witness/socketServer.7")));
+	}
 
-                ControlFilter cf;
-                cf << PAT7;
+	void test8()
+	{
+		SocketAppenderPtr socketAppender1 =
+			new SocketAppender(LOG4CXX_STR("localhost"), PORT);
 
-                ThreadFilter threadFilter;
+		root->addAppender(socketAppender1);
 
-                std::vector<Filter *> filters;
-                filters.push_back(&cf);
-                filters.push_back(&threadFilter);
+		NDC::push(LOG4CXX_TEST_STR("some8"));
+		common("test8", LOG4CXX_STR("T8"), LOG4CXX_STR("key8"), LOG4CXX_STR("MDC-TEST8"));
+		NDC::pop();
+		delay(2);
 
-                try
-                {
-                        Transformer::transform(TEMP, FILTERED, filters);
-                }
-                catch(UnexpectedFormatException& e)
-                {
-                        std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
-                        throw;
-                }
+		ControlFilter cf;
+		cf << PAT8;
 
-                LOGUNIT_ASSERT(Compare::compare(FILTERED, LOG4CXX_FILE("witness/socketServer.7")));
-        }
+		ThreadFilter threadFilter;
 
-        void test8()
-        {
-                SocketAppenderPtr socketAppender1 =
-                        new SocketAppender(LOG4CXX_STR("localhost"), PORT);
+		std::vector<Filter*> filters;
+		filters.push_back(&cf);
+		filters.push_back(&threadFilter);
 
-                root->addAppender(socketAppender1);
+		try
+		{
+			Transformer::transform(TEMP, FILTERED, filters);
+		}
+		catch (UnexpectedFormatException& e)
+		{
+			std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
+			throw;
+		}
 
-                NDC::push(LOG4CXX_TEST_STR("some8"));
-                common("test8", LOG4CXX_STR("T8"), LOG4CXX_STR("key8"), LOG4CXX_STR("MDC-TEST8"));
-                NDC::pop();
-                delay(2);
+		LOGUNIT_ASSERT(Compare::compare(FILTERED, LOG4CXX_FILE("witness/socketServer.8")));
+	}
 
-                ControlFilter cf;
-                cf << PAT8;
+	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);
 
-                ThreadFilter threadFilter;
+		logger->setLevel(Level::getDebug());
+		root->setLevel(Level::getDebug());
 
-                std::vector<Filter *> filters;
-                filters.push_back(&cf);
-                filters.push_back(&threadFilter);
+		LOG4CXX_TRACE(logger, "Message " << i);
+		i++;
 
-                try
-                {
-                        Transformer::transform(TEMP, FILTERED, filters);
-                }
-                catch(UnexpectedFormatException& e)
-                {
-                        std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
-                        throw;
-                }
+		logger->setLevel(Level::getTrace());
+		root->setLevel(Level::getTrace());
 
-                LOGUNIT_ASSERT(Compare::compare(FILTERED, LOG4CXX_FILE("witness/socketServer.8")));
-        }
+		LOG4CXX_TRACE(logger, "Message " << ++i);
+		LOG4CXX_TRACE(root, "Message " << ++i);
 
-        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_DEBUG(logger, "Message " << ++i);
+		LOG4CXX_DEBUG(root, "Message " << ++i);
 
-                LOG4CXX_TRACE(logger, "Message " << i);
-                i++;
+		LOG4CXX_INFO(logger, "Message "  << ++i);
+		LOG4CXX_WARN(logger, "Message " << ++i);
+		LOG4CXX_FATAL(logger, "Message " << ++i); //5
 
-                logger->setLevel(Level::getTrace());
-                root->setLevel(Level::getTrace());
-                
-                LOG4CXX_TRACE(logger, "Message " << ++i);
-                LOG4CXX_TRACE(root, "Message " << ++i);
+		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);
-                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);
+		LOG4CXX_DEBUG(logger, "Message " << ++i << exceptionMsg);
+		LOG4CXX_ERROR(root, "Message " << ++i << exceptionMsg);
 
-                NDC::pop();
-                MDC::remove(key);
-        }
+		NDC::pop();
+		MDC::remove(key);
+	}
 
-        void delay(int secs)
-        {
-                apr_sleep(APR_USEC_PER_SEC * secs);
-        }
+	void delay(int secs)
+	{
+		apr_sleep(APR_USEC_PER_SEC * secs);
+	}
 
-        private:
-        static const File TEMP;
-        static const File FILTERED;
+private:
+	static const File TEMP;
+	static const File FILTERED;
 };
 
 const File SocketServerTestCase::TEMP("output/temp");
diff --git a/src/test/cpp/net/socketservertestcase.h b/src/test/cpp/net/socketservertestcase.h
index ae285d9..9dec038 100644
--- a/src/test/cpp/net/socketservertestcase.h
+++ b/src/test/cpp/net/socketservertestcase.h
@@ -5,16 +5,16 @@
  * 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.
  */
- 
+
 #ifndef _LOG4CXX_NET_SOCKETSERVER_TESTCASE_H
 #define _LOG4CXX_NET_SOCKETSERVER_TESTCASE_H
 
diff --git a/src/test/cpp/net/syslogappendertestcase.cpp b/src/test/cpp/net/syslogappendertestcase.cpp
index b2b723c..8470548 100644
--- a/src/test/cpp/net/syslogappendertestcase.cpp
+++ b/src/test/cpp/net/syslogappendertestcase.cpp
@@ -27,21 +27,22 @@
  */
 class SyslogAppenderTestCase : public AppenderSkeletonTestCase
 {
-   LOGUNIT_TEST_SUITE(SyslogAppenderTestCase);
-                //
-                //    tests inherited from AppenderSkeletonTestCase
-                //
-                LOGUNIT_TEST(testDefaultThreshold);
-                LOGUNIT_TEST(testSetOptionThreshold);
+		LOGUNIT_TEST_SUITE(SyslogAppenderTestCase);
+		//
+		//    tests inherited from AppenderSkeletonTestCase
+		//
+		LOGUNIT_TEST(testDefaultThreshold);
+		LOGUNIT_TEST(testSetOptionThreshold);
 
-   LOGUNIT_TEST_SUITE_END();
+		LOGUNIT_TEST_SUITE_END();
 
 
-public:
+	public:
 
-        AppenderSkeleton* createAppenderSkeleton() const {
-          return new log4cxx::net::SyslogAppender();
-        }
+		AppenderSkeleton* createAppenderSkeleton() const
+		{
+			return new log4cxx::net::SyslogAppender();
+		}
 };
 
 LOGUNIT_TEST_SUITE_REGISTRATION(SyslogAppenderTestCase);
diff --git a/src/test/cpp/net/telnetappendertestcase.cpp b/src/test/cpp/net/telnetappendertestcase.cpp
index 394571b..8cde17f 100644
--- a/src/test/cpp/net/telnetappendertestcase.cpp
+++ b/src/test/cpp/net/telnetappendertestcase.cpp
@@ -31,58 +31,65 @@
  */
 class TelnetAppenderTestCase : public AppenderSkeletonTestCase
 {
-   LOGUNIT_TEST_SUITE(TelnetAppenderTestCase);
-                //
-                //    tests inherited from AppenderSkeletonTestCase
-                //
-                LOGUNIT_TEST(testDefaultThreshold);
-                LOGUNIT_TEST(testSetOptionThreshold);
-                LOGUNIT_TEST(testActivateClose);
-                LOGUNIT_TEST(testActivateSleepClose);
-                LOGUNIT_TEST(testActivateWriteClose);
+		LOGUNIT_TEST_SUITE(TelnetAppenderTestCase);
+		//
+		//    tests inherited from AppenderSkeletonTestCase
+		//
+		LOGUNIT_TEST(testDefaultThreshold);
+		LOGUNIT_TEST(testSetOptionThreshold);
+		LOGUNIT_TEST(testActivateClose);
+		LOGUNIT_TEST(testActivateSleepClose);
+		LOGUNIT_TEST(testActivateWriteClose);
 
-   LOGUNIT_TEST_SUITE_END();
+		LOGUNIT_TEST_SUITE_END();
 
-   enum { TEST_PORT = 1723 };
+		enum { TEST_PORT = 1723 };
 
-public:
+	public:
 
-        AppenderSkeleton* createAppenderSkeleton() const {
-          return new log4cxx::net::TelnetAppender();
-        }
-        
-        void testActivateClose() {
-            TelnetAppenderPtr appender(new TelnetAppender());
-            appender->setLayout(new TTCCLayout());
-            appender->setPort(TEST_PORT);
-            Pool p;
-            appender->activateOptions(p);
-            appender->close();
-        }
+		AppenderSkeleton* createAppenderSkeleton() const
+		{
+			return new log4cxx::net::TelnetAppender();
+		}
 
-        void testActivateSleepClose() {
-            TelnetAppenderPtr appender(new TelnetAppender());
-            appender->setLayout(new TTCCLayout());
-            appender->setPort(TEST_PORT);
-            Pool p;
-            appender->activateOptions(p);
-            Thread::sleep(1000);
-            appender->close();
-        }
+		void testActivateClose()
+		{
+			TelnetAppenderPtr appender(new TelnetAppender());
+			appender->setLayout(new TTCCLayout());
+			appender->setPort(TEST_PORT);
+			Pool p;
+			appender->activateOptions(p);
+			appender->close();
+		}
 
-        void testActivateWriteClose() {
-            TelnetAppenderPtr appender(new TelnetAppender());
-            appender->setLayout(new TTCCLayout());
-            appender->setPort(TEST_PORT);
-            Pool p;
-            appender->activateOptions(p);
-            LoggerPtr root(Logger::getRootLogger());
-            root->addAppender(appender);
-            for (int i = 0; i < 50; i++) {
-                LOG4CXX_INFO(root, "Hello, World " << i);
-            }
-            appender->close();
-        }
+		void testActivateSleepClose()
+		{
+			TelnetAppenderPtr appender(new TelnetAppender());
+			appender->setLayout(new TTCCLayout());
+			appender->setPort(TEST_PORT);
+			Pool p;
+			appender->activateOptions(p);
+			Thread::sleep(1000);
+			appender->close();
+		}
+
+		void testActivateWriteClose()
+		{
+			TelnetAppenderPtr appender(new TelnetAppender());
+			appender->setLayout(new TTCCLayout());
+			appender->setPort(TEST_PORT);
+			Pool p;
+			appender->activateOptions(p);
+			LoggerPtr root(Logger::getRootLogger());
+			root->addAppender(appender);
+
+			for (int i = 0; i < 50; i++)
+			{
+				LOG4CXX_INFO(root, "Hello, World " << i);
+			}
+
+			appender->close();
+		}
 
 };
 
diff --git a/src/test/cpp/net/xmlsocketappendertestcase.cpp b/src/test/cpp/net/xmlsocketappendertestcase.cpp
index 507f8d5..37ae2f1 100644
--- a/src/test/cpp/net/xmlsocketappendertestcase.cpp
+++ b/src/test/cpp/net/xmlsocketappendertestcase.cpp
@@ -28,21 +28,22 @@
  */
 class XMLSocketAppenderTestCase : public AppenderSkeletonTestCase
 {
-   LOGUNIT_TEST_SUITE(XMLSocketAppenderTestCase);
-                //
-                //    tests inherited from AppenderSkeletonTestCase
-                //
-                LOGUNIT_TEST(testDefaultThreshold);
-                LOGUNIT_TEST(testSetOptionThreshold);
+		LOGUNIT_TEST_SUITE(XMLSocketAppenderTestCase);
+		//
+		//    tests inherited from AppenderSkeletonTestCase
+		//
+		LOGUNIT_TEST(testDefaultThreshold);
+		LOGUNIT_TEST(testSetOptionThreshold);
 
-   LOGUNIT_TEST_SUITE_END();
+		LOGUNIT_TEST_SUITE_END();
 
 
-public:
+	public:
 
-        AppenderSkeleton* createAppenderSkeleton() const {
-          return new log4cxx::net::XMLSocketAppender();
-        }
+		AppenderSkeleton* createAppenderSkeleton() const
+		{
+			return new log4cxx::net::XMLSocketAppender();
+		}
 };
 
 LOGUNIT_TEST_SUITE_REGISTRATION(XMLSocketAppenderTestCase);
diff --git a/src/test/cpp/nt/nteventlogappendertestcase.cpp b/src/test/cpp/nt/nteventlogappendertestcase.cpp
index 5e8c6ff..b4b8211 100644
--- a/src/test/cpp/nt/nteventlogappendertestcase.cpp
+++ b/src/test/cpp/nt/nteventlogappendertestcase.cpp
@@ -36,62 +36,76 @@
  */
 class NTEventLogAppenderTestCase : public AppenderSkeletonTestCase
 {
-   LOGUNIT_TEST_SUITE(NTEventLogAppenderTestCase);
-                //
-                //    tests inherited from AppenderSkeletonTestCase
-                //
-                LOGUNIT_TEST(testDefaultThreshold);
-                LOGUNIT_TEST(testSetOptionThreshold);
-                LOGUNIT_TEST(testHelloWorld);
+		LOGUNIT_TEST_SUITE(NTEventLogAppenderTestCase);
+		//
+		//    tests inherited from AppenderSkeletonTestCase
+		//
+		LOGUNIT_TEST(testDefaultThreshold);
+		LOGUNIT_TEST(testSetOptionThreshold);
+		LOGUNIT_TEST(testHelloWorld);
 
-   LOGUNIT_TEST_SUITE_END();
+		LOGUNIT_TEST_SUITE_END();
 
 
-public:
+	public:
 
-        AppenderSkeleton* createAppenderSkeleton() const {
-          return new log4cxx::nt::NTEventLogAppender();
-        }
+		AppenderSkeleton* createAppenderSkeleton() const
+		{
+			return new log4cxx::nt::NTEventLogAppender();
+		}
 
-        void testHelloWorld() {
-           DWORD expectedId = 1;
-           HANDLE hEventLog = ::OpenEventLogW(NULL, L"log4cxx_test");
-           if (hEventLog != NULL) {
-               BOOL stat = GetNumberOfEventLogRecords(hEventLog, &expectedId);
-               DWORD oldest;
-               if(stat) stat = GetOldestEventLogRecord(hEventLog, &oldest);
-               CloseEventLog(hEventLog);
-               LOGUNIT_ASSERT(stat);
-               expectedId += oldest;
-           }
+		void testHelloWorld()
+		{
+			DWORD expectedId = 1;
+			HANDLE hEventLog = ::OpenEventLogW(NULL, L"log4cxx_test");
+
+			if (hEventLog != NULL)
+			{
+				BOOL stat = GetNumberOfEventLogRecords(hEventLog, &expectedId);
+				DWORD oldest;
+
+				if (stat)
+				{
+					stat = GetOldestEventLogRecord(hEventLog, &oldest);
+				}
+
+				CloseEventLog(hEventLog);
+				LOGUNIT_ASSERT(stat);
+				expectedId += oldest;
+			}
 
 
-            Pool p;
-            Date now;
-            DWORD expectedTime = now.getTime() / Date::getMicrosecondsPerSecond();
-            {
-                NTEventLogAppenderPtr appender(new NTEventLogAppender());
-                appender->setSource(LOG4CXX_STR("log4cxx_test"));
-                LayoutPtr layout(new PatternLayout(LOG4CXX_STR("%c - %m%n")));
-                appender->setLayout(layout);
-                appender->activateOptions(p);
+			Pool p;
+			Date now;
+			DWORD expectedTime = now.getTime() / Date::getMicrosecondsPerSecond();
+			{
+				NTEventLogAppenderPtr appender(new NTEventLogAppender());
+				appender->setSource(LOG4CXX_STR("log4cxx_test"));
+				LayoutPtr layout(new PatternLayout(LOG4CXX_STR("%c - %m%n")));
+				appender->setLayout(layout);
+				appender->activateOptions(p);
 
-                LoggingEventPtr event(new LoggingEvent(
-                    LOG4CXX_STR("org.foobar"), Level::getInfo(), LOG4CXX_STR("Hello,  World"), LOG4CXX_LOCATION));
-                appender->doAppend(event, p);
-            }
-            hEventLog = ::OpenEventLogW(NULL, L"log4cxx_test");
-            LOGUNIT_ASSERT(hEventLog != NULL);
-            DWORD actualId;
-            BOOL stat = GetNumberOfEventLogRecords(hEventLog, &actualId);
-            DWORD oldest;
-            if (stat) stat = GetOldestEventLogRecord(hEventLog, &oldest);
-            actualId += oldest;
-            actualId--;
-            CloseEventLog(hEventLog);
-            LOGUNIT_ASSERT(stat);
-            LOGUNIT_ASSERT_EQUAL(expectedId, actualId);
-        }
+				LoggingEventPtr event(new LoggingEvent(
+						LOG4CXX_STR("org.foobar"), Level::getInfo(), LOG4CXX_STR("Hello,  World"), LOG4CXX_LOCATION));
+				appender->doAppend(event, p);
+			}
+			hEventLog = ::OpenEventLogW(NULL, L"log4cxx_test");
+			LOGUNIT_ASSERT(hEventLog != NULL);
+			DWORD actualId;
+			BOOL stat = GetNumberOfEventLogRecords(hEventLog, &actualId);
+			DWORD oldest;
+
+			if (stat)
+			{
+				stat = GetOldestEventLogRecord(hEventLog, &oldest);
+			}
+
+			actualId += oldest;
+			actualId--;
+			CloseEventLog(hEventLog);
+			LOGUNIT_ASSERT(stat);
+			LOGUNIT_ASSERT_EQUAL(expectedId, actualId);
+		}
 };
 
 LOGUNIT_TEST_SUITE_REGISTRATION(NTEventLogAppenderTestCase);
diff --git a/src/test/cpp/pattern/num343patternconverter.cpp b/src/test/cpp/pattern/num343patternconverter.cpp
index fa756c5..f330930 100644
--- a/src/test/cpp/pattern/num343patternconverter.cpp
+++ b/src/test/cpp/pattern/num343patternconverter.cpp
@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 #if defined(_MSC_VER)
-#pragma warning ( disable: 4231 4251 4275 4786 )
+	#pragma warning ( disable: 4231 4251 4275 4786 )
 #endif
 
 #include <log4cxx/logstring.h>
@@ -29,20 +29,22 @@
 
 
 Num343PatternConverter::Num343PatternConverter() :
-   LoggingEventPatternConverter(LOG4CXX_STR("Num343"), LOG4CXX_STR("num343")) {
+	LoggingEventPatternConverter(LOG4CXX_STR("Num343"), LOG4CXX_STR("num343"))
+{
 }
 
 PatternConverterPtr Num343PatternConverter::newInstance(
-   const std::vector<LogString>&) {
-   return new Num343PatternConverter();
+	const std::vector<LogString>&)
+{
+	return new Num343PatternConverter();
 }
 
 
 void Num343PatternConverter::format(
-    const spi::LoggingEventPtr&,
-    LogString& sbuf,
-    Pool&) const
+	const spi::LoggingEventPtr&,
+	LogString& sbuf,
+	Pool&) const
 {
-        sbuf.append(LOG4CXX_STR("343"));
+	sbuf.append(LOG4CXX_STR("343"));
 }
 
diff --git a/src/test/cpp/pattern/num343patternconverter.h b/src/test/cpp/pattern/num343patternconverter.h
index 0e2f75b..ce3d81c 100644
--- a/src/test/cpp/pattern/num343patternconverter.h
+++ b/src/test/cpp/pattern/num343patternconverter.h
@@ -20,21 +20,22 @@
 
 namespace log4cxx
 {
-   namespace pattern {
-     class Num343PatternConverter : public LoggingEventPatternConverter
-     {
-     public:
-        DECLARE_LOG4CXX_OBJECT(Num343PatternConverter)
+namespace pattern
+{
+class Num343PatternConverter : public LoggingEventPatternConverter
+{
+	public:
+		DECLARE_LOG4CXX_OBJECT(Num343PatternConverter)
 
-       Num343PatternConverter();
-       static PatternConverterPtr newInstance(
-          const std::vector<LogString>& options);
+		Num343PatternConverter();
+		static PatternConverterPtr newInstance(
+			const std::vector<LogString>& options);
 
-     protected:
-          void format(
-              const log4cxx::spi::LoggingEventPtr& event,
-              LogString& toAppendTo,
-              log4cxx::helpers::Pool& pool) const;
-     };
-   }
+	protected:
+		void format(
+			const log4cxx::spi::LoggingEventPtr& event,
+			LogString& toAppendTo,
+			log4cxx::helpers::Pool& pool) const;
+};
+}
 }
diff --git a/src/test/cpp/pattern/patternparsertestcase.cpp b/src/test/cpp/pattern/patternparsertestcase.cpp
index f304252..f49e2a2 100644
--- a/src/test/cpp/pattern/patternparsertestcase.cpp
+++ b/src/test/cpp/pattern/patternparsertestcase.cpp
@@ -58,178 +58,190 @@
 using namespace log4cxx::pattern;
 
 #define RULES_PUT(spec, cls) \
-map.insert(PatternMap::value_type(LOG4CXX_STR(spec), (PatternConstructor) cls ::newInstance))
+	map.insert(PatternMap::value_type(LOG4CXX_STR(spec), (PatternConstructor) cls ::newInstance))
 
 
 LOGUNIT_CLASS(PatternParserTestCase)
 {
-   LOGUNIT_TEST_SUITE(PatternParserTestCase);
-      LOGUNIT_TEST(testNewWord);
-      LOGUNIT_TEST(testNewWord2);
-      LOGUNIT_TEST(testBogusWord1);
-      LOGUNIT_TEST(testBogusWord2);
-      LOGUNIT_TEST(testBasic1);
-      LOGUNIT_TEST(testBasic2);
-      LOGUNIT_TEST(testMultiOption);
-   LOGUNIT_TEST_SUITE_END();
+	LOGUNIT_TEST_SUITE(PatternParserTestCase);
+	LOGUNIT_TEST(testNewWord);
+	LOGUNIT_TEST(testNewWord2);
+	LOGUNIT_TEST(testBogusWord1);
+	LOGUNIT_TEST(testBogusWord2);
+	LOGUNIT_TEST(testBasic1);
+	LOGUNIT_TEST(testBasic2);
+	LOGUNIT_TEST(testMultiOption);
+	LOGUNIT_TEST_SUITE_END();
 
-   LoggingEventPtr event;
+	LoggingEventPtr event;
 
 public:
-   void setUp()
-   {
-      event = new LoggingEvent(
-         LOG4CXX_STR("org.foobar"), Level::getInfo(), LOG4CXX_STR("msg 1"), LOG4CXX_LOCATION);
-   }
+	void setUp()
+	{
+		event = new LoggingEvent(
+			LOG4CXX_STR("org.foobar"), Level::getInfo(), LOG4CXX_STR("msg 1"), LOG4CXX_LOCATION);
+	}
 
-   void tearDown()
-   {
-   }
+	void tearDown()
+	{
+	}
 
 
-   PatternMap getFormatSpecifiers() {
-     PatternMap map;
-     RULES_PUT("c", LoggerPatternConverter);
-     RULES_PUT("logger", LoggerPatternConverter);
+	PatternMap getFormatSpecifiers()
+	{
+		PatternMap map;
+		RULES_PUT("c", LoggerPatternConverter);
+		RULES_PUT("logger", LoggerPatternConverter);
 
-     RULES_PUT("C", ClassNamePatternConverter);
-     RULES_PUT("class", ClassNamePatternConverter);
+		RULES_PUT("C", ClassNamePatternConverter);
+		RULES_PUT("class", ClassNamePatternConverter);
 
-     RULES_PUT("d", DatePatternConverter);
-     RULES_PUT("date", DatePatternConverter);
+		RULES_PUT("d", DatePatternConverter);
+		RULES_PUT("date", DatePatternConverter);
 
-     RULES_PUT("F", FileLocationPatternConverter);
-     RULES_PUT("file", FileLocationPatternConverter);
+		RULES_PUT("F", FileLocationPatternConverter);
+		RULES_PUT("file", FileLocationPatternConverter);
 
-     RULES_PUT("l", FullLocationPatternConverter);
+		RULES_PUT("l", FullLocationPatternConverter);
 
-     RULES_PUT("L", LineLocationPatternConverter);
-     RULES_PUT("line", LineLocationPatternConverter);
+		RULES_PUT("L", LineLocationPatternConverter);
+		RULES_PUT("line", LineLocationPatternConverter);
 
-     RULES_PUT("m", MessagePatternConverter);
-     RULES_PUT("message", MessagePatternConverter);
+		RULES_PUT("m", MessagePatternConverter);
+		RULES_PUT("message", MessagePatternConverter);
 
-     RULES_PUT("n", LineSeparatorPatternConverter);
+		RULES_PUT("n", LineSeparatorPatternConverter);
 
-     RULES_PUT("M", MethodLocationPatternConverter);
-     RULES_PUT("method", MethodLocationPatternConverter);
+		RULES_PUT("M", MethodLocationPatternConverter);
+		RULES_PUT("method", MethodLocationPatternConverter);
 
-     RULES_PUT("p", LevelPatternConverter);
-     RULES_PUT("level", LevelPatternConverter);
+		RULES_PUT("p", LevelPatternConverter);
+		RULES_PUT("level", LevelPatternConverter);
 
-     RULES_PUT("r", RelativeTimePatternConverter);
-     RULES_PUT("relative", RelativeTimePatternConverter);
+		RULES_PUT("r", RelativeTimePatternConverter);
+		RULES_PUT("relative", RelativeTimePatternConverter);
 
-     RULES_PUT("t", ThreadPatternConverter);
-     RULES_PUT("thread", ThreadPatternConverter);
+		RULES_PUT("t", ThreadPatternConverter);
+		RULES_PUT("thread", ThreadPatternConverter);
 
-     RULES_PUT("x", NDCPatternConverter);
-     RULES_PUT("ndc", NDCPatternConverter);
+		RULES_PUT("x", NDCPatternConverter);
+		RULES_PUT("ndc", NDCPatternConverter);
 
-     RULES_PUT("X", PropertiesPatternConverter);
-     RULES_PUT("properties", PropertiesPatternConverter);
+		RULES_PUT("X", PropertiesPatternConverter);
+		RULES_PUT("properties", PropertiesPatternConverter);
 
-     RULES_PUT("throwable", ThrowableInformationPatternConverter);
+		RULES_PUT("throwable", ThrowableInformationPatternConverter);
 
-     return map;
+		return map;
 
-   }
+	}
 
-   void assertFormattedEquals(const LogString& pattern,
-        const PatternMap& patternMap,
-        const LogString& expected) {
-      std::vector<PatternConverterPtr> converters;
-      std::vector<FormattingInfoPtr> fields;
-      PatternParser::parse(pattern, converters, fields, patternMap);
-      Pool p;
-      LogString actual;
-      std::vector<FormattingInfoPtr>::const_iterator fieldIter = fields.begin();
-      for(std::vector<PatternConverterPtr>::const_iterator converterIter = converters.begin();
-          converterIter != converters.end();
-          converterIter++, fieldIter++) {
-          int fieldStart = actual.length();
-          (*converterIter)->format(event, actual, p);
-          (*fieldIter)->format(fieldStart, actual);
-      }
-      LOGUNIT_ASSERT_EQUAL(expected, actual);
-   }
+	void assertFormattedEquals(const LogString & pattern,
+		const PatternMap & patternMap,
+		const LogString & expected)
+	{
+		std::vector<PatternConverterPtr> converters;
+		std::vector<FormattingInfoPtr> fields;
+		PatternParser::parse(pattern, converters, fields, patternMap);
+		Pool p;
+		LogString actual;
+		std::vector<FormattingInfoPtr>::const_iterator fieldIter = fields.begin();
+
+		for (std::vector<PatternConverterPtr>::const_iterator converterIter = converters.begin();
+			converterIter != converters.end();
+			converterIter++, fieldIter++)
+		{
+			int fieldStart = actual.length();
+			(*converterIter)->format(event, actual, p);
+			(*fieldIter)->format(fieldStart, actual);
+		}
+
+		LOGUNIT_ASSERT_EQUAL(expected, actual);
+	}
 
 
-   void testNewWord()  {
-     PatternMap testRules(getFormatSpecifiers());
-     testRules.insert(
-        PatternMap::value_type(LOG4CXX_STR("z343"),
-            (PatternConstructor) Num343PatternConverter::newInstance));
-     assertFormattedEquals(LOG4CXX_STR("%z343"), testRules, LOG4CXX_STR("343"));
-   }
+	void testNewWord()
+	{
+		PatternMap testRules(getFormatSpecifiers());
+		testRules.insert(
+			PatternMap::value_type(LOG4CXX_STR("z343"),
+				(PatternConstructor) Num343PatternConverter::newInstance));
+		assertFormattedEquals(LOG4CXX_STR("%z343"), testRules, LOG4CXX_STR("343"));
+	}
 
 
-   /* Test whether words starting with the letter 'n' are treated differently,
-    * which was previously the case by mistake.
-    */
-   void testNewWord2()  {
-     PatternMap testRules(getFormatSpecifiers());
-     testRules.insert(
-        PatternMap::value_type(LOG4CXX_STR("n343"),
-            (PatternConstructor) Num343PatternConverter::newInstance));
-     assertFormattedEquals(LOG4CXX_STR("%n343"), testRules, LOG4CXX_STR("343"));
-   }
+	/* Test whether words starting with the letter 'n' are treated differently,
+	 * which was previously the case by mistake.
+	 */
+	void testNewWord2()
+	{
+		PatternMap testRules(getFormatSpecifiers());
+		testRules.insert(
+			PatternMap::value_type(LOG4CXX_STR("n343"),
+				(PatternConstructor) Num343PatternConverter::newInstance));
+		assertFormattedEquals(LOG4CXX_STR("%n343"), testRules, LOG4CXX_STR("343"));
+	}
 
-   void testBogusWord1()  {
-     assertFormattedEquals(LOG4CXX_STR("%, foobar"),
-         getFormatSpecifiers(),
-         LOG4CXX_STR("%, foobar"));
-   }
+	void testBogusWord1()
+	{
+		assertFormattedEquals(LOG4CXX_STR("%, foobar"),
+			getFormatSpecifiers(),
+			LOG4CXX_STR("%, foobar"));
+	}
 
-   void testBogusWord2()  {
-     assertFormattedEquals(LOG4CXX_STR("xyz %, foobar"),
-        getFormatSpecifiers(),
-        LOG4CXX_STR("xyz %, foobar"));
-   }
+	void testBogusWord2()
+	{
+		assertFormattedEquals(LOG4CXX_STR("xyz %, foobar"),
+			getFormatSpecifiers(),
+			LOG4CXX_STR("xyz %, foobar"));
+	}
 
-   void testBasic1()  {
-     assertFormattedEquals(LOG4CXX_STR("hello %-5level - %m%n"),
-        getFormatSpecifiers(),
-        LogString(LOG4CXX_STR("hello INFO  - msg 1")) + LOG4CXX_EOL);
-   }
+	void testBasic1()
+	{
+		assertFormattedEquals(LOG4CXX_STR("hello %-5level - %m%n"),
+			getFormatSpecifiers(),
+			LogString(LOG4CXX_STR("hello INFO  - msg 1")) + LOG4CXX_EOL);
+	}
 
-   void testBasic2()  {
-      Pool pool;
-      RelativeTimeDateFormat relativeFormat;
-      LogString expected;
-      relativeFormat.format(expected, event->getTimeStamp(), pool);
+	void testBasic2()
+	{
+		Pool pool;
+		RelativeTimeDateFormat relativeFormat;
+		LogString expected;
+		relativeFormat.format(expected, event->getTimeStamp(), pool);
 
-      expected.append(LOG4CXX_STR(" INFO  ["));
-      expected.append(event->getThreadName());
-      expected.append(LOG4CXX_STR("] org.foobar - msg 1"));
-      expected.append(LOG4CXX_EOL);
+		expected.append(LOG4CXX_STR(" INFO  ["));
+		expected.append(event->getThreadName());
+		expected.append(LOG4CXX_STR("] org.foobar - msg 1"));
+		expected.append(LOG4CXX_EOL);
 
-      assertFormattedEquals(LOG4CXX_STR("%relative %-5level [%thread] %logger - %m%n"),
-        getFormatSpecifiers(),
-        expected);
-   }
+		assertFormattedEquals(LOG4CXX_STR("%relative %-5level [%thread] %logger - %m%n"),
+			getFormatSpecifiers(),
+			expected);
+	}
 
-   void testMultiOption()  {
-     Pool pool;
+	void testMultiOption()
+	{
+		Pool pool;
 
-     SimpleDateFormat dateFormat(LOG4CXX_STR("HH:mm:ss"));
-     LogString localTime;
-     dateFormat.format(localTime, event->getTimeStamp(), pool);
+		SimpleDateFormat dateFormat(LOG4CXX_STR("HH:mm:ss"));
+		LogString localTime;
+		dateFormat.format(localTime, event->getTimeStamp(), pool);
 
-     dateFormat.setTimeZone(TimeZone::getGMT());
-     LogString utcTime;
-     dateFormat.format(utcTime, event->getTimeStamp(), pool);
+		dateFormat.setTimeZone(TimeZone::getGMT());
+		LogString utcTime;
+		dateFormat.format(utcTime, event->getTimeStamp(), pool);
 
-     LogString expected(utcTime);
-     expected.append(1, LOG4CXX_STR(' '));
-     expected.append(localTime);
-     expected.append(LOG4CXX_STR(" org.foobar  - msg 1"));
+		LogString expected(utcTime);
+		expected.append(1, LOG4CXX_STR(' '));
+		expected.append(localTime);
+		expected.append(LOG4CXX_STR(" org.foobar  - msg 1"));
 
 
-     assertFormattedEquals(LOG4CXX_STR("%d{HH:mm:ss}{GMT} %d{HH:mm:ss} %c  - %m"),
-       getFormatSpecifiers(),
-       expected);
-   }
+		assertFormattedEquals(LOG4CXX_STR("%d{HH:mm:ss}{GMT} %d{HH:mm:ss} %c  - %m"),
+			getFormatSpecifiers(),
+			expected);
+	}
 
 };
 
@@ -237,5 +249,5 @@
 //   See bug LOGCXX-204
 //
 #if !defined(_MSC_VER) || _MSC_VER > 1200
-LOGUNIT_TEST_SUITE_REGISTRATION(PatternParserTestCase);
+	LOGUNIT_TEST_SUITE_REGISTRATION(PatternParserTestCase);
 #endif
diff --git a/src/test/cpp/patternlayouttest.cpp b/src/test/cpp/patternlayouttest.cpp
index 9c3818f..b6c8510 100644
--- a/src/test/cpp/patternlayouttest.cpp
+++ b/src/test/cpp/patternlayouttest.cpp
@@ -53,8 +53,8 @@
 #define PAT11a REGEX_STR("^(DEBUG|INFO |WARN |ERROR|FATAL) \\[[0-9A-FXx]*]\\ log4j.PatternLayoutTest: Message [0-9]\\{1,2\\}")
 #define PAT11b REGEX_STR("^(DEBUG|INFO |WARN |ERROR|FATAL) \\[[0-9A-FXx]*]\\ root: Message [0-9]\\{1,2\\}")
 #define PAT12 REGEX_STR("^\\[[0-9A-FXx]*]\\ (DEBUG|INFO |WARN |ERROR|FATAL) ")\
-    REGEX_STR(".*patternlayouttest.cpp([0-9]\\{1,4\\}): ")\
-    REGEX_STR("Message [0-9]\\{1,2\\}")
+	REGEX_STR(".*patternlayouttest.cpp([0-9]\\{1,4\\}): ")\
+	REGEX_STR("Message [0-9]\\{1,2\\}")
 #define PAT_MDC_1 REGEX_STR("")
 
 using namespace log4cxx;
@@ -62,481 +62,482 @@
 
 LOGUNIT_CLASS(PatternLayoutTest)
 {
-        LOGUNIT_TEST_SUITE(PatternLayoutTest);
-                LOGUNIT_TEST(test1);
-                LOGUNIT_TEST(test2);
-                LOGUNIT_TEST(test3);
-                LOGUNIT_TEST(test4);
-                LOGUNIT_TEST(test5);
-                LOGUNIT_TEST(test6);
-                LOGUNIT_TEST(test7);
-                LOGUNIT_TEST(test8);
-                LOGUNIT_TEST(test9);
-                LOGUNIT_TEST(test10);
-                LOGUNIT_TEST(test11);
-                LOGUNIT_TEST(test12);
-                LOGUNIT_TEST(testMDC1);
-                LOGUNIT_TEST(testMDC2);
-        LOGUNIT_TEST_SUITE_END();
+	LOGUNIT_TEST_SUITE(PatternLayoutTest);
+	LOGUNIT_TEST(test1);
+	LOGUNIT_TEST(test2);
+	LOGUNIT_TEST(test3);
+	LOGUNIT_TEST(test4);
+	LOGUNIT_TEST(test5);
+	LOGUNIT_TEST(test6);
+	LOGUNIT_TEST(test7);
+	LOGUNIT_TEST(test8);
+	LOGUNIT_TEST(test9);
+	LOGUNIT_TEST(test10);
+	LOGUNIT_TEST(test11);
+	LOGUNIT_TEST(test12);
+	LOGUNIT_TEST(testMDC1);
+	LOGUNIT_TEST(testMDC2);
+	LOGUNIT_TEST_SUITE_END();
 
-        LoggerPtr root;
-        LoggerPtr logger;
+	LoggerPtr root;
+	LoggerPtr logger;
 
 public:
-        void setUp()
-        {
-                root = Logger::getRootLogger();
-                MDC::clear();
-                logger = Logger::getLogger(LOG4CXX_TEST_STR("java.org.apache.log4j.PatternLayoutTest"));
-        }
+	void setUp()
+	{
+		root = Logger::getRootLogger();
+		MDC::clear();
+		logger = Logger::getLogger(LOG4CXX_TEST_STR("java.org.apache.log4j.PatternLayoutTest"));
+	}
 
-        void tearDown()
-        {
-                MDC::clear();
-                root->getLoggerRepository()->resetConfiguration();
-        }
+	void tearDown()
+	{
+		MDC::clear();
+		root->getLoggerRepository()->resetConfiguration();
+	}
 
-        void test1()
-        {
-                PropertyConfigurator::configure(LOG4CXX_FILE("input/patternLayout1.properties"));
-                common();
-                LOGUNIT_ASSERT(Compare::compare(TEMP, LOG4CXX_FILE("witness/patternLayout.1")));
-        }
+	void test1()
+	{
+		PropertyConfigurator::configure(LOG4CXX_FILE("input/patternLayout1.properties"));
+		common();
+		LOGUNIT_ASSERT(Compare::compare(TEMP, LOG4CXX_FILE("witness/patternLayout.1")));
+	}
 
-        void test2()
-        {
-                PropertyConfigurator::configure(LOG4CXX_FILE("input/patternLayout2.properties"));
-                common();
+	void test2()
+	{
+		PropertyConfigurator::configure(LOG4CXX_FILE("input/patternLayout2.properties"));
+		common();
 
-                ControlFilter filter1;
-                filter1 << PAT1;
-                ISO8601Filter filter2;
-                ThreadFilter filter3;
+		ControlFilter filter1;
+		filter1 << PAT1;
+		ISO8601Filter filter2;
+		ThreadFilter filter3;
 
-                std::vector<Filter *> filters;
-                filters.push_back(&filter1);
-                filters.push_back(&filter2);
-                filters.push_back(&filter3);
+		std::vector<Filter*> filters;
+		filters.push_back(&filter1);
+		filters.push_back(&filter2);
+		filters.push_back(&filter3);
 
-                try
-                {
-                        Transformer::transform(TEMP, FILTERED, filters);
-                }
-                catch(UnexpectedFormatException& e)
-                {
-                        std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
-                        throw;
-                }
+		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/patternLayout.2")));
-        }
+		LOGUNIT_ASSERT(Compare::compare(FILTERED, LOG4CXX_FILE("witness/patternLayout.2")));
+	}
 
-        void test3()
-        {
-                PropertyConfigurator::configure(LOG4CXX_FILE("input/patternLayout3.properties"));
-                common();
+	void test3()
+	{
+		PropertyConfigurator::configure(LOG4CXX_FILE("input/patternLayout3.properties"));
+		common();
 
-                ControlFilter filter1;
-                filter1 << PAT1;
-                ISO8601Filter filter2;
-                ThreadFilter filter3;
+		ControlFilter filter1;
+		filter1 << PAT1;
+		ISO8601Filter filter2;
+		ThreadFilter filter3;
 
-                std::vector<Filter *> filters;
-                filters.push_back(&filter1);
-                filters.push_back(&filter2);
-                filters.push_back(&filter3);
+		std::vector<Filter*> filters;
+		filters.push_back(&filter1);
+		filters.push_back(&filter2);
+		filters.push_back(&filter3);
 
-                try
-                {
-                        Transformer::transform(TEMP, FILTERED, filters);
-                }
-                catch(UnexpectedFormatException& e)
-                {
-                        std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
-                        throw;
-                }
+		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/patternLayout.3")));
-        }
+		LOGUNIT_ASSERT(Compare::compare(FILTERED, LOG4CXX_FILE("witness/patternLayout.3")));
+	}
 
-        // Output format:
-        // 06 avr. 2002 18:30:58,937 [12345] DEBUG atternLayoutTest - Message 0
-        void test4()
-        {
-                PropertyConfigurator::configure(LOG4CXX_FILE("input/patternLayout4.properties"));
-                common();
+	// Output format:
+	// 06 avr. 2002 18:30:58,937 [12345] DEBUG atternLayoutTest - Message 0
+	void test4()
+	{
+		PropertyConfigurator::configure(LOG4CXX_FILE("input/patternLayout4.properties"));
+		common();
 
-                ControlFilter filter1;
-                filter1 << PAT2;
-                AbsoluteDateAndTimeFilter filter2;
-                ThreadFilter filter3;
+		ControlFilter filter1;
+		filter1 << PAT2;
+		AbsoluteDateAndTimeFilter filter2;
+		ThreadFilter filter3;
 
-                std::vector<Filter *> filters;
-                filters.push_back(&filter1);
-                filters.push_back(&filter2);
-                filters.push_back(&filter3);
+		std::vector<Filter*> filters;
+		filters.push_back(&filter1);
+		filters.push_back(&filter2);
+		filters.push_back(&filter3);
 
-                try
-                {
-                        Transformer::transform(TEMP, FILTERED, filters);
-                }
-                catch(UnexpectedFormatException& e)
-                {
-                        std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
-                        throw;
-                }
+		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/patternLayout.4")));
-        }
+		LOGUNIT_ASSERT(Compare::compare(FILTERED, LOG4CXX_FILE("witness/patternLayout.4")));
+	}
 
-        void test5()
-        {
-                PropertyConfigurator::configure(LOG4CXX_FILE("input/patternLayout5.properties"));
-                common();
+	void test5()
+	{
+		PropertyConfigurator::configure(LOG4CXX_FILE("input/patternLayout5.properties"));
+		common();
 
-                ControlFilter filter1;
-                filter1 << PAT2;
-                AbsoluteDateAndTimeFilter filter2;
-                ThreadFilter filter3;
+		ControlFilter filter1;
+		filter1 << PAT2;
+		AbsoluteDateAndTimeFilter filter2;
+		ThreadFilter filter3;
 
-                std::vector<Filter *> filters;
-                filters.push_back(&filter1);
-                filters.push_back(&filter2);
-                filters.push_back(&filter3);
+		std::vector<Filter*> filters;
+		filters.push_back(&filter1);
+		filters.push_back(&filter2);
+		filters.push_back(&filter3);
 
-                try
-                {
-                        Transformer::transform(TEMP, FILTERED, filters);
-                }
-                catch(UnexpectedFormatException& e)
-                {
-                        std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
-                        throw;
-                }
+		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/patternLayout.5")));
-        }
+		LOGUNIT_ASSERT(Compare::compare(FILTERED, LOG4CXX_FILE("witness/patternLayout.5")));
+	}
 
-        void test6()
-        {
-                PropertyConfigurator::configure(LOG4CXX_FILE("input/patternLayout6.properties"));
-                common();
+	void test6()
+	{
+		PropertyConfigurator::configure(LOG4CXX_FILE("input/patternLayout6.properties"));
+		common();
 
-                ControlFilter filter1;
-                filter1 << PAT3;
-                AbsoluteTimeFilter filter2;
-                ThreadFilter filter3;
+		ControlFilter filter1;
+		filter1 << PAT3;
+		AbsoluteTimeFilter filter2;
+		ThreadFilter filter3;
 
-                std::vector<Filter *> filters;
-                filters.push_back(&filter1);
-                filters.push_back(&filter2);
-                filters.push_back(&filter3);
+		std::vector<Filter*> filters;
+		filters.push_back(&filter1);
+		filters.push_back(&filter2);
+		filters.push_back(&filter3);
 
-                try
-                {
-                        Transformer::transform(TEMP, FILTERED, filters);
-                }
-                catch(UnexpectedFormatException& e)
-                {
-                        std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
-                        throw;
-                }
+		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/patternLayout.6")));
-        }
+		LOGUNIT_ASSERT(Compare::compare(FILTERED, LOG4CXX_FILE("witness/patternLayout.6")));
+	}
 
-        void test7()
-        {
-                PropertyConfigurator::configure(LOG4CXX_FILE("input/patternLayout7.properties"));
-                common();
+	void test7()
+	{
+		PropertyConfigurator::configure(LOG4CXX_FILE("input/patternLayout7.properties"));
+		common();
 
-                ControlFilter filter1;
-                filter1 << PAT3;
-                AbsoluteTimeFilter filter2;
-                ThreadFilter filter3;
+		ControlFilter filter1;
+		filter1 << PAT3;
+		AbsoluteTimeFilter filter2;
+		ThreadFilter filter3;
 
-                std::vector<Filter *> filters;
-                filters.push_back(&filter1);
-                filters.push_back(&filter2);
-                filters.push_back(&filter3);
+		std::vector<Filter*> filters;
+		filters.push_back(&filter1);
+		filters.push_back(&filter2);
+		filters.push_back(&filter3);
 
-                try
-                {
-                        Transformer::transform(TEMP, FILTERED, filters);
-                }
-                catch(UnexpectedFormatException& e)
-                {
-                        std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
-                        throw;
-                }
+		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/patternLayout.7")));
-        }
+		LOGUNIT_ASSERT(Compare::compare(FILTERED, LOG4CXX_FILE("witness/patternLayout.7")));
+	}
 
-        void test8()
-        {
-                PropertyConfigurator::configure(LOG4CXX_FILE("input/patternLayout8.properties"));
-                common();
+	void test8()
+	{
+		PropertyConfigurator::configure(LOG4CXX_FILE("input/patternLayout8.properties"));
+		common();
 
 
-                ControlFilter filter1;
-                filter1 << PAT4;
-                //
-                //   combo of relative time and thread identifier
-                //     (the \\\\1 preserve a leading space)
-                Filter filter2(".*]", "[main]");
+		ControlFilter filter1;
+		filter1 << PAT4;
+		//
+		//   combo of relative time and thread identifier
+		//     (the \\\\1 preserve a leading space)
+		Filter filter2(".*]", "[main]");
 
-                std::vector<Filter *> filters;
+		std::vector<Filter*> filters;
 
-                filters.push_back(&filter1);
-                filters.push_back(&filter2);
+		filters.push_back(&filter1);
+		filters.push_back(&filter2);
 
-                try
-                {
-                        Transformer::transform(TEMP, FILTERED, filters);
-                }
-                catch(UnexpectedFormatException& e)
-                {
-                        std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
-                        throw;
-                }
+		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/patternLayout.8")));
-        }
+		LOGUNIT_ASSERT(Compare::compare(FILTERED, LOG4CXX_FILE("witness/patternLayout.8")));
+	}
 
-        void test9()
-        {
-                PropertyConfigurator::configure(LOG4CXX_FILE("input/patternLayout9.properties"));
-                common();
+	void test9()
+	{
+		PropertyConfigurator::configure(LOG4CXX_FILE("input/patternLayout9.properties"));
+		common();
 
-                ControlFilter filter1;
-                filter1 << PAT5;
-                ThreadFilter filter2;
+		ControlFilter filter1;
+		filter1 << PAT5;
+		ThreadFilter filter2;
 
-                std::vector<Filter *> filters;
-                filters.push_back(&filter1);
-                filters.push_back(&filter2);
+		std::vector<Filter*> filters;
+		filters.push_back(&filter1);
+		filters.push_back(&filter2);
 
-                try
-                {
-                        Transformer::transform(TEMP, FILTERED, filters);
-                }
-                catch(UnexpectedFormatException& e)
-                {
-                        std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
-                        throw;
-                }
+		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/patternLayout.9")));
-        }
+		LOGUNIT_ASSERT(Compare::compare(FILTERED, LOG4CXX_FILE("witness/patternLayout.9")));
+	}
 
-        void test10()
-        {
-                PropertyConfigurator::configure(LOG4CXX_FILE("input/patternLayout10.properties"));
-                common();
+	void test10()
+	{
+		PropertyConfigurator::configure(LOG4CXX_FILE("input/patternLayout10.properties"));
+		common();
 
-                ControlFilter filter1;
-                filter1 << PAT6;
-                ThreadFilter filter2;
-                LineNumberFilter filter3;
-                FilenameFilter filenameFilter(__FILE__, "patternlayouttest.cpp");
+		ControlFilter filter1;
+		filter1 << PAT6;
+		ThreadFilter filter2;
+		LineNumberFilter filter3;
+		FilenameFilter filenameFilter(__FILE__, "patternlayouttest.cpp");
 
 
-                std::vector<Filter *> filters;
-                filters.push_back(&filenameFilter);
-                filters.push_back(&filter1);
-                filters.push_back(&filter2);
-                filters.push_back(&filter3);
+		std::vector<Filter*> filters;
+		filters.push_back(&filenameFilter);
+		filters.push_back(&filter1);
+		filters.push_back(&filter2);
+		filters.push_back(&filter3);
 
 
-                try
-                {
-                        Transformer::transform(TEMP, FILTERED, filters);
-                }
-                catch(UnexpectedFormatException& e)
-                {
-                        std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
-                        throw;
-                }
+		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/patternLayout.10")));
-        }
+		LOGUNIT_ASSERT(Compare::compare(FILTERED, LOG4CXX_FILE("witness/patternLayout.10")));
+	}
 
-        void test11()
-        {
-                PropertyConfigurator::configure(LOG4CXX_FILE("input/patternLayout11.properties"));
-                common();
+	void test11()
+	{
+		PropertyConfigurator::configure(LOG4CXX_FILE("input/patternLayout11.properties"));
+		common();
 
-                ControlFilter filter1;
-                filter1 << PAT11a << PAT11b;
-                ThreadFilter filter2;
+		ControlFilter filter1;
+		filter1 << PAT11a << PAT11b;
+		ThreadFilter filter2;
 
-                std::vector<Filter *> filters;
-                filters.push_back(&filter1);
-                filters.push_back(&filter2);
+		std::vector<Filter*> filters;
+		filters.push_back(&filter1);
+		filters.push_back(&filter2);
 
-                try
-                {
-                        Transformer::transform(TEMP, FILTERED, filters);
-                }
-                catch(UnexpectedFormatException& e)
-                {
-                        std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
-                        throw;
-                }
+		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/patternLayout.11")));
-        }
+		LOGUNIT_ASSERT(Compare::compare(FILTERED, LOG4CXX_FILE("witness/patternLayout.11")));
+	}
 
-        void test12()
-        {
-                PropertyConfigurator::configure(LOG4CXX_FILE("input/patternLayout12.properties"));
-                common();
+	void test12()
+	{
+		PropertyConfigurator::configure(LOG4CXX_FILE("input/patternLayout12.properties"));
+		common();
 
-                ControlFilter filter1;
-                filter1 << PAT12;
-                ThreadFilter filter2;
-                LineNumberFilter filter3;
-                FilenameFilter filenameFilter(__FILE__, "patternlayouttest.cpp");
+		ControlFilter filter1;
+		filter1 << PAT12;
+		ThreadFilter filter2;
+		LineNumberFilter filter3;
+		FilenameFilter filenameFilter(__FILE__, "patternlayouttest.cpp");
 
-                std::vector<Filter *> filters;
-                filters.push_back(&filenameFilter);
-                filters.push_back(&filter1);
-                filters.push_back(&filter2);
-                filters.push_back(&filter3);
+		std::vector<Filter*> filters;
+		filters.push_back(&filenameFilter);
+		filters.push_back(&filter1);
+		filters.push_back(&filter2);
+		filters.push_back(&filter3);
 
-                try
-                {
-                        Transformer::transform(TEMP, FILTERED, filters);
-                }
-                catch(UnexpectedFormatException& e)
-                {
-                        std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
-                        throw;
-                }
+		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/patternLayout.12")));
-        }
+		LOGUNIT_ASSERT(Compare::compare(FILTERED, LOG4CXX_FILE("witness/patternLayout.12")));
+	}
 
-        void testMDC1()
-        {
-                PropertyConfigurator::configure(LOG4CXX_FILE("input/patternLayout.mdc.1.properties"));
-                MDC::put(LOG4CXX_TEST_STR("key1"), LOG4CXX_TEST_STR("va11"));
-                MDC::put(LOG4CXX_TEST_STR("key2"), LOG4CXX_TEST_STR("va12"));
-                logger->debug(LOG4CXX_TEST_STR("Hello World"));
-                MDC::clear();
+	void testMDC1()
+	{
+		PropertyConfigurator::configure(LOG4CXX_FILE("input/patternLayout.mdc.1.properties"));
+		MDC::put(LOG4CXX_TEST_STR("key1"), LOG4CXX_TEST_STR("va11"));
+		MDC::put(LOG4CXX_TEST_STR("key2"), LOG4CXX_TEST_STR("va12"));
+		logger->debug(LOG4CXX_TEST_STR("Hello World"));
+		MDC::clear();
 
-                LOGUNIT_ASSERT(Compare::compare(TEMP, LOG4CXX_FILE("witness/patternLayout.mdc.1")));
-        }
+		LOGUNIT_ASSERT(Compare::compare(TEMP, LOG4CXX_FILE("witness/patternLayout.mdc.1")));
+	}
 
-        void testMDC2()
-        {
-                LogString OUTPUT_FILE   = LOG4CXX_STR("output/patternLayout.mdc.2");
-                File WITNESS_FILE  = LOG4CXX_FILE("witness/patternLayout.mdc.2");
+	void testMDC2()
+	{
+		LogString OUTPUT_FILE   = LOG4CXX_STR("output/patternLayout.mdc.2");
+		File WITNESS_FILE  = LOG4CXX_FILE("witness/patternLayout.mdc.2");
 
-                LogString mdcMsgPattern1 = LOG4CXX_STR("%m : %X%n");
-                LogString mdcMsgPattern2 = LOG4CXX_STR("%m : %X{key1}%n");
-                LogString mdcMsgPattern3 = LOG4CXX_STR("%m : %X{key2}%n");
-                LogString mdcMsgPattern4 = LOG4CXX_STR("%m : %X{key3}%n");
-                LogString mdcMsgPattern5 = LOG4CXX_STR("%m : %X{key1},%X{key2},%X{key3}%n");
+		LogString mdcMsgPattern1 = LOG4CXX_STR("%m : %X%n");
+		LogString mdcMsgPattern2 = LOG4CXX_STR("%m : %X{key1}%n");
+		LogString mdcMsgPattern3 = LOG4CXX_STR("%m : %X{key2}%n");
+		LogString mdcMsgPattern4 = LOG4CXX_STR("%m : %X{key3}%n");
+		LogString mdcMsgPattern5 = LOG4CXX_STR("%m : %X{key1},%X{key2},%X{key3}%n");
 
-                // set up appender
-                PatternLayoutPtr layout = new PatternLayout(LOG4CXX_STR("%m%n"));
-                AppenderPtr appender = new FileAppender(layout, OUTPUT_FILE, false);
+		// set up appender
+		PatternLayoutPtr layout = new PatternLayout(LOG4CXX_STR("%m%n"));
+		AppenderPtr appender = new FileAppender(layout, OUTPUT_FILE, false);
 
-                // set appender on root and set level to debug
-                root->addAppender(appender);
-                root->setLevel(Level::getDebug());
+		// set appender on root and set level to debug
+		root->addAppender(appender);
+		root->setLevel(Level::getDebug());
 
-                // output starting message
-                root->debug(LOG4CXX_TEST_STR("starting mdc pattern test"));
+		// output starting message
+		root->debug(LOG4CXX_TEST_STR("starting mdc pattern test"));
 
-                layout->setConversionPattern(mdcMsgPattern1);
-                log4cxx::helpers::Pool pool;
-                layout->activateOptions(pool);
-                root->debug(LOG4CXX_TEST_STR("empty mdc, no key specified in pattern"));
+		layout->setConversionPattern(mdcMsgPattern1);
+		log4cxx::helpers::Pool pool;
+		layout->activateOptions(pool);
+		root->debug(LOG4CXX_TEST_STR("empty mdc, no key specified in pattern"));
 
-                layout->setConversionPattern(mdcMsgPattern2);
-                layout->activateOptions(pool);
-                root->debug(LOG4CXX_TEST_STR("empty mdc, key1 in pattern"));
+		layout->setConversionPattern(mdcMsgPattern2);
+		layout->activateOptions(pool);
+		root->debug(LOG4CXX_TEST_STR("empty mdc, key1 in pattern"));
 
-                layout->setConversionPattern(mdcMsgPattern3);
-                layout->activateOptions(pool);
-                root->debug(LOG4CXX_TEST_STR("empty mdc, key2 in pattern"));
+		layout->setConversionPattern(mdcMsgPattern3);
+		layout->activateOptions(pool);
+		root->debug(LOG4CXX_TEST_STR("empty mdc, key2 in pattern"));
 
-                layout->setConversionPattern(mdcMsgPattern4);
-                layout->activateOptions(pool);
-                root->debug(LOG4CXX_TEST_STR("empty mdc, key3 in pattern"));
+		layout->setConversionPattern(mdcMsgPattern4);
+		layout->activateOptions(pool);
+		root->debug(LOG4CXX_TEST_STR("empty mdc, key3 in pattern"));
 
-                layout->setConversionPattern(mdcMsgPattern5);
-                layout->activateOptions(pool);
-                root->debug(LOG4CXX_TEST_STR("empty mdc, key1, key2, and key3 in pattern"));
+		layout->setConversionPattern(mdcMsgPattern5);
+		layout->activateOptions(pool);
+		root->debug(LOG4CXX_TEST_STR("empty mdc, key1, key2, and key3 in pattern"));
 
-                MDC::put(LOG4CXX_TEST_STR("key1"), LOG4CXX_TEST_STR("value1"));
-                MDC::put(LOG4CXX_TEST_STR("key2"), LOG4CXX_TEST_STR("value2"));
+		MDC::put(LOG4CXX_TEST_STR("key1"), LOG4CXX_TEST_STR("value1"));
+		MDC::put(LOG4CXX_TEST_STR("key2"), LOG4CXX_TEST_STR("value2"));
 
-                layout->setConversionPattern(mdcMsgPattern1);
-                layout->activateOptions(pool);
-                root->debug(LOG4CXX_TEST_STR("filled mdc, no key specified in pattern"));
+		layout->setConversionPattern(mdcMsgPattern1);
+		layout->activateOptions(pool);
+		root->debug(LOG4CXX_TEST_STR("filled mdc, no key specified in pattern"));
 
-                layout->setConversionPattern(mdcMsgPattern2);
-                layout->activateOptions(pool);
-                root->debug(LOG4CXX_TEST_STR("filled mdc, key1 in pattern"));
+		layout->setConversionPattern(mdcMsgPattern2);
+		layout->activateOptions(pool);
+		root->debug(LOG4CXX_TEST_STR("filled mdc, key1 in pattern"));
 
-                layout->setConversionPattern(mdcMsgPattern3);
-                layout->activateOptions(pool);
-                root->debug(LOG4CXX_TEST_STR("filled mdc, key2 in pattern"));
+		layout->setConversionPattern(mdcMsgPattern3);
+		layout->activateOptions(pool);
+		root->debug(LOG4CXX_TEST_STR("filled mdc, key2 in pattern"));
 
-                layout->setConversionPattern(mdcMsgPattern4);
-                layout->activateOptions(pool);
-                root->debug(LOG4CXX_TEST_STR("filled mdc, key3 in pattern"));
+		layout->setConversionPattern(mdcMsgPattern4);
+		layout->activateOptions(pool);
+		root->debug(LOG4CXX_TEST_STR("filled mdc, key3 in pattern"));
 
-                layout->setConversionPattern(mdcMsgPattern5);
-                layout->activateOptions(pool);
-                root->debug(LOG4CXX_TEST_STR("filled mdc, key1, key2, and key3 in pattern"));
+		layout->setConversionPattern(mdcMsgPattern5);
+		layout->activateOptions(pool);
+		root->debug(LOG4CXX_TEST_STR("filled mdc, key1, key2, and key3 in pattern"));
 
-                MDC::remove(LOG4CXX_TEST_STR("key1"));
-                MDC::remove(LOG4CXX_TEST_STR("key2"));
+		MDC::remove(LOG4CXX_TEST_STR("key1"));
+		MDC::remove(LOG4CXX_TEST_STR("key2"));
 
-                layout->setConversionPattern(LOG4CXX_STR("%m%n"));
-                layout->activateOptions(pool);
-                root->debug(LOG4CXX_TEST_STR("finished mdc pattern test"));
+		layout->setConversionPattern(LOG4CXX_STR("%m%n"));
+		layout->activateOptions(pool);
+		root->debug(LOG4CXX_TEST_STR("finished mdc pattern test"));
 
-                LOGUNIT_ASSERT(Compare::compare(OUTPUT_FILE, WITNESS_FILE));
-        }
+		LOGUNIT_ASSERT(Compare::compare(OUTPUT_FILE, WITNESS_FILE));
+	}
 
-       std::string createMessage(Pool& pool, int i) {
-         std::string msg("Message ");
-         msg.append(pool.itoa(i));
-         return msg;
-       }
+	std::string createMessage(Pool & pool, int i)
+	{
+		std::string msg("Message ");
+		msg.append(pool.itoa(i));
+		return msg;
+	}
 
-        void common()
-        {
-                int i = -1;
+	void common()
+	{
+		int i = -1;
 
-                Pool pool;
+		Pool pool;
 
 
-                LOG4CXX_DEBUG(logger, createMessage(pool, ++i));
-                LOG4CXX_DEBUG(root, createMessage(pool, i));
+		LOG4CXX_DEBUG(logger, createMessage(pool, ++i));
+		LOG4CXX_DEBUG(root, createMessage(pool, i));
 
-                LOG4CXX_INFO(logger, createMessage(pool, ++i));
-                LOG4CXX_INFO(root, createMessage(pool, i));
+		LOG4CXX_INFO(logger, createMessage(pool, ++i));
+		LOG4CXX_INFO(root, createMessage(pool, i));
 
-                LOG4CXX_WARN(logger, createMessage(pool, ++i));
-                LOG4CXX_WARN(root, createMessage(pool, i));
+		LOG4CXX_WARN(logger, createMessage(pool, ++i));
+		LOG4CXX_WARN(root, createMessage(pool, i));
 
-                LOG4CXX_ERROR(logger, createMessage(pool, ++i));
-                LOG4CXX_ERROR(root, createMessage(pool, i));
+		LOG4CXX_ERROR(logger, createMessage(pool, ++i));
+		LOG4CXX_ERROR(root, createMessage(pool, i));
 
-                LOG4CXX_FATAL(logger, createMessage(pool, ++i));
-                LOG4CXX_FATAL(root, createMessage(pool, i));
-        }
+		LOG4CXX_FATAL(logger, createMessage(pool, ++i));
+		LOG4CXX_FATAL(root, createMessage(pool, i));
+	}
 
 private:
-        static const LogString FILTERED;
-        static const LogString TEMP;
+	static const LogString FILTERED;
+	static const LogString TEMP;
 
 };
 
diff --git a/src/test/cpp/propertyconfiguratortest.cpp b/src/test/cpp/propertyconfiguratortest.cpp
index c93c363..15e2f55 100644
--- a/src/test/cpp/propertyconfiguratortest.cpp
+++ b/src/test/cpp/propertyconfiguratortest.cpp
@@ -27,60 +27,63 @@
 
 LOGUNIT_CLASS(PropertyConfiguratorTest)
 {
-        LOGUNIT_TEST_SUITE(PropertyConfiguratorTest);
-                LOGUNIT_TEST(testInherited);
-                LOGUNIT_TEST(testNull);
-                LOGUNIT_TEST(testAppenderThreshold);
-        LOGUNIT_TEST_SUITE_END();
+	LOGUNIT_TEST_SUITE(PropertyConfiguratorTest);
+	LOGUNIT_TEST(testInherited);
+	LOGUNIT_TEST(testNull);
+	LOGUNIT_TEST(testAppenderThreshold);
+	LOGUNIT_TEST_SUITE_END();
 
 public:
-    void testInherited() {
-        Properties props;
-        props.put(LOG4CXX_STR("log4j.rootLogger"),LOG4CXX_STR("DEBUG,VECTOR1"));
-        props.put(LOG4CXX_STR("log4j.logger.org.apache.log4j.PropertyConfiguratorTest"), LOG4CXX_STR("inherited,VECTOR2"));
-        props.put(LOG4CXX_STR("log4j.appender.VECTOR1"), LOG4CXX_STR("org.apache.log4j.VectorAppender"));
-        props.put(LOG4CXX_STR("log4j.appender.VECTOR2"), LOG4CXX_STR("org.apache.log4j.VectorAppender"));
-        PropertyConfigurator::configure(props);
-        LoggerPtr logger = Logger::getLogger("org.apache.log4j.PropertyConfiguratorTest");
-        LOGUNIT_ASSERT_EQUAL((int) Level::DEBUG_INT,
-                logger->getEffectiveLevel()->toInt());
-        Logger::getRootLogger()->setLevel(Level::getError());
-        LOGUNIT_ASSERT_EQUAL((int) Level::ERROR_INT,
-                logger->getEffectiveLevel()->toInt());
-        LogManager::resetConfiguration();
-    }
+	void testInherited()
+	{
+		Properties props;
+		props.put(LOG4CXX_STR("log4j.rootLogger"), LOG4CXX_STR("DEBUG,VECTOR1"));
+		props.put(LOG4CXX_STR("log4j.logger.org.apache.log4j.PropertyConfiguratorTest"), LOG4CXX_STR("inherited,VECTOR2"));
+		props.put(LOG4CXX_STR("log4j.appender.VECTOR1"), LOG4CXX_STR("org.apache.log4j.VectorAppender"));
+		props.put(LOG4CXX_STR("log4j.appender.VECTOR2"), LOG4CXX_STR("org.apache.log4j.VectorAppender"));
+		PropertyConfigurator::configure(props);
+		LoggerPtr logger = Logger::getLogger("org.apache.log4j.PropertyConfiguratorTest");
+		LOGUNIT_ASSERT_EQUAL((int) Level::DEBUG_INT,
+			logger->getEffectiveLevel()->toInt());
+		Logger::getRootLogger()->setLevel(Level::getError());
+		LOGUNIT_ASSERT_EQUAL((int) Level::ERROR_INT,
+			logger->getEffectiveLevel()->toInt());
+		LogManager::resetConfiguration();
+	}
 
-    void testNull() {
-        Properties props;
-        props.put(LOG4CXX_STR("log4j.rootLogger"),LOG4CXX_STR("DEBUG,VECTOR1"));
-        props.put(LOG4CXX_STR("log4j.logger.org.apache.log4j.PropertyConfiguratorTest"), LOG4CXX_STR("NuLL,VECTOR2"));
-        props.put(LOG4CXX_STR("log4j.appender.VECTOR1"), LOG4CXX_STR("org.apache.log4j.VectorAppender"));
-        props.put(LOG4CXX_STR("log4j.appender.VECTOR2"), LOG4CXX_STR("org.apache.log4j.VectorAppender"));
-        PropertyConfigurator::configure(props);
-        LoggerPtr logger = Logger::getLogger("org.apache.log4j.PropertyConfiguratorTest");
-        LOGUNIT_ASSERT_EQUAL((int) Level::DEBUG_INT,
-                logger->getEffectiveLevel()->toInt());
-        Logger::getRootLogger()->setLevel(Level::getError());
-        LOGUNIT_ASSERT_EQUAL((int) Level::ERROR_INT,
-                logger->getEffectiveLevel()->toInt());
-        LogManager::resetConfiguration();
-    }
+	void testNull()
+	{
+		Properties props;
+		props.put(LOG4CXX_STR("log4j.rootLogger"), LOG4CXX_STR("DEBUG,VECTOR1"));
+		props.put(LOG4CXX_STR("log4j.logger.org.apache.log4j.PropertyConfiguratorTest"), LOG4CXX_STR("NuLL,VECTOR2"));
+		props.put(LOG4CXX_STR("log4j.appender.VECTOR1"), LOG4CXX_STR("org.apache.log4j.VectorAppender"));
+		props.put(LOG4CXX_STR("log4j.appender.VECTOR2"), LOG4CXX_STR("org.apache.log4j.VectorAppender"));
+		PropertyConfigurator::configure(props);
+		LoggerPtr logger = Logger::getLogger("org.apache.log4j.PropertyConfiguratorTest");
+		LOGUNIT_ASSERT_EQUAL((int) Level::DEBUG_INT,
+			logger->getEffectiveLevel()->toInt());
+		Logger::getRootLogger()->setLevel(Level::getError());
+		LOGUNIT_ASSERT_EQUAL((int) Level::ERROR_INT,
+			logger->getEffectiveLevel()->toInt());
+		LogManager::resetConfiguration();
+	}
 
-    void testAppenderThreshold() {
-        Properties props;
-        props.put(LOG4CXX_STR("log4j.rootLogger"), LOG4CXX_STR("ALL,VECTOR1"));
-        props.put(LOG4CXX_STR("log4j.appender.VECTOR1"), LOG4CXX_STR("org.apache.log4j.VectorAppender"));
-        props.put(LOG4CXX_STR("log4j.appender.VECTOR1.threshold"), LOG4CXX_STR("WARN"));
-        PropertyConfigurator::configure(props);
-        LoggerPtr root(Logger::getRootLogger());
-        VectorAppenderPtr appender(root->getAppender(LOG4CXX_STR("VECTOR1")));
-        LOGUNIT_ASSERT_EQUAL((int) Level::WARN_INT, appender->getThreshold()->toInt());
-        LOG4CXX_INFO(root, "Info message");
-        LOG4CXX_WARN(root, "Warn message");
-        LOG4CXX_WARN(root, "Error message");
-        LOGUNIT_ASSERT_EQUAL((size_t) 2, appender->vector.size());        
-        LogManager::resetConfiguration();
-    }
+	void testAppenderThreshold()
+	{
+		Properties props;
+		props.put(LOG4CXX_STR("log4j.rootLogger"), LOG4CXX_STR("ALL,VECTOR1"));
+		props.put(LOG4CXX_STR("log4j.appender.VECTOR1"), LOG4CXX_STR("org.apache.log4j.VectorAppender"));
+		props.put(LOG4CXX_STR("log4j.appender.VECTOR1.threshold"), LOG4CXX_STR("WARN"));
+		PropertyConfigurator::configure(props);
+		LoggerPtr root(Logger::getRootLogger());
+		VectorAppenderPtr appender(root->getAppender(LOG4CXX_STR("VECTOR1")));
+		LOGUNIT_ASSERT_EQUAL((int) Level::WARN_INT, appender->getThreshold()->toInt());
+		LOG4CXX_INFO(root, "Info message");
+		LOG4CXX_WARN(root, "Warn message");
+		LOG4CXX_WARN(root, "Error message");
+		LOGUNIT_ASSERT_EQUAL((size_t) 2, appender->vector.size());
+		LogManager::resetConfiguration();
+	}
 
 };
 
diff --git a/src/test/cpp/rolling/filenamepatterntestcase.cpp b/src/test/cpp/rolling/filenamepatterntestcase.cpp
index de6b655..e703f50 100644
--- a/src/test/cpp/rolling/filenamepatterntestcase.cpp
+++ b/src/test/cpp/rolling/filenamepatterntestcase.cpp
@@ -35,149 +35,172 @@
 /**
  * Tests for FileNamePattern.
  *
- * 
- * 
+ *
+ *
  *
  */
-LOGUNIT_CLASS(FileNamePatternTestCase) {
-  LOGUNIT_TEST_SUITE(FileNamePatternTestCase);
-  LOGUNIT_TEST(testFormatInteger1);
-  LOGUNIT_TEST(testFormatInteger2);
-  LOGUNIT_TEST(testFormatInteger3);
-  LOGUNIT_TEST(testFormatInteger4);
-  LOGUNIT_TEST(testFormatInteger5);
-  LOGUNIT_TEST(testFormatInteger6);
-  LOGUNIT_TEST(testFormatInteger7);
-  LOGUNIT_TEST(testFormatInteger8);
-  LOGUNIT_TEST(testFormatInteger9);
-  LOGUNIT_TEST(testFormatInteger10);
-  LOGUNIT_TEST(testFormatInteger11);
-  LOGUNIT_TEST(testFormatDate1);
-//
-//   TODO: Problem with timezone offset
-//  LOGUNIT_TEST(testFormatDate2);
-//  LOGUNIT_TEST(testFormatDate3);
-  LOGUNIT_TEST(testFormatDate4);
-  LOGUNIT_TEST(testFormatDate5);
-  LOGUNIT_TEST_SUITE_END();
+LOGUNIT_CLASS(FileNamePatternTestCase)
+{
+	LOGUNIT_TEST_SUITE(FileNamePatternTestCase);
+	LOGUNIT_TEST(testFormatInteger1);
+	LOGUNIT_TEST(testFormatInteger2);
+	LOGUNIT_TEST(testFormatInteger3);
+	LOGUNIT_TEST(testFormatInteger4);
+	LOGUNIT_TEST(testFormatInteger5);
+	LOGUNIT_TEST(testFormatInteger6);
+	LOGUNIT_TEST(testFormatInteger7);
+	LOGUNIT_TEST(testFormatInteger8);
+	LOGUNIT_TEST(testFormatInteger9);
+	LOGUNIT_TEST(testFormatInteger10);
+	LOGUNIT_TEST(testFormatInteger11);
+	LOGUNIT_TEST(testFormatDate1);
+	//
+	//   TODO: Problem with timezone offset
+	//  LOGUNIT_TEST(testFormatDate2);
+	//  LOGUNIT_TEST(testFormatDate3);
+	LOGUNIT_TEST(testFormatDate4);
+	LOGUNIT_TEST(testFormatDate5);
+	LOGUNIT_TEST_SUITE_END();
 
 public:
-    LogString format(const LogString& pattern,
-        const ObjectPtr& obj) {
-        std::vector<PatternConverterPtr> converters;
-        std::vector<FormattingInfoPtr> fields;
-        PatternMap rules;
-        rules.insert(PatternMap::value_type(LOG4CXX_STR("d"), (PatternConstructor) FileDatePatternConverter::newInstance));
-        rules.insert(PatternMap::value_type(LOG4CXX_STR("i"), (PatternConstructor) IntegerPatternConverter::newInstance));
-        PatternParser::parse(pattern, converters, fields, rules);
-        LogString result;
-        Pool pool;
-        std::vector<FormattingInfoPtr>::const_iterator fieldIter = fields.begin();
-        for(std::vector<PatternConverterPtr>::const_iterator converterIter = converters.begin();
-            converterIter != converters.end();
-            converterIter++, fieldIter++) {
-            LogString::size_type i = result.length();
-            (*converterIter)->format(obj, result, pool);
-            (*fieldIter)->format(i, result);
-        }
-        return result;
-    }
+	LogString format(const LogString & pattern,
+		const ObjectPtr & obj)
+	{
+		std::vector<PatternConverterPtr> converters;
+		std::vector<FormattingInfoPtr> fields;
+		PatternMap rules;
+		rules.insert(PatternMap::value_type(LOG4CXX_STR("d"), (PatternConstructor) FileDatePatternConverter::newInstance));
+		rules.insert(PatternMap::value_type(LOG4CXX_STR("i"), (PatternConstructor) IntegerPatternConverter::newInstance));
+		PatternParser::parse(pattern, converters, fields, rules);
+		LogString result;
+		Pool pool;
+		std::vector<FormattingInfoPtr>::const_iterator fieldIter = fields.begin();
+
+		for (std::vector<PatternConverterPtr>::const_iterator converterIter = converters.begin();
+			converterIter != converters.end();
+			converterIter++, fieldIter++)
+		{
+			LogString::size_type i = result.length();
+			(*converterIter)->format(obj, result, pool);
+			(*fieldIter)->format(i, result);
+		}
+
+		return result;
+	}
 
 
 
-    void assertDatePattern(const LogString& pattern,
-        int year,
-        int month,
-        int day, int hour,
-        int min,
-        const LogString& expected) {
-        apr_time_exp_t tm;
-        memset(&tm, 0, sizeof(tm));
-        tm.tm_min = min;
-        tm.tm_hour = hour;
-        tm.tm_mday = day;
-        tm.tm_mon = month;
-        tm.tm_year = year - 1900;
-        apr_time_t n;
-        /*apr_status_t stat = */apr_time_exp_get(&n, &tm);
-        ObjectPtr obj(new Date(n));
-        LOGUNIT_ASSERT_EQUAL(expected, format(pattern, obj));
-    }
+	void assertDatePattern(const LogString & pattern,
+		int year,
+		int month,
+		int day, int hour,
+		int min,
+		const LogString & expected)
+	{
+		apr_time_exp_t tm;
+		memset(&tm, 0, sizeof(tm));
+		tm.tm_min = min;
+		tm.tm_hour = hour;
+		tm.tm_mday = day;
+		tm.tm_mon = month;
+		tm.tm_year = year - 1900;
+		apr_time_t n;
+		/*apr_status_t stat = */apr_time_exp_get(&n, &tm);
+		ObjectPtr obj(new Date(n));
+		LOGUNIT_ASSERT_EQUAL(expected, format(pattern, obj));
+	}
 
-    void assertIntegerPattern(const LogString& pattern, int value,
-        const LogString& expected) {
-        ObjectPtr obj(new Integer(value));
-        LOGUNIT_ASSERT_EQUAL(expected, format(pattern, obj));
-    }
+	void assertIntegerPattern(const LogString & pattern, int value,
+		const LogString & expected)
+	{
+		ObjectPtr obj(new Integer(value));
+		LOGUNIT_ASSERT_EQUAL(expected, format(pattern, obj));
+	}
 
-    void testFormatInteger1() {
-        assertIntegerPattern(LOG4CXX_STR("t"),  3, LOG4CXX_STR("t"));
-    }
+	void testFormatInteger1()
+	{
+		assertIntegerPattern(LOG4CXX_STR("t"),  3, LOG4CXX_STR("t"));
+	}
 
-    void testFormatInteger2() {
-        assertIntegerPattern(LOG4CXX_STR("foo"),  3, LOG4CXX_STR("foo"));
-    }
+	void testFormatInteger2()
+	{
+		assertIntegerPattern(LOG4CXX_STR("foo"),  3, LOG4CXX_STR("foo"));
+	}
 
-    void testFormatInteger3() {
-        assertIntegerPattern(LOG4CXX_STR("foo%"),  3, LOG4CXX_STR("foo%"));
-    }
+	void testFormatInteger3()
+	{
+		assertIntegerPattern(LOG4CXX_STR("foo%"),  3, LOG4CXX_STR("foo%"));
+	}
 
-    void testFormatInteger4() {
-        assertIntegerPattern(LOG4CXX_STR("%ifoo"),  3, LOG4CXX_STR("3foo"));
-    }
+	void testFormatInteger4()
+	{
+		assertIntegerPattern(LOG4CXX_STR("%ifoo"),  3, LOG4CXX_STR("3foo"));
+	}
 
-    void testFormatInteger5() {
-        assertIntegerPattern(LOG4CXX_STR("foo%ixixo"),  3, LOG4CXX_STR("foo3xixo"));
-    }
+	void testFormatInteger5()
+	{
+		assertIntegerPattern(LOG4CXX_STR("foo%ixixo"),  3, LOG4CXX_STR("foo3xixo"));
+	}
 
-    void testFormatInteger6() {
-        assertIntegerPattern(LOG4CXX_STR("foo%i.log"),  3, LOG4CXX_STR("foo3.log"));
-    }
+	void testFormatInteger6()
+	{
+		assertIntegerPattern(LOG4CXX_STR("foo%i.log"),  3, LOG4CXX_STR("foo3.log"));
+	}
 
-    void testFormatInteger7() {
-        assertIntegerPattern(LOG4CXX_STR("foo.%i.log"),  3, LOG4CXX_STR("foo.3.log"));
-    }
+	void testFormatInteger7()
+	{
+		assertIntegerPattern(LOG4CXX_STR("foo.%i.log"),  3, LOG4CXX_STR("foo.3.log"));
+	}
 
-    void testFormatInteger8() {
-        assertIntegerPattern(LOG4CXX_STR("%ifoo%"),  3, LOG4CXX_STR("3foo%"));
-    }
+	void testFormatInteger8()
+	{
+		assertIntegerPattern(LOG4CXX_STR("%ifoo%"),  3, LOG4CXX_STR("3foo%"));
+	}
 
-    void testFormatInteger9() {
-        assertIntegerPattern(LOG4CXX_STR("%ifoo%%"),  3, LOG4CXX_STR("3foo%"));
-    }
+	void testFormatInteger9()
+	{
+		assertIntegerPattern(LOG4CXX_STR("%ifoo%%"),  3, LOG4CXX_STR("3foo%"));
+	}
 
-    void testFormatInteger10() {
-        assertIntegerPattern(LOG4CXX_STR("%%foo"),  3, LOG4CXX_STR("%foo"));
-    }
+	void testFormatInteger10()
+	{
+		assertIntegerPattern(LOG4CXX_STR("%%foo"),  3, LOG4CXX_STR("%foo"));
+	}
 
-    void testFormatInteger11() {
-        assertIntegerPattern(LOG4CXX_STR("foo%ibar%i"),  3, LOG4CXX_STR("foo3bar3"));
-    }
+	void testFormatInteger11()
+	{
+		assertIntegerPattern(LOG4CXX_STR("foo%ibar%i"),  3, LOG4CXX_STR("foo3bar3"));
+	}
 
-    void testFormatDate1() {
-        assertDatePattern(LOG4CXX_STR("foo%d{yyyy.MM.dd}"),  2003, 4, 20, 17, 55,
-            LOG4CXX_STR("foo2003.05.20"));
-    }
+	void testFormatDate1()
+	{
+		assertDatePattern(LOG4CXX_STR("foo%d{yyyy.MM.dd}"),  2003, 4, 20, 17, 55,
+			LOG4CXX_STR("foo2003.05.20"));
+	}
 
-    void testFormatDate2() {
-        assertDatePattern(LOG4CXX_STR("foo%d{yyyy.MM.dd HH:mm}"),  2003, 4, 20, 17, 55,
-            LOG4CXX_STR("foo2003.05.20 17:55"));
-    }
+	void testFormatDate2()
+	{
+		assertDatePattern(LOG4CXX_STR("foo%d{yyyy.MM.dd HH:mm}"),  2003, 4, 20, 17, 55,
+			LOG4CXX_STR("foo2003.05.20 17:55"));
+	}
 
-    void testFormatDate3() {
-        assertDatePattern(LOG4CXX_STR("%d{yyyy.MM.dd HH:mm} foo"),  2003, 4, 20, 17, 55,
-            LOG4CXX_STR("2003.05.20 17:55 foo"));
-    }
+	void testFormatDate3()
+	{
+		assertDatePattern(LOG4CXX_STR("%d{yyyy.MM.dd HH:mm} foo"),  2003, 4, 20, 17, 55,
+			LOG4CXX_STR("2003.05.20 17:55 foo"));
+	}
 
-    void testFormatDate4() {
-        assertDatePattern(LOG4CXX_STR("foo%dyyyy.MM.dd}"),  2003, 4, 20, 17, 55,
-            LOG4CXX_STR("foo2003-05-20yyyy.MM.dd}"));
-    }
+	void testFormatDate4()
+	{
+		assertDatePattern(LOG4CXX_STR("foo%dyyyy.MM.dd}"),  2003, 4, 20, 17, 55,
+			LOG4CXX_STR("foo2003-05-20yyyy.MM.dd}"));
+	}
 
-    void testFormatDate5() {
-        assertDatePattern(LOG4CXX_STR("foo%d{yyyy.MM.dd"),  2003, 4, 20, 17, 55,
-            LOG4CXX_STR("foo2003-05-20{yyyy.MM.dd"));
-    }
+	void testFormatDate5()
+	{
+		assertDatePattern(LOG4CXX_STR("foo%d{yyyy.MM.dd"),  2003, 4, 20, 17, 55,
+			LOG4CXX_STR("foo2003-05-20{yyyy.MM.dd"));
+	}
 
 };
 
@@ -185,5 +208,5 @@
 //   See bug LOGCXX-204
 //
 #if !defined(_MSC_VER) || _MSC_VER > 1200
-LOGUNIT_TEST_SUITE_REGISTRATION(FileNamePatternTestCase);
+	LOGUNIT_TEST_SUITE_REGISTRATION(FileNamePatternTestCase);
 #endif
diff --git a/src/test/cpp/rolling/filterbasedrollingtest.cpp b/src/test/cpp/rolling/filterbasedrollingtest.cpp
index c1e238a..c1f615b 100644
--- a/src/test/cpp/rolling/filterbasedrollingtest.cpp
+++ b/src/test/cpp/rolling/filterbasedrollingtest.cpp
@@ -38,106 +38,120 @@
  *
  * Tests of rolling file appender with a filter based triggering policy.
  *
- * 
- * 
+ *
+ *
  *
  */
-LOGUNIT_CLASS(FilterBasedRollingTest) {
-  LOGUNIT_TEST_SUITE(FilterBasedRollingTest);
-          LOGUNIT_TEST(test1);
-          LOGUNIT_TEST(test2);
-  LOGUNIT_TEST_SUITE_END();
+LOGUNIT_CLASS(FilterBasedRollingTest)
+{
+	LOGUNIT_TEST_SUITE(FilterBasedRollingTest);
+	LOGUNIT_TEST(test1);
+	LOGUNIT_TEST(test2);
+	LOGUNIT_TEST_SUITE_END();
 
 public:
-  void tearDown() {
-    LogManager::getLoggerRepository()->resetConfiguration();
-  }
+	void tearDown()
+	{
+		LogManager::getLoggerRepository()->resetConfiguration();
+	}
 
-  /**
-   * Test basic rolling functionality using configuration file.
-   */
-  void test1() {
-    DOMConfigurator::configure(
-      "./input/rolling/filter1.xml" /*, LogManager::getLoggerRepository() */);
+	/**
+	 * Test basic rolling functionality using configuration file.
+	 */
+	void test1()
+	{
+		DOMConfigurator::configure(
+			"./input/rolling/filter1.xml" /*, LogManager::getLoggerRepository() */);
 
-    common(LOG4CXX_STR("output/filterBased-test1"));
-  }
+		common(LOG4CXX_STR("output/filterBased-test1"));
+	}
 
-  /**
-   * Test basic rolling functionality using explicit configuration.
-   * @remarks Test fails when run immediately after test1.
-   */
-  void test2()  {
-    LayoutPtr layout(new PatternLayout(LOG4CXX_STR("%m\n")));
-    RollingFileAppenderPtr rfa(new RollingFileAppender());
-    rfa->setName(LOG4CXX_STR("ROLLING"));
-    rfa->setLayout(layout);
+	/**
+	 * Test basic rolling functionality using explicit configuration.
+	 * @remarks Test fails when run immediately after test1.
+	 */
+	void test2()
+	{
+		LayoutPtr layout(new PatternLayout(LOG4CXX_STR("%m\n")));
+		RollingFileAppenderPtr rfa(new RollingFileAppender());
+		rfa->setName(LOG4CXX_STR("ROLLING"));
+		rfa->setLayout(layout);
 
-    FixedWindowRollingPolicyPtr swrp(new FixedWindowRollingPolicy());
-    FilterBasedTriggeringPolicyPtr fbtp(new FilterBasedTriggeringPolicy());
+		FixedWindowRollingPolicyPtr swrp(new FixedWindowRollingPolicy());
+		FilterBasedTriggeringPolicyPtr fbtp(new FilterBasedTriggeringPolicy());
 
-    LevelRangeFilterPtr rf(new LevelRangeFilter());
-    rf->setLevelMin(Level::getInfo());
-    fbtp->addFilter(rf);
+		LevelRangeFilterPtr rf(new LevelRangeFilter());
+		rf->setLevelMin(Level::getInfo());
+		fbtp->addFilter(rf);
 
-    Pool p;
-    fbtp->activateOptions(p);
+		Pool p;
+		fbtp->activateOptions(p);
 
-    swrp->setMinIndex(0);
-    rfa->setFile(LOG4CXX_STR("output/filterBased-test2.log"));
-    rfa->setAppend(false);
+		swrp->setMinIndex(0);
+		rfa->setFile(LOG4CXX_STR("output/filterBased-test2.log"));
+		rfa->setAppend(false);
 
-    swrp->setFileNamePattern(LOG4CXX_STR("output/filterBased-test2.%i"));
-    swrp->activateOptions(p);
+		swrp->setFileNamePattern(LOG4CXX_STR("output/filterBased-test2.%i"));
+		swrp->activateOptions(p);
 
-    rfa->setRollingPolicy(swrp);
-    rfa->setTriggeringPolicy(fbtp);
-    rfa->activateOptions(p);
-    Logger::getRootLogger()->addAppender(rfa);
-    Logger::getRootLogger()->setLevel(Level::getDebug());
+		rfa->setRollingPolicy(swrp);
+		rfa->setTriggeringPolicy(fbtp);
+		rfa->activateOptions(p);
+		Logger::getRootLogger()->addAppender(rfa);
+		Logger::getRootLogger()->setLevel(Level::getDebug());
 
-    common(LOG4CXX_STR("output/filterBased-test2"));
-  }
+		common(LOG4CXX_STR("output/filterBased-test2"));
+	}
 
 private:
-  /**
-   *   Common aspects of test1 and test2
-   */
-  void common(const LogString& baseName)  {
-    LoggerPtr logger(Logger::getLogger("org.apache.log4j.rolling.FilterBasedRollingTest"));
+	/**
+	 *   Common aspects of test1 and test2
+	 */
+	void common(const LogString & baseName)
+	{
+		LoggerPtr logger(Logger::getLogger("org.apache.log4j.rolling.FilterBasedRollingTest"));
 
-    // Write exactly 10 bytes with each log
-    for (int i = 0; i < 25; i++) {
-      char msg[10];
+		// Write exactly 10 bytes with each log
+		for (int i = 0; i < 25; i++)
+		{
+			char msg[10];
 #if defined(__STDC_LIB_EXT1__) || defined(__STDC_SECURE_LIB__)
-      strcpy_s(msg, sizeof msg, "Hello---?");
+			strcpy_s(msg, sizeof msg, "Hello---?");
 #else
-      strcpy(msg, "Hello---?");
+			strcpy(msg, "Hello---?");
 #endif
-      if (i < 10) {
-        msg[8] = (char) ('0' + i);
-        LOG4CXX_DEBUG(logger, msg);
-      } else if (i < 100) {
-        msg[7] = (char) ('0' + (i / 10));
-        msg[8] = (char) ('0' + (i % 10));
-        if ((i % 10) == 0) {
-          LOG4CXX_WARN(logger, msg);
-        } else {
-          LOG4CXX_DEBUG(logger, msg);
-        }
-      }
-    }
 
-    //
-    //  test was constructed to mimic SizeBasedRollingTest.test2
-    //
-    LOGUNIT_ASSERT_EQUAL(true,
-      Compare::compare(baseName + LOG4CXX_STR(".log"), LogString(LOG4CXX_STR("witness/rolling/sbr-test2.log"))));
-    LOGUNIT_ASSERT_EQUAL(true,
-      Compare::compare(baseName + LOG4CXX_STR(".0"), LogString(LOG4CXX_STR("witness/rolling/sbr-test2.0"))));
-    LOGUNIT_ASSERT_EQUAL(true,
-      Compare::compare(baseName + LOG4CXX_STR(".1"), LogString(LOG4CXX_STR("witness/rolling/sbr-test2.1"))));
-  }
+			if (i < 10)
+			{
+				msg[8] = (char) ('0' + i);
+				LOG4CXX_DEBUG(logger, msg);
+			}
+			else if (i < 100)
+			{
+				msg[7] = (char) ('0' + (i / 10));
+				msg[8] = (char) ('0' + (i % 10));
+
+				if ((i % 10) == 0)
+				{
+					LOG4CXX_WARN(logger, msg);
+				}
+				else
+				{
+					LOG4CXX_DEBUG(logger, msg);
+				}
+			}
+		}
+
+		//
+		//  test was constructed to mimic SizeBasedRollingTest.test2
+		//
+		LOGUNIT_ASSERT_EQUAL(true,
+			Compare::compare(baseName + LOG4CXX_STR(".log"), LogString(LOG4CXX_STR("witness/rolling/sbr-test2.log"))));
+		LOGUNIT_ASSERT_EQUAL(true,
+			Compare::compare(baseName + LOG4CXX_STR(".0"), LogString(LOG4CXX_STR("witness/rolling/sbr-test2.0"))));
+		LOGUNIT_ASSERT_EQUAL(true,
+			Compare::compare(baseName + LOG4CXX_STR(".1"), LogString(LOG4CXX_STR("witness/rolling/sbr-test2.1"))));
+	}
 };
 
 LOGUNIT_TEST_SUITE_REGISTRATION(FilterBasedRollingTest);
diff --git a/src/test/cpp/rolling/manualrollingtest.cpp b/src/test/cpp/rolling/manualrollingtest.cpp
index 4e479ac..188d4f3 100644
--- a/src/test/cpp/rolling/manualrollingtest.cpp
+++ b/src/test/cpp/rolling/manualrollingtest.cpp
@@ -43,252 +43,272 @@
 /**
  *   Tests of explicit manual rolling of RollingFileAppenders.
  *
- * 
+ *
  *
  */
-LOGUNIT_CLASS(ManualRollingTest)  {
-   LOGUNIT_TEST_SUITE(ManualRollingTest);
-           LOGUNIT_TEST(test1);
-           LOGUNIT_TEST(test2);
-//           TODO: Compression not yet implemented
-//           LOGUNIT_TEST(test3);
-           LOGUNIT_TEST(test4);
-           LOGUNIT_TEST(test5);
-   LOGUNIT_TEST_SUITE_END();
+LOGUNIT_CLASS(ManualRollingTest)
+{
+	LOGUNIT_TEST_SUITE(ManualRollingTest);
+	LOGUNIT_TEST(test1);
+	LOGUNIT_TEST(test2);
+	//           TODO: Compression not yet implemented
+	//           LOGUNIT_TEST(test3);
+	LOGUNIT_TEST(test4);
+	LOGUNIT_TEST(test5);
+	LOGUNIT_TEST_SUITE_END();
 
-   LoggerPtr root;
-   LoggerPtr logger;
+	LoggerPtr root;
+	LoggerPtr logger;
 
- public:
-  void setUp() {
-    logger = Logger::getLogger("org.apache.log4j.rolling.ManualRollingTest");
-    root = Logger::getRootLogger();
-  }
+public:
+	void setUp()
+	{
+		logger = Logger::getLogger("org.apache.log4j.rolling.ManualRollingTest");
+		root = Logger::getRootLogger();
+	}
 
-  void tearDown() {
-    LogManager::shutdown();
-  }
+	void tearDown()
+	{
+		LogManager::shutdown();
+	}
 
-  void common(RollingFileAppenderPtr& rfa,
-       Pool& pool,
-       LoggerPtr& logger1) {
-    char msg[] = { 'H', 'e', 'l', 'l', 'o', '-', '-', '-', 'N', 0 };
+	void common(RollingFileAppenderPtr & rfa,
+		Pool & pool,
+		LoggerPtr & logger1)
+	{
+		char msg[] = { 'H', 'e', 'l', 'l', 'o', '-', '-', '-', 'N', 0 };
 
-    // Write exactly 10 bytes with each log
-    for (int i = 0; i < 25; i++) {
-      if (i < 10) {
-        msg[8] = '0' + i;
-      } else if (i < 100) {
-        int digit = i % 10;
-        if (digit == 0) {
-          rfa->rollover(pool);
-        }
-        msg[7] = '0' + i / 10;
-        msg[8] = '0' + digit;
-      }
-      LOG4CXX_DEBUG(logger1, msg);
-    }
-  }
+		// Write exactly 10 bytes with each log
+		for (int i = 0; i < 25; i++)
+		{
+			if (i < 10)
+			{
+				msg[8] = '0' + i;
+			}
+			else if (i < 100)
+			{
+				int digit = i % 10;
+
+				if (digit == 0)
+				{
+					rfa->rollover(pool);
+				}
+
+				msg[7] = '0' + i / 10;
+				msg[8] = '0' + digit;
+			}
+
+			LOG4CXX_DEBUG(logger1, msg);
+		}
+	}
 
 
-  /**
-   * Tests that the lack of an explicit active file will use the
-   * low index as the active file.
-   *
-   */
-  void test1() {
-    PatternLayoutPtr layout = new PatternLayout(LOG4CXX_STR("%m\n"));
-    RollingFileAppenderPtr rfa = new RollingFileAppender();
-    rfa->setName(LOG4CXX_STR("ROLLING"));
-    rfa->setAppend(false);
-    rfa->setLayout(layout);
+	/**
+	 * Tests that the lack of an explicit active file will use the
+	 * low index as the active file.
+	 *
+	 */
+	void test1()
+	{
+		PatternLayoutPtr layout = new PatternLayout(LOG4CXX_STR("%m\n"));
+		RollingFileAppenderPtr rfa = new RollingFileAppender();
+		rfa->setName(LOG4CXX_STR("ROLLING"));
+		rfa->setAppend(false);
+		rfa->setLayout(layout);
 
-    FixedWindowRollingPolicyPtr swrp = new FixedWindowRollingPolicy();
-    swrp->setMinIndex(0);
+		FixedWindowRollingPolicyPtr swrp = new FixedWindowRollingPolicy();
+		swrp->setMinIndex(0);
 
-    swrp->setFileNamePattern(LOG4CXX_STR("output/manual-test1.%i"));
-    Pool p;
-    swrp->activateOptions(p);
+		swrp->setFileNamePattern(LOG4CXX_STR("output/manual-test1.%i"));
+		Pool p;
+		swrp->activateOptions(p);
 
-    rfa->setRollingPolicy(swrp);
-    rfa->activateOptions(p);
-    root->addAppender(rfa);
+		rfa->setRollingPolicy(swrp);
+		rfa->activateOptions(p);
+		root->addAppender(rfa);
 
 
-    common(rfa, p, logger);
+		common(rfa, p, logger);
 
-    LOGUNIT_ASSERT_EQUAL(true, File("output/manual-test1.0").exists(p));
-    LOGUNIT_ASSERT_EQUAL(true, File("output/manual-test1.1").exists(p));
-    LOGUNIT_ASSERT_EQUAL(true, File("output/manual-test1.2").exists(p));
-    LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/manual-test1.0"),
-     File("witness/rolling/sbr-test2.log")));
-    LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/manual-test1.1"),
-     File("witness/rolling/sbr-test2.0")));
-    LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/manual-test1.2"),
-     File("witness/rolling/sbr-test2.1")));
-  }
+		LOGUNIT_ASSERT_EQUAL(true, File("output/manual-test1.0").exists(p));
+		LOGUNIT_ASSERT_EQUAL(true, File("output/manual-test1.1").exists(p));
+		LOGUNIT_ASSERT_EQUAL(true, File("output/manual-test1.2").exists(p));
+		LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/manual-test1.0"),
+				File("witness/rolling/sbr-test2.log")));
+		LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/manual-test1.1"),
+				File("witness/rolling/sbr-test2.0")));
+		LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/manual-test1.2"),
+				File("witness/rolling/sbr-test2.1")));
+	}
 
-  /**
-   * Test basic rolling functionality with explicit setting of FileAppender.file.
-   */
-  void test2() {
-    PatternLayoutPtr layout = new PatternLayout(LOG4CXX_STR("%m\n"));
-    RollingFileAppenderPtr rfa = new RollingFileAppender();
-    rfa->setName(LOG4CXX_STR("ROLLING"));
-    rfa->setAppend(false);
-    rfa->setLayout(layout);
-    rfa->setFile(LOG4CXX_STR("output/manual-test2.log"));
+	/**
+	 * Test basic rolling functionality with explicit setting of FileAppender.file.
+	 */
+	void test2()
+	{
+		PatternLayoutPtr layout = new PatternLayout(LOG4CXX_STR("%m\n"));
+		RollingFileAppenderPtr rfa = new RollingFileAppender();
+		rfa->setName(LOG4CXX_STR("ROLLING"));
+		rfa->setAppend(false);
+		rfa->setLayout(layout);
+		rfa->setFile(LOG4CXX_STR("output/manual-test2.log"));
 
-    Pool p;
-    rfa->activateOptions(p);
-    root->addAppender(rfa);
+		Pool p;
+		rfa->activateOptions(p);
+		root->addAppender(rfa);
 
-    common(rfa, p, logger);
+		common(rfa, p, logger);
 
-    LOGUNIT_ASSERT_EQUAL(true, File("output/manual-test2.log").exists(p));
-    LOGUNIT_ASSERT_EQUAL(true, File("output/manual-test2.log.1").exists(p));
-    LOGUNIT_ASSERT_EQUAL(true, File("output/manual-test2.log.2").exists(p));
+		LOGUNIT_ASSERT_EQUAL(true, File("output/manual-test2.log").exists(p));
+		LOGUNIT_ASSERT_EQUAL(true, File("output/manual-test2.log.1").exists(p));
+		LOGUNIT_ASSERT_EQUAL(true, File("output/manual-test2.log.2").exists(p));
 
-    LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/manual-test2.log"),
-     File("witness/rolling/sbr-test2.log")));
-    LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/manual-test2.log.1"),
-     File("witness/rolling/sbr-test2.0")));
-    LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/manual-test2.log.2"),
-     File("witness/rolling/sbr-test2.1")));
-  }
+		LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/manual-test2.log"),
+				File("witness/rolling/sbr-test2.log")));
+		LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/manual-test2.log.1"),
+				File("witness/rolling/sbr-test2.0")));
+		LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/manual-test2.log.2"),
+				File("witness/rolling/sbr-test2.1")));
+	}
 
-  /**
-   * Same as testBasic but also with GZ compression.
-   */
-  void test3() {
-    PatternLayoutPtr layout = new PatternLayout(LOG4CXX_STR("%m\n"));
-    RollingFileAppenderPtr rfa = new RollingFileAppender();
-    rfa->setAppend(false);
-    rfa->setLayout(layout);
+	/**
+	 * Same as testBasic but also with GZ compression.
+	 */
+	void test3()
+	{
+		PatternLayoutPtr layout = new PatternLayout(LOG4CXX_STR("%m\n"));
+		RollingFileAppenderPtr rfa = new RollingFileAppender();
+		rfa->setAppend(false);
+		rfa->setLayout(layout);
 
-    FixedWindowRollingPolicyPtr  fwrp = new FixedWindowRollingPolicy();
+		FixedWindowRollingPolicyPtr  fwrp = new FixedWindowRollingPolicy();
 
-    fwrp->setMinIndex(0);
-    rfa->setFile(LOG4CXX_STR("output/manual-test3.log"));
-    fwrp->setFileNamePattern(LOG4CXX_STR("output/sbr-test3.%i.gz"));
-    Pool p;
-    fwrp->activateOptions(p);
-    rfa->setRollingPolicy(fwrp);
-    rfa->activateOptions(p);
-    root->addAppender(rfa);
+		fwrp->setMinIndex(0);
+		rfa->setFile(LOG4CXX_STR("output/manual-test3.log"));
+		fwrp->setFileNamePattern(LOG4CXX_STR("output/sbr-test3.%i.gz"));
+		Pool p;
+		fwrp->activateOptions(p);
+		rfa->setRollingPolicy(fwrp);
+		rfa->activateOptions(p);
+		root->addAppender(rfa);
 
-    common(rfa, p, logger);
+		common(rfa, p, logger);
 
-    LOGUNIT_ASSERT_EQUAL(true, File("output/manual-test3.log").exists(p));
-    LOGUNIT_ASSERT_EQUAL(true, File("output/manual-test3.0.gz").exists(p));
-    LOGUNIT_ASSERT_EQUAL(true, File("output/manual-test3.1.gz").exists(p));
+		LOGUNIT_ASSERT_EQUAL(true, File("output/manual-test3.log").exists(p));
+		LOGUNIT_ASSERT_EQUAL(true, File("output/manual-test3.0.gz").exists(p));
+		LOGUNIT_ASSERT_EQUAL(true, File("output/manual-test3.1.gz").exists(p));
 
-    LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/manual-test3.log"),  File("witness/rolling/sbr-test3.log")));
-    LOGUNIT_ASSERT_EQUAL(File("witness/rolling/sbr-test3.0.gz").length(p), File("output/manual-test3.0.gz").length(p));
-    LOGUNIT_ASSERT_EQUAL(File("witness/rolling/sbr-test3.1.gz").length(p), File("output/manual-test3.1.gz").length(p));
-  }
+		LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/manual-test3.log"),  File("witness/rolling/sbr-test3.log")));
+		LOGUNIT_ASSERT_EQUAL(File("witness/rolling/sbr-test3.0.gz").length(p), File("output/manual-test3.0.gz").length(p));
+		LOGUNIT_ASSERT_EQUAL(File("witness/rolling/sbr-test3.1.gz").length(p), File("output/manual-test3.1.gz").length(p));
+	}
 
-  /**
-   * Test basic rolling functionality with bogus path in file name pattern.
-   */
-  void test4() {
-    PatternLayoutPtr layout = new PatternLayout(LOG4CXX_STR("%m\n"));
-    RollingFileAppenderPtr rfa = new RollingFileAppender();
-    rfa->setName(LOG4CXX_STR("ROLLING"));
-    rfa->setAppend(false);
-    rfa->setLayout(layout);
-    rfa->setFile(LOG4CXX_STR("output/manual-test4.log"));
+	/**
+	 * Test basic rolling functionality with bogus path in file name pattern.
+	 */
+	void test4()
+	{
+		PatternLayoutPtr layout = new PatternLayout(LOG4CXX_STR("%m\n"));
+		RollingFileAppenderPtr rfa = new RollingFileAppender();
+		rfa->setName(LOG4CXX_STR("ROLLING"));
+		rfa->setAppend(false);
+		rfa->setLayout(layout);
+		rfa->setFile(LOG4CXX_STR("output/manual-test4.log"));
 
-    FixedWindowRollingPolicyPtr swrp = new FixedWindowRollingPolicy();
+		FixedWindowRollingPolicyPtr swrp = new FixedWindowRollingPolicy();
 
-    swrp->setMinIndex(0);
+		swrp->setMinIndex(0);
 
-    //
-    //   test4 directory should not exists.  Should cause all rollover attempts to fail.
-    //
-    swrp->setFileNamePattern(LOG4CXX_STR("output/test4/manual-test4.%i"));
-    Pool p;
-    swrp->activateOptions(p);
+		//
+		//   test4 directory should not exists.  Should cause all rollover attempts to fail.
+		//
+		swrp->setFileNamePattern(LOG4CXX_STR("output/test4/manual-test4.%i"));
+		Pool p;
+		swrp->activateOptions(p);
 
-    rfa->setRollingPolicy(swrp);
-    rfa->activateOptions(p);
-    root->addAppender(rfa);
+		rfa->setRollingPolicy(swrp);
+		rfa->activateOptions(p);
+		root->addAppender(rfa);
 
-    common(rfa, p, logger);
+		common(rfa, p, logger);
 
-    LOGUNIT_ASSERT_EQUAL(true, File("output/manual-test4.log").exists(p));
+		LOGUNIT_ASSERT_EQUAL(true, File("output/manual-test4.log").exists(p));
 
-    LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/manual-test4.log"),
-     File("witness/rolling/sbr-test4.log")));
-  }
+		LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/manual-test4.log"),
+				File("witness/rolling/sbr-test4.log")));
+	}
 
-  /**
-   * Checking handling of rename failures due to other access
-   * to the indexed files.
-   */
-  void test5()  {
-    PatternLayoutPtr layout = new PatternLayout(LOG4CXX_STR("%m\n"));
-    RollingFileAppenderPtr rfa = new RollingFileAppender();
-    rfa->setName(LOG4CXX_STR("ROLLING"));
-    rfa->setAppend(false);
-    rfa->setLayout(layout);
-    rfa->setFile(LOG4CXX_STR("output/manual-test5.log"));
+	/**
+	 * Checking handling of rename failures due to other access
+	 * to the indexed files.
+	 */
+	void test5()
+	{
+		PatternLayoutPtr layout = new PatternLayout(LOG4CXX_STR("%m\n"));
+		RollingFileAppenderPtr rfa = new RollingFileAppender();
+		rfa->setName(LOG4CXX_STR("ROLLING"));
+		rfa->setAppend(false);
+		rfa->setLayout(layout);
+		rfa->setFile(LOG4CXX_STR("output/manual-test5.log"));
 
-    FixedWindowRollingPolicyPtr swrp = new FixedWindowRollingPolicy();
+		FixedWindowRollingPolicyPtr swrp = new FixedWindowRollingPolicy();
 
-    swrp->setMinIndex(0);
+		swrp->setMinIndex(0);
 
-    swrp->setFileNamePattern(LOG4CXX_STR("output/manual-test5.%i"));
-    Pool p;
-    swrp->activateOptions(p);
+		swrp->setFileNamePattern(LOG4CXX_STR("output/manual-test5.%i"));
+		Pool p;
+		swrp->activateOptions(p);
 
-    rfa->setRollingPolicy(swrp);
-    rfa->activateOptions(p);
-    root->addAppender(rfa);
+		rfa->setRollingPolicy(swrp);
+		rfa->activateOptions(p);
+		root->addAppender(rfa);
 
-    //
-    //   put stray file about locked file
-    FileOutputStream os1(LOG4CXX_STR("output/manual-test5.1"), false);
-    os1.close(p);
+		//
+		//   put stray file about locked file
+		FileOutputStream os1(LOG4CXX_STR("output/manual-test5.1"), false);
+		os1.close(p);
 
 
-    FileOutputStream os0(LOG4CXX_STR("output/manual-test5.0"), false);
+		FileOutputStream os0(LOG4CXX_STR("output/manual-test5.0"), false);
 
-    common(rfa, p, logger);
+		common(rfa, p, logger);
 
-    os0.close(p);
+		os0.close(p);
 
-    if (File("output/manual-test5.3").exists(p)) {
-      //
-      //    looks like platform where open files can be renamed
-      //
-      LOGUNIT_ASSERT_EQUAL(true, File("output/manual-test5.log").exists(p));
-      LOGUNIT_ASSERT_EQUAL(true, File("output/manual-test5.0").exists(p));
-      LOGUNIT_ASSERT_EQUAL(true, File("output/manual-test5.1").exists(p));
-      LOGUNIT_ASSERT_EQUAL(true, File("output/manual-test5.2").exists(p));
-      LOGUNIT_ASSERT_EQUAL(true, File("output/manual-test5.3").exists(p));
+		if (File("output/manual-test5.3").exists(p))
+		{
+			//
+			//    looks like platform where open files can be renamed
+			//
+			LOGUNIT_ASSERT_EQUAL(true, File("output/manual-test5.log").exists(p));
+			LOGUNIT_ASSERT_EQUAL(true, File("output/manual-test5.0").exists(p));
+			LOGUNIT_ASSERT_EQUAL(true, File("output/manual-test5.1").exists(p));
+			LOGUNIT_ASSERT_EQUAL(true, File("output/manual-test5.2").exists(p));
+			LOGUNIT_ASSERT_EQUAL(true, File("output/manual-test5.3").exists(p));
 
-      LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/manual-test5.log"),
-       File("witness/rolling/sbr-test2.log")));
-      LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/manual-test5.0"),
-       File("witness/rolling/sbr-test2.0")));
-      LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/manual-test5.1"),
-       File("witness/rolling/sbr-test2.1")));
+			LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/manual-test5.log"),
+					File("witness/rolling/sbr-test2.log")));
+			LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/manual-test5.0"),
+					File("witness/rolling/sbr-test2.0")));
+			LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/manual-test5.1"),
+					File("witness/rolling/sbr-test2.1")));
 
-    } else {
-      //
-      //  rollover attempts should all fail
-      //    so initial log file should have all log content
-      //    open file should be unaffected
-      //    stray file should have only been moved one slot.
-      LOGUNIT_ASSERT_EQUAL(true, File("output/manual-test5.log").exists(p));
-      LOGUNIT_ASSERT_EQUAL(true, File("output/manual-test5.0").exists(p));
-      LOGUNIT_ASSERT_EQUAL(true, File("output/manual-test5.2").exists(p));
+		}
+		else
+		{
+			//
+			//  rollover attempts should all fail
+			//    so initial log file should have all log content
+			//    open file should be unaffected
+			//    stray file should have only been moved one slot.
+			LOGUNIT_ASSERT_EQUAL(true, File("output/manual-test5.log").exists(p));
+			LOGUNIT_ASSERT_EQUAL(true, File("output/manual-test5.0").exists(p));
+			LOGUNIT_ASSERT_EQUAL(true, File("output/manual-test5.2").exists(p));
 
-      LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/manual-test5.log"),
-          File("witness/rolling/sbr-test4.log")));
-    }
-  }
+			LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/manual-test5.log"),
+					File("witness/rolling/sbr-test4.log")));
+		}
+	}
 
 };
 
diff --git a/src/test/cpp/rolling/obsoletedailyrollingfileappendertest.cpp b/src/test/cpp/rolling/obsoletedailyrollingfileappendertest.cpp
index 7e18e87..d04e50c 100644
--- a/src/test/cpp/rolling/obsoletedailyrollingfileappendertest.cpp
+++ b/src/test/cpp/rolling/obsoletedailyrollingfileappendertest.cpp
@@ -43,92 +43,102 @@
 /**
  * Tests the emulation of org.apache.log4j.DailyRollingFileAppender
  *
- * 
+ *
  *
  */
-LOGUNIT_CLASS(ObsoleteDailyRollingFileAppenderTest)  {
-  LOGUNIT_TEST_SUITE(ObsoleteDailyRollingFileAppenderTest);
-          LOGUNIT_TEST(test1);
-          LOGUNIT_TEST(test2);
-  LOGUNIT_TEST_SUITE_END();
+LOGUNIT_CLASS(ObsoleteDailyRollingFileAppenderTest)
+{
+	LOGUNIT_TEST_SUITE(ObsoleteDailyRollingFileAppenderTest);
+	LOGUNIT_TEST(test1);
+	LOGUNIT_TEST(test2);
+	LOGUNIT_TEST_SUITE_END();
 
 
 public:
 
-  void tearDown() {
-    LogManager::shutdown();
-  }
+	void tearDown()
+	{
+		LogManager::shutdown();
+	}
 
-  /**
-   * Test basic rolling functionality.
-   */
-  void test1() {
-    PropertyConfigurator::configure(File("input/rolling/obsoleteDRFA1.properties"));
+	/**
+	 * Test basic rolling functionality.
+	 */
+	void test1()
+	{
+		PropertyConfigurator::configure(File("input/rolling/obsoleteDRFA1.properties"));
 
-    int preCount = getFileCount("output", LOG4CXX_STR("obsoleteDRFA-test1.log."));
-    LoggerPtr logger(Logger::getLogger("org.apache.log4j.ObsoleteDailyRollingFileAppenderTest"));
+		int preCount = getFileCount("output", LOG4CXX_STR("obsoleteDRFA-test1.log."));
+		LoggerPtr logger(Logger::getLogger("org.apache.log4j.ObsoleteDailyRollingFileAppenderTest"));
 
-    char msg[11];
-    strcpy(msg, "Hello---??");
+		char msg[11];
+		strcpy(msg, "Hello---??");
 
-    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);
-    }
+		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);
-  }
+		int postCount = getFileCount("output", LOG4CXX_STR("obsoleteDRFA-test1.log."));
+		LOGUNIT_ASSERT_EQUAL(true, postCount > preCount);
+	}
 
-  /**
-   * Test basic rolling functionality.
-   * @deprecated Class under test is deprecated.
-   */
-  void test2() {
-    PatternLayoutPtr layout(new PatternLayout(LOG4CXX_STR("%m%n")));
-    log4cxx::DailyRollingFileAppenderPtr rfa(new log4cxx::DailyRollingFileAppender());
-    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("org.apache.log4j.ObsoleteDailyRollingAppenderTest"));
+	/**
+	 * Test basic rolling functionality.
+	 * @deprecated Class under test is deprecated.
+	 */
+	void test2()
+	{
+		PatternLayoutPtr layout(new PatternLayout(LOG4CXX_STR("%m%n")));
+		log4cxx::DailyRollingFileAppenderPtr rfa(new log4cxx::DailyRollingFileAppender());
+		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("org.apache.log4j.ObsoleteDailyRollingAppenderTest"));
 
-    int preCount = getFileCount("output", LOG4CXX_STR("obsoleteDRFA-test2.log."));
+		int preCount = getFileCount("output", LOG4CXX_STR("obsoleteDRFA-test2.log."));
 
-    char msg[11];
-    strcpy(msg, "Hello---??");
-    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);
-    }
+		char msg[11];
+		strcpy(msg, "Hello---??");
 
-    int postCount = getFileCount("output", LOG4CXX_STR("obsoleteDRFA-test2.log."));
-    LOGUNIT_ASSERT_EQUAL(true, postCount > preCount);
-  }
+		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);
+	}
 
 private:
-  static int getFileCount(const char* dir, const LogString& initial) {
-    Pool p;
-    std::vector<LogString> files(File(dir).list(p));
-    int count = 0;
+	static int getFileCount(const char* dir, const LogString & initial)
+	{
+		Pool p;
+		std::vector<LogString> files(File(dir).list(p));
+		int count = 0;
 
-    for (size_t i = 0; i < files.size(); i++) {
-      if (StringHelper::startsWith(files[i], initial)) {
-        count++;
-      }
-    }
+		for (size_t i = 0; i < files.size(); i++)
+		{
+			if (StringHelper::startsWith(files[i], initial))
+			{
+				count++;
+			}
+		}
 
-    return count;
-  }
+		return count;
+	}
 };
 
 LOGUNIT_TEST_SUITE_REGISTRATION(ObsoleteDailyRollingFileAppenderTest);
diff --git a/src/test/cpp/rolling/obsoleterollingfileappendertest.cpp b/src/test/cpp/rolling/obsoleterollingfileappendertest.cpp
index c3840fb..a7ead2b 100644
--- a/src/test/cpp/rolling/obsoleterollingfileappendertest.cpp
+++ b/src/test/cpp/rolling/obsoleterollingfileappendertest.cpp
@@ -31,113 +31,127 @@
 #include <log4cxx/rollingfileappender.h>
 #include <log4cxx/helpers/stringhelper.h>
 
- using namespace log4cxx;
- using namespace log4cxx::xml;
- using namespace log4cxx::filter;
- using namespace log4cxx::helpers;
+using namespace log4cxx;
+using namespace log4cxx::xml;
+using namespace log4cxx::filter;
+using namespace log4cxx::helpers;
 
 /**
  * Tests the emulation of org.apache.log4j.RollingFileAppender
  *
- * 
+ *
  *
  */
- LOGUNIT_CLASS(ObsoleteRollingFileAppenderTest)  {
-   LOGUNIT_TEST_SUITE(ObsoleteRollingFileAppenderTest);
-           LOGUNIT_TEST(test1);
-           LOGUNIT_TEST(test2);
-           LOGUNIT_TEST(testIsOptionHandler);
-           LOGUNIT_TEST(testClassForName);
-   LOGUNIT_TEST_SUITE_END();
+LOGUNIT_CLASS(ObsoleteRollingFileAppenderTest)
+{
+	LOGUNIT_TEST_SUITE(ObsoleteRollingFileAppenderTest);
+	LOGUNIT_TEST(test1);
+	LOGUNIT_TEST(test2);
+	LOGUNIT_TEST(testIsOptionHandler);
+	LOGUNIT_TEST(testClassForName);
+	LOGUNIT_TEST_SUITE_END();
 
 
- public:
+public:
 
-  void tearDown() {
-    LogManager::shutdown();
-  }
+	void tearDown()
+	{
+		LogManager::shutdown();
+	}
 
-  /**
-   * Test basic rolling functionality.
-   */
-  void test1() {
-    PropertyConfigurator::configure(File("input/rolling/obsoleteRFA1.properties"));
+	/**
+	 * Test basic rolling functionality.
+	 */
+	void test1()
+	{
+		PropertyConfigurator::configure(File("input/rolling/obsoleteRFA1.properties"));
 
-    char msg[] = { 'H', 'e', 'l', 'l', 'o', '-', '-', '-', '?', 0};
-    LoggerPtr logger(Logger::getLogger("org.apache.logj4.ObsoleteRollingFileAppenderTest"));
+		char msg[] = { 'H', 'e', 'l', 'l', 'o', '-', '-', '-', '?', 0};
+		LoggerPtr logger(Logger::getLogger("org.apache.logj4.ObsoleteRollingFileAppenderTest"));
 
-    // Write exactly 10 bytes with each log
-    for (int i = 0; i < 25; i++) {
-      apr_sleep(100000);
+		// Write exactly 10 bytes with each log
+		for (int i = 0; i < 25; i++)
+		{
+			apr_sleep(100000);
 
-      if (i < 10) {
-        msg[8] = (char) ('0' + i);
-        LOG4CXX_DEBUG(logger, msg);
-      } else if (i < 100) {
-        msg[7] = (char) ('0' + i / 10);
-        msg[8] = (char) ('0' + i % 10);
-        LOG4CXX_DEBUG(logger, msg);
-      }
-    }
+			if (i < 10)
+			{
+				msg[8] = (char) ('0' + i);
+				LOG4CXX_DEBUG(logger, msg);
+			}
+			else if (i < 100)
+			{
+				msg[7] = (char) ('0' + i / 10);
+				msg[8] = (char) ('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));
-  }
+		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.
-   * @deprecated Class under test is deprecated.
-   */
-  void test2()  {
-    PatternLayoutPtr layout(new PatternLayout(LOG4CXX_STR("%m\n")));
-    log4cxx::RollingFileAppenderPtr rfa(
-      new log4cxx::RollingFileAppender());
-    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);
-    LoggerPtr root(Logger::getRootLogger());
-    root->addAppender(rfa);
+	/**
+	 * Test basic rolling functionality.
+	 * @deprecated Class under test is deprecated.
+	 */
+	void test2()
+	{
+		PatternLayoutPtr layout(new PatternLayout(LOG4CXX_STR("%m\n")));
+		log4cxx::RollingFileAppenderPtr rfa(
+			new log4cxx::RollingFileAppender());
+		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);
+		LoggerPtr root(Logger::getRootLogger());
+		root->addAppender(rfa);
 
-    char msg[] = { 'H', 'e', 'l', 'l', 'o', '-', '-', '-', '?', 0};
-    LoggerPtr logger(Logger::getLogger("org.apache.logj4.ObsoleteRollingFileAppenderTest"));
+		char msg[] = { 'H', 'e', 'l', 'l', 'o', '-', '-', '-', '?', 0};
+		LoggerPtr logger(Logger::getLogger("org.apache.logj4.ObsoleteRollingFileAppenderTest"));
 
-    // Write exactly 10 bytes with each log
-    for (int i = 0; i < 25; i++) {
-      apr_sleep(100000);
+		// Write exactly 10 bytes with each log
+		for (int i = 0; i < 25; i++)
+		{
+			apr_sleep(100000);
 
-      if (i < 10) {
-        msg[8] = (char) ('0' + i);
-        LOG4CXX_DEBUG(logger, msg);
-      } else if (i < 100) {
-        msg[7] = (char) ('0' + i / 10);
-        msg[8] = (char) ('0' + i % 10);
-        LOG4CXX_DEBUG(logger, msg);
-      }
-    }
+			if (i < 10)
+			{
+				msg[8] = (char) ('0' + i);
+				LOG4CXX_DEBUG(logger, msg);
+			}
+			else if (i < 100)
+			{
+				msg[7] = (char) ('0' + i / 10);
+				msg[8] = (char) ('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));
-  }
+		LOGUNIT_ASSERT_EQUAL(true, File("output/obsoleteRFA-test2.log").exists(p));
+		LOGUNIT_ASSERT_EQUAL(true, File("output/obsoleteRFA-test2.log.1").exists(p));
+	}
 
-  /**
-   *  Tests if class is declared to support the OptionHandler interface.
-   *  See LOGCXX-136.
-   */
-  void testIsOptionHandler() {
-      RollingFileAppenderPtr rfa(new RollingFileAppender());
-      LOGUNIT_ASSERT_EQUAL(true, rfa->instanceof(log4cxx::spi::OptionHandler::getStaticClass()));
-  }
+	/**
+	 *  Tests if class is declared to support the OptionHandler interface.
+	 *  See LOGCXX-136.
+	 */
+	void testIsOptionHandler()
+	{
+		RollingFileAppenderPtr rfa(new RollingFileAppender());
+		LOGUNIT_ASSERT_EQUAL(true, rfa->instanceof(log4cxx::spi::OptionHandler::getStaticClass()));
+	}
 
-  void testClassForName() {
-      LogString className(LOG4CXX_STR("org.apache.log4j.RollingFileAppender"));
-      const Class& myclass = Class::forName(className);
-      LOGUNIT_ASSERT_EQUAL(className, LogString(myclass.getName()));
-  }
+	void testClassForName()
+	{
+		LogString className(LOG4CXX_STR("org.apache.log4j.RollingFileAppender"));
+		const Class& myclass = Class::forName(className);
+		LOGUNIT_ASSERT_EQUAL(className, LogString(myclass.getName()));
+	}
 };
 
 LOGUNIT_TEST_SUITE_REGISTRATION(ObsoleteRollingFileAppenderTest);
diff --git a/src/test/cpp/rolling/sizebasedrollingtest.cpp b/src/test/cpp/rolling/sizebasedrollingtest.cpp
index e036b3c..ccee138 100644
--- a/src/test/cpp/rolling/sizebasedrollingtest.cpp
+++ b/src/test/cpp/rolling/sizebasedrollingtest.cpp
@@ -44,307 +44,325 @@
  *
  * Do not forget to call activateOptions when configuring programatically.
  *
- * 
+ *
  *
  */
-LOGUNIT_CLASS(SizeBasedRollingTest)  {
-   LOGUNIT_TEST_SUITE(SizeBasedRollingTest);
-           LOGUNIT_TEST(test1);
-           LOGUNIT_TEST(test2);
-           LOGUNIT_TEST(test3);
-           LOGUNIT_TEST(test4);
-           LOGUNIT_TEST(test5);
-           LOGUNIT_TEST(test6);
-   LOGUNIT_TEST_SUITE_END();
+LOGUNIT_CLASS(SizeBasedRollingTest)
+{
+	LOGUNIT_TEST_SUITE(SizeBasedRollingTest);
+	LOGUNIT_TEST(test1);
+	LOGUNIT_TEST(test2);
+	LOGUNIT_TEST(test3);
+	LOGUNIT_TEST(test4);
+	LOGUNIT_TEST(test5);
+	LOGUNIT_TEST(test6);
+	LOGUNIT_TEST_SUITE_END();
 
-   LoggerPtr root;
-   LoggerPtr logger;
+	LoggerPtr root;
+	LoggerPtr logger;
 
- public:
-  void setUp() {
-    PatternLayoutPtr layout(new PatternLayout(LOG4CXX_STR("%d %level %c -%m%n")));
-    AppenderPtr ca(new ConsoleAppender(layout));
-    ca->setName(LOG4CXX_STR("CONSOLE"));
-    root = Logger::getRootLogger();
-    root->addAppender(ca);
-    logger = Logger::getLogger("org.apache.log4j.rolling.SizeBasedRollingTest");
-  }
+public:
+	void setUp()
+	{
+		PatternLayoutPtr layout(new PatternLayout(LOG4CXX_STR("%d %level %c -%m%n")));
+		AppenderPtr ca(new ConsoleAppender(layout));
+		ca->setName(LOG4CXX_STR("CONSOLE"));
+		root = Logger::getRootLogger();
+		root->addAppender(ca);
+		logger = Logger::getLogger("org.apache.log4j.rolling.SizeBasedRollingTest");
+	}
 
-  void tearDown() {
-    LogManager::shutdown();
-  }
+	void tearDown()
+	{
+		LogManager::shutdown();
+	}
 
-  void common(LoggerPtr& logger1, int /*sleep*/) {
-    char msg[] = { 'H', 'e', 'l', 'l', 'o', '-', '-', '-', 'N', 0 };
+	void common(LoggerPtr & logger1, int /*sleep*/)
+	{
+		char msg[] = { 'H', 'e', 'l', 'l', 'o', '-', '-', '-', 'N', 0 };
 
-    // Write exactly 10 bytes with each log
-    for (int i = 0; i < 25; i++) {
-      if (i < 10) {
-        msg[8] = '0' + i;
-      } else if (i < 100) {
-        msg[7] = '0' + i / 10;
-        msg[8] = '0' + i % 10;
-      }
-      LOG4CXX_DEBUG(logger1, msg);
-    }
-  }
+		// Write exactly 10 bytes with each log
+		for (int i = 0; i < 25; i++)
+		{
+			if (i < 10)
+			{
+				msg[8] = '0' + i;
+			}
+			else if (i < 100)
+			{
+				msg[7] = '0' + i / 10;
+				msg[8] = '0' + i % 10;
+			}
+
+			LOG4CXX_DEBUG(logger1, msg);
+		}
+	}
 
 
-  /**
-   * Tests that the lack of an explicit active file will use the
-   * low index as the active file.
-   *
-   */
-  void test1() {
-    PatternLayoutPtr layout = new PatternLayout(LOG4CXX_STR("%m\n"));
-    RollingFileAppenderPtr rfa = new RollingFileAppender();
-    rfa->setName(LOG4CXX_STR("ROLLING"));
-    rfa->setAppend(false);
-    rfa->setLayout(layout);
+	/**
+	 * Tests that the lack of an explicit active file will use the
+	 * low index as the active file.
+	 *
+	 */
+	void test1()
+	{
+		PatternLayoutPtr layout = new PatternLayout(LOG4CXX_STR("%m\n"));
+		RollingFileAppenderPtr rfa = new RollingFileAppender();
+		rfa->setName(LOG4CXX_STR("ROLLING"));
+		rfa->setAppend(false);
+		rfa->setLayout(layout);
 
-    FixedWindowRollingPolicyPtr swrp = new FixedWindowRollingPolicy();
-    SizeBasedTriggeringPolicyPtr sbtp = new SizeBasedTriggeringPolicy();
+		FixedWindowRollingPolicyPtr swrp = new FixedWindowRollingPolicy();
+		SizeBasedTriggeringPolicyPtr sbtp = new SizeBasedTriggeringPolicy();
 
-    sbtp->setMaxFileSize(100);
-    swrp->setMinIndex(0);
+		sbtp->setMaxFileSize(100);
+		swrp->setMinIndex(0);
 
-    swrp->setFileNamePattern(LOG4CXX_STR("output/sizeBased-test1.%i"));
-    Pool p;
-    swrp->activateOptions(p);
+		swrp->setFileNamePattern(LOG4CXX_STR("output/sizeBased-test1.%i"));
+		Pool p;
+		swrp->activateOptions(p);
 
-    rfa->setRollingPolicy(swrp);
-    rfa->setTriggeringPolicy(sbtp);
-    rfa->activateOptions(p);
-    root->addAppender(rfa);
+		rfa->setRollingPolicy(swrp);
+		rfa->setTriggeringPolicy(sbtp);
+		rfa->activateOptions(p);
+		root->addAppender(rfa);
 
 
-    common(logger, 0);
+		common(logger, 0);
 
-    LOGUNIT_ASSERT_EQUAL(true, File("output/sizeBased-test1.0").exists(p));
-    LOGUNIT_ASSERT_EQUAL(true, File("output/sizeBased-test1.1").exists(p));
-    LOGUNIT_ASSERT_EQUAL(true, File("output/sizeBased-test1.2").exists(p));
-    LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/sizeBased-test1.0"),
-     File("witness/rolling/sbr-test2.log")));
-    LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/sizeBased-test1.1"),
-     File("witness/rolling/sbr-test2.0")));
-    LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/sizeBased-test1.2"),
-     File("witness/rolling/sbr-test2.1")));
-  }
+		LOGUNIT_ASSERT_EQUAL(true, File("output/sizeBased-test1.0").exists(p));
+		LOGUNIT_ASSERT_EQUAL(true, File("output/sizeBased-test1.1").exists(p));
+		LOGUNIT_ASSERT_EQUAL(true, File("output/sizeBased-test1.2").exists(p));
+		LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/sizeBased-test1.0"),
+				File("witness/rolling/sbr-test2.log")));
+		LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/sizeBased-test1.1"),
+				File("witness/rolling/sbr-test2.0")));
+		LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/sizeBased-test1.2"),
+				File("witness/rolling/sbr-test2.1")));
+	}
 
-  /**
-   * Test basic rolling functionality with explicit setting of FileAppender.file.
-   */
-  void test2() {
-    PatternLayoutPtr layout = new PatternLayout(LOG4CXX_STR("%m\n"));
-    RollingFileAppenderPtr rfa = new RollingFileAppender();
-    rfa->setName(LOG4CXX_STR("ROLLING"));
-    rfa->setAppend(false);
-    rfa->setLayout(layout);
-    rfa->setFile(LOG4CXX_STR("output/sizeBased-test2.log"));
+	/**
+	 * Test basic rolling functionality with explicit setting of FileAppender.file.
+	 */
+	void test2()
+	{
+		PatternLayoutPtr layout = new PatternLayout(LOG4CXX_STR("%m\n"));
+		RollingFileAppenderPtr rfa = new RollingFileAppender();
+		rfa->setName(LOG4CXX_STR("ROLLING"));
+		rfa->setAppend(false);
+		rfa->setLayout(layout);
+		rfa->setFile(LOG4CXX_STR("output/sizeBased-test2.log"));
 
-    FixedWindowRollingPolicyPtr swrp = new FixedWindowRollingPolicy();
-    SizeBasedTriggeringPolicyPtr sbtp = new SizeBasedTriggeringPolicy();
+		FixedWindowRollingPolicyPtr swrp = new FixedWindowRollingPolicy();
+		SizeBasedTriggeringPolicyPtr sbtp = new SizeBasedTriggeringPolicy();
 
-    sbtp->setMaxFileSize(100);
-    swrp->setMinIndex(0);
+		sbtp->setMaxFileSize(100);
+		swrp->setMinIndex(0);
 
-    swrp->setFileNamePattern(LOG4CXX_STR("output/sizeBased-test2.%i"));
-    Pool p;
-    swrp->activateOptions(p);
+		swrp->setFileNamePattern(LOG4CXX_STR("output/sizeBased-test2.%i"));
+		Pool p;
+		swrp->activateOptions(p);
 
-    rfa->setRollingPolicy(swrp);
-    rfa->setTriggeringPolicy(sbtp);
-    rfa->activateOptions(p);
-    root->addAppender(rfa);
+		rfa->setRollingPolicy(swrp);
+		rfa->setTriggeringPolicy(sbtp);
+		rfa->activateOptions(p);
+		root->addAppender(rfa);
 
-    common(logger, 0);
+		common(logger, 0);
 
-    LOGUNIT_ASSERT_EQUAL(true, File("output/sizeBased-test2.log").exists(p));
-    LOGUNIT_ASSERT_EQUAL(true, File("output/sizeBased-test2.0").exists(p));
-    LOGUNIT_ASSERT_EQUAL(true, File("output/sizeBased-test2.1").exists(p));
+		LOGUNIT_ASSERT_EQUAL(true, File("output/sizeBased-test2.log").exists(p));
+		LOGUNIT_ASSERT_EQUAL(true, File("output/sizeBased-test2.0").exists(p));
+		LOGUNIT_ASSERT_EQUAL(true, File("output/sizeBased-test2.1").exists(p));
 
-    LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/sizeBased-test2.log"),
-     File("witness/rolling/sbr-test2.log")));
-    LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/sizeBased-test2.0"),
-     File("witness/rolling/sbr-test2.0")));
-    LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/sizeBased-test2.1"),
-     File("witness/rolling/sbr-test2.1")));
-  }
+		LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/sizeBased-test2.log"),
+				File("witness/rolling/sbr-test2.log")));
+		LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/sizeBased-test2.0"),
+				File("witness/rolling/sbr-test2.0")));
+		LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/sizeBased-test2.1"),
+				File("witness/rolling/sbr-test2.1")));
+	}
 
-  /**
-   * Same as testBasic but also with GZ compression.
-   */
-  void test3() {
-    PatternLayoutPtr layout = new PatternLayout(LOG4CXX_STR("%m\n"));
-    RollingFileAppenderPtr rfa = new RollingFileAppender();
-    rfa->setAppend(false);
-    rfa->setLayout(layout);
+	/**
+	 * Same as testBasic but also with GZ compression.
+	 */
+	void test3()
+	{
+		PatternLayoutPtr layout = new PatternLayout(LOG4CXX_STR("%m\n"));
+		RollingFileAppenderPtr rfa = new RollingFileAppender();
+		rfa->setAppend(false);
+		rfa->setLayout(layout);
 
-    FixedWindowRollingPolicyPtr  fwrp = new FixedWindowRollingPolicy();
-    SizeBasedTriggeringPolicyPtr sbtp = new SizeBasedTriggeringPolicy();
+		FixedWindowRollingPolicyPtr  fwrp = new FixedWindowRollingPolicy();
+		SizeBasedTriggeringPolicyPtr sbtp = new SizeBasedTriggeringPolicy();
 
-    sbtp->setMaxFileSize(100);
-    fwrp->setMinIndex(0);
-    rfa->setFile(LOG4CXX_STR("output/sbr-test3.log"));
-    fwrp->setFileNamePattern(LOG4CXX_STR("output/sbr-test3.%i.gz"));
-    Pool p;
-    fwrp->activateOptions(p);
-    rfa->setRollingPolicy(fwrp);
-    rfa->setTriggeringPolicy(sbtp);
-    rfa->activateOptions(p);
-    root->addAppender(rfa);
+		sbtp->setMaxFileSize(100);
+		fwrp->setMinIndex(0);
+		rfa->setFile(LOG4CXX_STR("output/sbr-test3.log"));
+		fwrp->setFileNamePattern(LOG4CXX_STR("output/sbr-test3.%i.gz"));
+		Pool p;
+		fwrp->activateOptions(p);
+		rfa->setRollingPolicy(fwrp);
+		rfa->setTriggeringPolicy(sbtp);
+		rfa->activateOptions(p);
+		root->addAppender(rfa);
 
-    common(logger, 100);
+		common(logger, 100);
 
-    LOGUNIT_ASSERT_EQUAL(true, File("output/sbr-test3.log").exists(p));
-    LOGUNIT_ASSERT_EQUAL(true, File("output/sbr-test3.0.gz").exists(p));
-    LOGUNIT_ASSERT_EQUAL(true, File("output/sbr-test3.1.gz").exists(p));
+		LOGUNIT_ASSERT_EQUAL(true, File("output/sbr-test3.log").exists(p));
+		LOGUNIT_ASSERT_EQUAL(true, File("output/sbr-test3.0.gz").exists(p));
+		LOGUNIT_ASSERT_EQUAL(true, File("output/sbr-test3.1.gz").exists(p));
 
-    LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/sbr-test3.log"),  File("witness/rolling/sbr-test3.log")));
-    LOGUNIT_ASSERT_EQUAL(File("witness/rolling/sbr-test3.0.gz").length(p), File("output/sbr-test3.0.gz").length(p));
-    LOGUNIT_ASSERT_EQUAL(File("witness/rolling/sbr-test3.1.gz").length(p), File("output/sbr-test3.1.gz").length(p));
-  }
+		LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/sbr-test3.log"),  File("witness/rolling/sbr-test3.log")));
+		LOGUNIT_ASSERT_EQUAL(File("witness/rolling/sbr-test3.0.gz").length(p), File("output/sbr-test3.0.gz").length(p));
+		LOGUNIT_ASSERT_EQUAL(File("witness/rolling/sbr-test3.1.gz").length(p), File("output/sbr-test3.1.gz").length(p));
+	}
 
-  /**
-   * Test basic rolling functionality with bogus path in file name pattern.
-   */
-  void test4() {
-    PatternLayoutPtr layout = new PatternLayout(LOG4CXX_STR("%m\n"));
-    RollingFileAppenderPtr rfa = new RollingFileAppender();
-    rfa->setName(LOG4CXX_STR("ROLLING"));
-    rfa->setAppend(false);
-    rfa->setLayout(layout);
-    rfa->setFile(LOG4CXX_STR("output/sizeBased-test4.log"));
+	/**
+	 * Test basic rolling functionality with bogus path in file name pattern.
+	 */
+	void test4()
+	{
+		PatternLayoutPtr layout = new PatternLayout(LOG4CXX_STR("%m\n"));
+		RollingFileAppenderPtr rfa = new RollingFileAppender();
+		rfa->setName(LOG4CXX_STR("ROLLING"));
+		rfa->setAppend(false);
+		rfa->setLayout(layout);
+		rfa->setFile(LOG4CXX_STR("output/sizeBased-test4.log"));
 
-    FixedWindowRollingPolicyPtr swrp = new FixedWindowRollingPolicy();
-    SizeBasedTriggeringPolicyPtr sbtp = new SizeBasedTriggeringPolicy();
+		FixedWindowRollingPolicyPtr swrp = new FixedWindowRollingPolicy();
+		SizeBasedTriggeringPolicyPtr sbtp = new SizeBasedTriggeringPolicy();
 
-    sbtp->setMaxFileSize(100);
-    swrp->setMinIndex(0);
+		sbtp->setMaxFileSize(100);
+		swrp->setMinIndex(0);
 
-    //
-    //   test4 directory should not exists.  Should cause all rollover attempts to fail.
-    //
-    swrp->setFileNamePattern(LOG4CXX_STR("output/test4/sizeBased-test4.%i"));
-    Pool p;
-    swrp->activateOptions(p);
+		//
+		//   test4 directory should not exists.  Should cause all rollover attempts to fail.
+		//
+		swrp->setFileNamePattern(LOG4CXX_STR("output/test4/sizeBased-test4.%i"));
+		Pool p;
+		swrp->activateOptions(p);
 
-    rfa->setRollingPolicy(swrp);
-    rfa->setTriggeringPolicy(sbtp);
-    rfa->activateOptions(p);
-    root->addAppender(rfa);
+		rfa->setRollingPolicy(swrp);
+		rfa->setTriggeringPolicy(sbtp);
+		rfa->activateOptions(p);
+		root->addAppender(rfa);
 
-    common(logger, 0);
+		common(logger, 0);
 
-    LOGUNIT_ASSERT_EQUAL(true, File("output/sizeBased-test4.log").exists(p));
+		LOGUNIT_ASSERT_EQUAL(true, File("output/sizeBased-test4.log").exists(p));
 
-    LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/sizeBased-test4.log"),
-     File("witness/rolling/sbr-test4.log")));
-  }
+		LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/sizeBased-test4.log"),
+				File("witness/rolling/sbr-test4.log")));
+	}
 
-  /**
-   * Checking handling of rename failures due to other access
-   * to the indexed files.
-   */
-  void test5()  {
-    PatternLayoutPtr layout = new PatternLayout(LOG4CXX_STR("%m\n"));
-    RollingFileAppenderPtr rfa = new RollingFileAppender();
-    rfa->setName(LOG4CXX_STR("ROLLING"));
-    rfa->setAppend(false);
-    rfa->setLayout(layout);
-    rfa->setFile(LOG4CXX_STR("output/sizeBased-test5.log"));
+	/**
+	 * Checking handling of rename failures due to other access
+	 * to the indexed files.
+	 */
+	void test5()
+	{
+		PatternLayoutPtr layout = new PatternLayout(LOG4CXX_STR("%m\n"));
+		RollingFileAppenderPtr rfa = new RollingFileAppender();
+		rfa->setName(LOG4CXX_STR("ROLLING"));
+		rfa->setAppend(false);
+		rfa->setLayout(layout);
+		rfa->setFile(LOG4CXX_STR("output/sizeBased-test5.log"));
 
-    FixedWindowRollingPolicyPtr swrp = new FixedWindowRollingPolicy();
-    SizeBasedTriggeringPolicyPtr sbtp = new SizeBasedTriggeringPolicy();
+		FixedWindowRollingPolicyPtr swrp = new FixedWindowRollingPolicy();
+		SizeBasedTriggeringPolicyPtr sbtp = new SizeBasedTriggeringPolicy();
 
-    sbtp->setMaxFileSize(100);
-    swrp->setMinIndex(0);
+		sbtp->setMaxFileSize(100);
+		swrp->setMinIndex(0);
 
-    swrp->setFileNamePattern(LOG4CXX_STR("output/sizeBased-test5.%i"));
-    Pool p;
-    swrp->activateOptions(p);
+		swrp->setFileNamePattern(LOG4CXX_STR("output/sizeBased-test5.%i"));
+		Pool p;
+		swrp->activateOptions(p);
 
-    rfa->setRollingPolicy(swrp);
-    rfa->setTriggeringPolicy(sbtp);
-    rfa->activateOptions(p);
-    root->addAppender(rfa);
+		rfa->setRollingPolicy(swrp);
+		rfa->setTriggeringPolicy(sbtp);
+		rfa->activateOptions(p);
+		root->addAppender(rfa);
 
-    //
-    //   put stray file about locked file
-    FileOutputStream os1(LOG4CXX_STR("output/sizeBased-test5.1"), false);
-    os1.close(p);
+		//
+		//   put stray file about locked file
+		FileOutputStream os1(LOG4CXX_STR("output/sizeBased-test5.1"), false);
+		os1.close(p);
 
 
-    FileOutputStream os0(LOG4CXX_STR("output/sizeBased-test5.0"), false);
+		FileOutputStream os0(LOG4CXX_STR("output/sizeBased-test5.0"), false);
 
-    common(logger, 0);
+		common(logger, 0);
 
-    os0.close(p);
+		os0.close(p);
 
-    if (File("output/sizeBased-test5.3").exists(p)) {
-      //
-      //    looks like platform where open files can be renamed
-      //
-      LOGUNIT_ASSERT_EQUAL(true, File("output/sizeBased-test5.log").exists(p));
-      LOGUNIT_ASSERT_EQUAL(true, File("output/sizeBased-test5.0").exists(p));
-      LOGUNIT_ASSERT_EQUAL(true, File("output/sizeBased-test5.1").exists(p));
-      LOGUNIT_ASSERT_EQUAL(true, File("output/sizeBased-test5.2").exists(p));
-      LOGUNIT_ASSERT_EQUAL(true, File("output/sizeBased-test5.3").exists(p));
+		if (File("output/sizeBased-test5.3").exists(p))
+		{
+			//
+			//    looks like platform where open files can be renamed
+			//
+			LOGUNIT_ASSERT_EQUAL(true, File("output/sizeBased-test5.log").exists(p));
+			LOGUNIT_ASSERT_EQUAL(true, File("output/sizeBased-test5.0").exists(p));
+			LOGUNIT_ASSERT_EQUAL(true, File("output/sizeBased-test5.1").exists(p));
+			LOGUNIT_ASSERT_EQUAL(true, File("output/sizeBased-test5.2").exists(p));
+			LOGUNIT_ASSERT_EQUAL(true, File("output/sizeBased-test5.3").exists(p));
 
-      LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/sizeBased-test5.log"),
-       File("witness/rolling/sbr-test2.log")));
-      LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/sizeBased-test5.0"),
-       File("witness/rolling/sbr-test2.0")));
-      LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/sizeBased-test5.1"),
-       File("witness/rolling/sbr-test2.1")));
+			LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/sizeBased-test5.log"),
+					File("witness/rolling/sbr-test2.log")));
+			LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/sizeBased-test5.0"),
+					File("witness/rolling/sbr-test2.0")));
+			LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/sizeBased-test5.1"),
+					File("witness/rolling/sbr-test2.1")));
 
-    } else {
-      //
-      //  rollover attempts should all fail
-      //    so initial log file should have all log content
-      //    open file should be unaffected
-      //    stray file should have only been moved one slot.
-      LOGUNIT_ASSERT_EQUAL(true, File("output/sizeBased-test5.log").exists(p));
-      LOGUNIT_ASSERT_EQUAL(true, File("output/sizeBased-test5.0").exists(p));
-      LOGUNIT_ASSERT_EQUAL(true, File("output/sizeBased-test5.2").exists(p));
+		}
+		else
+		{
+			//
+			//  rollover attempts should all fail
+			//    so initial log file should have all log content
+			//    open file should be unaffected
+			//    stray file should have only been moved one slot.
+			LOGUNIT_ASSERT_EQUAL(true, File("output/sizeBased-test5.log").exists(p));
+			LOGUNIT_ASSERT_EQUAL(true, File("output/sizeBased-test5.0").exists(p));
+			LOGUNIT_ASSERT_EQUAL(true, File("output/sizeBased-test5.2").exists(p));
 
-      LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/sizeBased-test5.log"),
-          File("witness/rolling/sbr-test4.log")));
-    }
-  }
-  
-  /**
-   * Same as testBasic but also with GZ compression.
-   */
-  void test6() {
-    PatternLayoutPtr layout = new PatternLayout(LOG4CXX_STR("%m\n"));
-    RollingFileAppenderPtr rfa = new RollingFileAppender();
-    rfa->setAppend(false);
-    rfa->setLayout(layout);
+			LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/sizeBased-test5.log"),
+					File("witness/rolling/sbr-test4.log")));
+		}
+	}
 
-    FixedWindowRollingPolicyPtr  fwrp = new FixedWindowRollingPolicy();
-    SizeBasedTriggeringPolicyPtr sbtp = new SizeBasedTriggeringPolicy();
+	/**
+	 * Same as testBasic but also with GZ compression.
+	 */
+	void test6()
+	{
+		PatternLayoutPtr layout = new PatternLayout(LOG4CXX_STR("%m\n"));
+		RollingFileAppenderPtr rfa = new RollingFileAppender();
+		rfa->setAppend(false);
+		rfa->setLayout(layout);
 
-    sbtp->setMaxFileSize(100);
-    fwrp->setMinIndex(0);
-    rfa->setFile(LOG4CXX_STR("output/sbr-test6.log"));
-    fwrp->setFileNamePattern(LOG4CXX_STR("output/sbr-test6.%i.zip"));
-    Pool p;
-    fwrp->activateOptions(p);
-    rfa->setRollingPolicy(fwrp);
-    rfa->setTriggeringPolicy(sbtp);
-    rfa->activateOptions(p);
-    root->addAppender(rfa);
+		FixedWindowRollingPolicyPtr  fwrp = new FixedWindowRollingPolicy();
+		SizeBasedTriggeringPolicyPtr sbtp = new SizeBasedTriggeringPolicy();
 
-    common(logger, 100);
+		sbtp->setMaxFileSize(100);
+		fwrp->setMinIndex(0);
+		rfa->setFile(LOG4CXX_STR("output/sbr-test6.log"));
+		fwrp->setFileNamePattern(LOG4CXX_STR("output/sbr-test6.%i.zip"));
+		Pool p;
+		fwrp->activateOptions(p);
+		rfa->setRollingPolicy(fwrp);
+		rfa->setTriggeringPolicy(sbtp);
+		rfa->activateOptions(p);
+		root->addAppender(rfa);
 
-    LOGUNIT_ASSERT_EQUAL(true, File("output/sbr-test6.log").exists(p));
-    LOGUNIT_ASSERT_EQUAL(true, File("output/sbr-test6.0.zip").exists(p));
-    LOGUNIT_ASSERT_EQUAL(true, File("output/sbr-test6.1.zip").exists(p));
+		common(logger, 100);
 
-    LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/sbr-test6.log"),  File("witness/rolling/sbr-test3.log")));
-  }
-  
+		LOGUNIT_ASSERT_EQUAL(true, File("output/sbr-test6.log").exists(p));
+		LOGUNIT_ASSERT_EQUAL(true, File("output/sbr-test6.0.zip").exists(p));
+		LOGUNIT_ASSERT_EQUAL(true, File("output/sbr-test6.1.zip").exists(p));
+
+		LOGUNIT_ASSERT_EQUAL(true, Compare::compare(File("output/sbr-test6.log"),  File("witness/rolling/sbr-test3.log")));
+	}
+
 };
 
 
diff --git a/src/test/cpp/rolling/timebasedrollingtest.cpp b/src/test/cpp/rolling/timebasedrollingtest.cpp
index 76b8678..d3ab1c9 100644
--- a/src/test/cpp/rolling/timebasedrollingtest.cpp
+++ b/src/test/cpp/rolling/timebasedrollingtest.cpp
@@ -32,16 +32,16 @@
 #include <apr_strings.h>
 #include <apr_time.h>
 #ifndef INT64_C
-#define INT64_C(x) x ## LL
+	#define INT64_C(x) x ## LL
 #endif
 
 // We often need one and the same date pattern, but in different contexts, to either easily embed it
 // into other string literals or as an object. While macros are hard to debug, embedding into string
 // literals is easier this way, because the compiler can automatically collaps them, and if we have
 // one macro already, a second for a similar purpose shouldn't hurt as well.
-#define DATE_PATTERN		"yyyy-MM-dd_HH_mm_ss"
-#define DATE_PATTERN_STR	LogString(LOG4CXX_STR("yyyy-MM-dd_HH_mm_ss"))
-#define PATTERN_LAYOUT		LOG4CXX_STR("%c{1} - %m%n")
+#define DATE_PATTERN        "yyyy-MM-dd_HH_mm_ss"
+#define DATE_PATTERN_STR    LogString(LOG4CXX_STR("yyyy-MM-dd_HH_mm_ss"))
+#define PATTERN_LAYOUT      LOG4CXX_STR("%c{1} - %m%n")
 
 using namespace log4cxx;
 using namespace log4cxx::helpers;
@@ -69,13 +69,13 @@
 LOGUNIT_CLASS(TimeBasedRollingTest)
 {
 	LOGUNIT_TEST_SUITE(TimeBasedRollingTest);
-		LOGUNIT_TEST(test1);
-		LOGUNIT_TEST(test2);
-		LOGUNIT_TEST(test3);
-		LOGUNIT_TEST(test4);
-		LOGUNIT_TEST(test5);
-		LOGUNIT_TEST(test6);
-		LOGUNIT_TEST(test7);
+	LOGUNIT_TEST(test1);
+	LOGUNIT_TEST(test2);
+	LOGUNIT_TEST(test3);
+	LOGUNIT_TEST(test4);
+	LOGUNIT_TEST(test5);
+	LOGUNIT_TEST(test6);
+	LOGUNIT_TEST(test7);
 	LOGUNIT_TEST_SUITE_END();
 
 private:
@@ -111,24 +111,25 @@
 	 * 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.
 	 * </p>
-	 * @param[in,out]	pool
-	 * @param[in]		prefix
-	 * @param[in]		fileNames
-	 * param[in,opt]	withCompression
-	 * param[in,opt]	startInFuture
+	 * @param[in,out]   pool
+	 * @param[in]       prefix
+	 * @param[in]       fileNames
+	 * param[in,opt]    withCompression
+	 * param[in,opt]    startInFuture
 	 */
 	template<size_t N>
-	void buildTsFileNames(			Pool&		pool,
-							const	logchar*	prefix,
-									LogString	(&fileNames)[N],
-									bool		withCompression	= false,
-									bool		startInFuture	= false)
+	void buildTsFileNames(          Pool &       pool,
+		const   logchar *    prefix,
+		LogString   (&fileNames)[N],
+		bool        withCompression = false,
+		bool        startInFuture   = false)
 	{
-		SimpleDateFormat	sdf(DATE_PATTERN_STR);
-		apr_time_t			now(apr_time_now());
-		LogString			ext(withCompression ? LOG4CXX_STR(".gz") : LOG4CXX_STR(""));
+		SimpleDateFormat    sdf(DATE_PATTERN_STR);
+		apr_time_t          now(apr_time_now());
+		LogString           ext(withCompression ? LOG4CXX_STR(".gz") : LOG4CXX_STR(""));
 
 		now += startInFuture ? APR_USEC_PER_SEC : 0;
+
 		for (size_t i = 0; i < N; ++i)
 		{
 			fileNames[i].assign(LogString(LOG4CXX_STR("output/")) + prefix);
@@ -167,40 +168,40 @@
 	 * 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.
 	 * </p>
-	 * @param[in,out]	pool
-	 * @param[in]		howOften
-	 * @param[in]		srcFunc
-	 * @param[in]		srcLine
-	 * @param[in,opt]	startWith
-	 * @param[in]		waitFactor
+	 * @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)
+	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__,					\
-							srcFunc.c_str(),			\
-							srcLine)
+#undef  LOG4CXX_LOCATION
+#define LOG4CXX_LOCATION ::log4cxx::spi::LocationInfo(  \
+	__FILE__,                   \
+	srcFunc.c_str(),            \
+	srcLine)
 
 		for (size_t i = startWith; i < startWith + howOften; ++i)
 		{
-			std::string	message("Hello---");
-						message.append(pool.itoa(i));
+			std::string message("Hello---");
+			message.append(pool.itoa(i));
 
 			LOG4CXX_DEBUG(logger, message);
 			apr_sleep(APR_USEC_PER_SEC * waitFactor);
 		}
 
-#undef	LOG4CXX_LOCATION
-#define	LOG4CXX_LOCATION ::log4cxx::spi::LocationInfo(	\
-							__FILE__,					\
-							__LOG4CXX_FUNC__,			\
-							__LINE__)
+#undef  LOG4CXX_LOCATION
+#define LOG4CXX_LOCATION ::log4cxx::spi::LocationInfo(  \
+	__FILE__,                   \
+	__LOG4CXX_FUNC__,           \
+	__LINE__)
 	}
 
 	/**
@@ -215,20 +216,20 @@
 	 * 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.
 	 * </p>
-	 * @param[in,out]	pool
-	 * @param[in]		prefix
-	 * @param[in]		fileName
-	 * @param[in]		witnessIdx
-	 * @param[in]		srcLine
+	 * @param[in,out]   pool
+	 * @param[in]       prefix
+	 * @param[in]       fileName
+	 * @param[in]       witnessIdx
+	 * @param[in]       srcLine
 	 */
-	void compareWitness(		Pool&		pool,
-						const	logchar*	prefix,
-						const	LogString&	fileName,
-								size_t		witnessIdx,
-								size_t		srcLine)
+	void compareWitness(        Pool &       pool,
+		const   logchar *    prefix,
+		const   LogString &  fileName,
+		size_t      witnessIdx,
+		size_t      srcLine)
 	{
-		LogString	witness(LOG4CXX_STR("witness/rolling/tbr-"));
-					witness.append(prefix);
+		LogString   witness(LOG4CXX_STR("witness/rolling/tbr-"));
+		witness.append(prefix);
 
 		StringHelper::toString(witnessIdx, pool, witness);
 		LOGUNIT_ASSERT_SRCL(Compare::compare(fileName, File(witness)), srcLine);
@@ -240,16 +241,16 @@
 	 * This method is a wrapper around {@link compareWitness}, used to iterate over all files from a
 	 * given test.
 	 * </p>
-	 * @param[in,out]	pool
-	 * @param[in]		prefix
-	 * @param[in]		fileNames
-	 * @param[in]		srcLine
+	 * @param[in,out]   pool
+	 * @param[in]       prefix
+	 * @param[in]       fileNames
+	 * @param[in]       srcLine
 	 */
 	template<size_t N>
-	void compareWitnesses(			Pool&		pool,
-							const	logchar*	prefix,
-									LogString	(&fileNames)[N],
-									size_t		srcLine)
+	void compareWitnesses(          Pool &       pool,
+		const   logchar *    prefix,
+		LogString   (&fileNames)[N],
+		size_t      srcLine)
 	{
 		for (int i = 0; i < N; ++i)
 		{
@@ -267,16 +268,16 @@
 	 * We don't use a wrapper macro this time because the src line schould have the same name in all
 	 * compilers and is easily to add for the caller.
 	 * </p>
-	 * @param[in,out]	pool
-	 * @param[in]		prefix
-	 * @param[in]		fileNames
-	 * @param[in]		srcLine
+	 * @param[in,out]   pool
+	 * @param[in]       prefix
+	 * @param[in]       fileNames
+	 * @param[in]       srcLine
 	 */
 	template<size_t N>
-	void checkFilesExist(			Pool&		pool,
-							const	logchar*	prefix,
-									LogString	(&fileNames)[N],
-									size_t		srcLine)
+	void checkFilesExist(           Pool &       pool,
+		const   logchar *    prefix,
+		LogString   (&fileNames)[N],
+		size_t      srcLine)
 	{
 		for (int i = 0; i < N - 1; ++i)
 		{
@@ -332,8 +333,8 @@
 	 */
 	void deleteGenericLogFilePerTest(size_t num_test)
 	{
-		Pool		pool;
-		LogString	path(LOG4CXX_STR("output/test"));
+		Pool        pool;
+		LogString   path(LOG4CXX_STR("output/test"));
 
 		StringHelper::toString(num_test, pool, path);
 		path.append(LOG4CXX_STR(".log"));
@@ -364,7 +365,7 @@
 	void internalTearDown()
 	{
 		// Nothing to do currently.
-    }
+	}
 
 public:
 	/**
@@ -374,7 +375,7 @@
 	 * is the only place where we can extract and save it in the instance.
 	 * </p>
 	 */
-	void setCase(abts_case* tc)
+	void setCase(abts_case * tc)
 	{
 		LogUnit::TestFixture::setCase(tc);
 		this->num_test = tc->suite->num_test;
@@ -401,12 +402,12 @@
 	 */
 	void test1()
 	{
-				Pool		pool;
-		const	size_t		nrOfFileNames = 4;
-				LogString	fileNames[nrOfFileNames];
+		Pool        pool;
+		const   size_t      nrOfFileNames = 4;
+		LogString   fileNames[nrOfFileNames];
 
-		PatternLayoutPtr		layout(	new PatternLayout(PATTERN_LAYOUT));
-		RollingFileAppenderPtr	rfa(	new RollingFileAppender());
+		PatternLayoutPtr        layout( new PatternLayout(PATTERN_LAYOUT));
+		RollingFileAppenderPtr  rfa(    new RollingFileAppender());
 		rfa->setLayout(layout);
 
 		TimeBasedRollingPolicyPtr tbrp(new TimeBasedRollingPolicy());
@@ -418,8 +419,8 @@
 
 		this->buildTsFileNames(pool, LOG4CXX_STR("test1-"), fileNames);
 		this->delayUntilNextSecondWithMsg();
-		this->logMsgAndSleep(	pool, nrOfFileNames + 1, __LOG4CXX_FUNC__, __LINE__);
-		this->compareWitnesses(	pool, LOG4CXX_STR("test1."), fileNames, __LINE__);
+		this->logMsgAndSleep(   pool, nrOfFileNames + 1, __LOG4CXX_FUNC__, __LINE__);
+		this->compareWitnesses( pool, LOG4CXX_STR("test1."), fileNames, __LINE__);
 	}
 
 	/**
@@ -427,12 +428,12 @@
 	 */
 	void test2()
 	{
-				Pool		pool;
-		const	size_t		nrOfFileNames = 4;
-				LogString	fileNames[nrOfFileNames];
+		Pool        pool;
+		const   size_t      nrOfFileNames = 4;
+		LogString   fileNames[nrOfFileNames];
 
-		PatternLayoutPtr		layout1(new PatternLayout(PATTERN_LAYOUT));
-		RollingFileAppenderPtr	rfa1(	new RollingFileAppender());
+		PatternLayoutPtr        layout1(new PatternLayout(PATTERN_LAYOUT));
+		RollingFileAppenderPtr  rfa1(   new RollingFileAppender());
 		rfa1->setLayout(layout1);
 
 		TimeBasedRollingPolicyPtr tbrp1(new TimeBasedRollingPolicy());
@@ -449,8 +450,8 @@
 		logger->removeAppender(rfa1);
 		rfa1->close();
 
-		PatternLayoutPtr		layout2(new PatternLayout(PATTERN_LAYOUT));
-		RollingFileAppenderPtr	rfa2(	new RollingFileAppender());
+		PatternLayoutPtr        layout2(new PatternLayout(PATTERN_LAYOUT));
+		RollingFileAppenderPtr  rfa2(   new RollingFileAppender());
 		rfa2->setLayout(layout2);
 
 		TimeBasedRollingPolicyPtr tbrp2 = new TimeBasedRollingPolicy();
@@ -460,8 +461,8 @@
 		rfa2->activateOptions(pool);
 		logger->addAppender(rfa2);
 
-		this->logMsgAndSleep(	pool, 2, __LOG4CXX_FUNC__, __LINE__, 3);
-		this->compareWitnesses(	pool, LOG4CXX_STR("test2."), fileNames, __LINE__);
+		this->logMsgAndSleep(   pool, 2, __LOG4CXX_FUNC__, __LINE__, 3);
+		this->compareWitnesses( pool, LOG4CXX_STR("test2."), fileNames, __LINE__);
 	}
 
 	/**
@@ -469,12 +470,12 @@
 	 */
 	void test3()
 	{
-				Pool		pool;
-		const	size_t		nrOfFileNames = 4;
-				LogString	fileNames[nrOfFileNames];
+		Pool        pool;
+		const   size_t      nrOfFileNames = 4;
+		LogString   fileNames[nrOfFileNames];
 
-		PatternLayoutPtr		layout(	new PatternLayout(PATTERN_LAYOUT));
-		RollingFileAppenderPtr	rfa(	new RollingFileAppender());
+		PatternLayoutPtr        layout( new PatternLayout(PATTERN_LAYOUT));
+		RollingFileAppenderPtr  rfa(    new RollingFileAppender());
 		rfa->setAppend(false);
 		rfa->setLayout(layout);
 
@@ -488,8 +489,8 @@
 		this->buildTsFileNames(pool, LOG4CXX_STR("test3-"), fileNames, true);
 		fileNames[3].resize(fileNames[3].size() - 3);
 		this->delayUntilNextSecondWithMsg();
-		this->logMsgAndSleep(	pool, nrOfFileNames + 1, __LOG4CXX_FUNC__, __LINE__);
-		this->checkFilesExist(	pool, LOG4CXX_STR("test3."), fileNames, __LINE__);
+		this->logMsgAndSleep(   pool, nrOfFileNames + 1, __LOG4CXX_FUNC__, __LINE__);
+		this->checkFilesExist(  pool, LOG4CXX_STR("test3."), fileNames, __LINE__);
 	}
 
 	/**
@@ -497,12 +498,12 @@
 	 */
 	void test4()
 	{
-				Pool		pool;
-		const	size_t		nrOfFileNames = 4;
-				LogString	fileNames[nrOfFileNames];
+		Pool        pool;
+		const   size_t      nrOfFileNames = 4;
+		LogString   fileNames[nrOfFileNames];
 
-		PatternLayoutPtr		layout1(new PatternLayout(PATTERN_LAYOUT));
-		RollingFileAppenderPtr	rfa1(	new RollingFileAppender());
+		PatternLayoutPtr        layout1(new PatternLayout(PATTERN_LAYOUT));
+		RollingFileAppenderPtr  rfa1(   new RollingFileAppender());
 		rfa1->setLayout(layout1);
 
 		TimeBasedRollingPolicyPtr tbrp1 = new TimeBasedRollingPolicy();
@@ -521,8 +522,8 @@
 		logger->removeAppender(rfa1);
 		rfa1->close();
 
-		PatternLayoutPtr		layout2(new PatternLayout(PATTERN_LAYOUT));
-		RollingFileAppenderPtr	rfa2(	new RollingFileAppender());
+		PatternLayoutPtr        layout2(new PatternLayout(PATTERN_LAYOUT));
+		RollingFileAppenderPtr  rfa2(   new RollingFileAppender());
 		rfa2->setLayout(layout2);
 
 		TimeBasedRollingPolicyPtr tbrp2 = new TimeBasedRollingPolicy();
@@ -533,8 +534,8 @@
 		rfa2->activateOptions(pool);
 		logger->addAppender(rfa2);
 
-		this->logMsgAndSleep(	pool, 2, __LOG4CXX_FUNC__, __LINE__, 3);
-		this->compareWitnesses(	pool, LOG4CXX_STR("test4."), fileNames, __LINE__);
+		this->logMsgAndSleep(   pool, 2, __LOG4CXX_FUNC__, __LINE__, 3);
+		this->compareWitnesses( pool, LOG4CXX_STR("test4."), fileNames, __LINE__);
 	}
 
 	/**
@@ -542,12 +543,12 @@
 	 */
 	void test5()
 	{
-				Pool		pool;
-		const	size_t		nrOfFileNames = 4;
-				LogString	fileNames[nrOfFileNames];
+		Pool        pool;
+		const   size_t      nrOfFileNames = 4;
+		LogString   fileNames[nrOfFileNames];
 
-		PatternLayoutPtr		layout(	new PatternLayout(PATTERN_LAYOUT));
-		RollingFileAppenderPtr	rfa(	new RollingFileAppender());
+		PatternLayoutPtr        layout( new PatternLayout(PATTERN_LAYOUT));
+		RollingFileAppenderPtr  rfa(    new RollingFileAppender());
 		rfa->setLayout(layout);
 
 		TimeBasedRollingPolicyPtr tbrp = new TimeBasedRollingPolicy();
@@ -562,8 +563,8 @@
 		this->buildTsFileNames(pool, LOG4CXX_STR("test5-"), fileNames);
 		fileNames[3].assign(rfa->getFile());
 		this->delayUntilNextSecondWithMsg();
-		this->logMsgAndSleep(	pool, nrOfFileNames + 1, __LOG4CXX_FUNC__, __LINE__);
-		this->compareWitnesses(	pool, LOG4CXX_STR("test5."), fileNames, __LINE__);
+		this->logMsgAndSleep(   pool, nrOfFileNames + 1, __LOG4CXX_FUNC__, __LINE__);
+		this->compareWitnesses( pool, LOG4CXX_STR("test5."), fileNames, __LINE__);
 	}
 
 	/**
@@ -571,12 +572,12 @@
 	 */
 	void test6()
 	{
-				Pool		pool;
-		const	size_t		nrOfFileNames = 4;
-				LogString	fileNames[nrOfFileNames];
+		Pool        pool;
+		const   size_t      nrOfFileNames = 4;
+		LogString   fileNames[nrOfFileNames];
 
-		PatternLayoutPtr		layout(	new PatternLayout(PATTERN_LAYOUT));
-		RollingFileAppenderPtr	rfa(	new RollingFileAppender());
+		PatternLayoutPtr        layout( new PatternLayout(PATTERN_LAYOUT));
+		RollingFileAppenderPtr  rfa(    new RollingFileAppender());
 		rfa->setAppend(false);
 		rfa->setLayout(layout);
 
@@ -591,8 +592,8 @@
 		this->buildTsFileNames(pool, LOG4CXX_STR("test6-"), fileNames, true);
 		fileNames[3].assign(rfa->getFile());
 		this->delayUntilNextSecondWithMsg();
-		this->logMsgAndSleep(	pool, nrOfFileNames + 1, __LOG4CXX_FUNC__, __LINE__);
-		this->checkFilesExist(	pool, LOG4CXX_STR("test6."), fileNames, __LINE__);
+		this->logMsgAndSleep(   pool, nrOfFileNames + 1, __LOG4CXX_FUNC__, __LINE__);
+		this->checkFilesExist(  pool, LOG4CXX_STR("test6."), fileNames, __LINE__);
 	}
 
 	/**
@@ -607,8 +608,8 @@
 		typedef void (TimeBasedRollingTest::*Test)();
 		typedef std::vector<Test> Tests;
 
-		Tests	tests(10);
-		size_t	numTest = 0;
+		Tests   tests(10);
+		size_t  numTest = 0;
 
 		tests.at(4) = &TimeBasedRollingTest::test4;
 		tests.at(5) = &TimeBasedRollingTest::test5;
@@ -617,6 +618,7 @@
 		for (size_t numTest = 1; numTest < tests.size(); ++numTest)
 		{
 			Test test(tests.at(numTest));
+
 			if (!test)
 			{
 				continue;
diff --git a/src/test/cpp/rollingfileappendertestcase.cpp b/src/test/cpp/rollingfileappendertestcase.cpp
index 7bf1d75..f77f116 100644
--- a/src/test/cpp/rollingfileappendertestcase.cpp
+++ b/src/test/cpp/rollingfileappendertestcase.cpp
@@ -26,21 +26,22 @@
  */
 class RollingFileAppenderTestCase : public FileAppenderAbstractTestCase
 {
-   LOGUNIT_TEST_SUITE(RollingFileAppenderTestCase);
-                //
-                //    tests inherited from AppenderSkeletonTestCase
-                //
-                LOGUNIT_TEST(testDefaultThreshold);
-                LOGUNIT_TEST(testSetOptionThreshold);
+		LOGUNIT_TEST_SUITE(RollingFileAppenderTestCase);
+		//
+		//    tests inherited from AppenderSkeletonTestCase
+		//
+		LOGUNIT_TEST(testDefaultThreshold);
+		LOGUNIT_TEST(testSetOptionThreshold);
 
-   LOGUNIT_TEST_SUITE_END();
+		LOGUNIT_TEST_SUITE_END();
 
 
-public:
+	public:
 
-        FileAppender* createFileAppender() const {
-          return new log4cxx::rolling::RollingFileAppender();
-        }
+		FileAppender* createFileAppender() const
+		{
+			return new log4cxx::rolling::RollingFileAppender();
+		}
 };
 
 LOGUNIT_TEST_SUITE_REGISTRATION(RollingFileAppenderTestCase);
diff --git a/src/test/cpp/spi/loggingeventtest.cpp b/src/test/cpp/spi/loggingeventtest.cpp
index bbe6b84..ba07301 100644
--- a/src/test/cpp/spi/loggingeventtest.cpp
+++ b/src/test/cpp/spi/loggingeventtest.cpp
@@ -33,88 +33,93 @@
  */
 LOGUNIT_CLASS(LoggingEventTest)
 {
-        LOGUNIT_TEST_SUITE(LoggingEventTest);
-                LOGUNIT_TEST(testSerializationSimple);
-                LOGUNIT_TEST(testSerializationWithLocation);
-                LOGUNIT_TEST(testSerializationNDC);
-                LOGUNIT_TEST(testSerializationMDC);
-         LOGUNIT_TEST_SUITE_END();
+	LOGUNIT_TEST_SUITE(LoggingEventTest);
+	LOGUNIT_TEST(testSerializationSimple);
+	LOGUNIT_TEST(testSerializationWithLocation);
+	LOGUNIT_TEST(testSerializationNDC);
+	LOGUNIT_TEST(testSerializationMDC);
+	LOGUNIT_TEST_SUITE_END();
 
 public:
-        void setUp() {
-            NDC::clear();
-            MDC::clear();
-        }
+	void setUp()
+	{
+		NDC::clear();
+		MDC::clear();
+	}
 
-        void tearDown()
-        {
-            LogManager::shutdown();
-        }
-        
-        
-  
-        
-  /**
-   * Serialize a simple logging event and check it against
-   * a witness.
-   * @throws Exception if exception during test.
-   */
-  void testSerializationSimple() {
-    LoggingEventPtr event =
-      new LoggingEvent(
-        LOG4CXX_STR("root"), Level::getInfo(), LOG4CXX_STR("Hello, world."), LocationInfo::getLocationUnavailable());
-        
-    LOGUNIT_ASSERT_EQUAL(true, SerializationTestHelper::compare(
-      "witness/serialization/simple.bin", event, 237));
-  }
+	void tearDown()
+	{
+		LogManager::shutdown();
+	}
 
 
-  /**
-   * Serialize a logging event with an exception and check it against
-   * a witness.
-   * @throws Exception if exception during test.
-   *
-   */
-  void testSerializationWithLocation() {
-    LoggingEventPtr event =
-      new LoggingEvent(
-        LOG4CXX_STR("root"), Level::getInfo(), LOG4CXX_STR("Hello, world."), LOG4CXX_LOCATION);
 
-    LOGUNIT_ASSERT_EQUAL(true, SerializationTestHelper::compare(
-      "witness/serialization/location.bin", event, 237));
-  }
 
-  /**
-   * Serialize a logging event with ndc.
-   * @throws Exception if exception during test.
-   *
-   */
-  void testSerializationNDC() {
-    NDC::push("ndc test");
+	/**
+	 * Serialize a simple logging event and check it against
+	 * a witness.
+	 * @throws Exception if exception during test.
+	 */
+	void testSerializationSimple()
+	{
+		LoggingEventPtr event =
+			new LoggingEvent(
+			LOG4CXX_STR("root"), Level::getInfo(), LOG4CXX_STR("Hello, world."), LocationInfo::getLocationUnavailable());
 
-    LoggingEventPtr event =
-      new LoggingEvent(
-        LOG4CXX_STR("root"), Level::getInfo(), LOG4CXX_STR("Hello, world."), LocationInfo::getLocationUnavailable());
+		LOGUNIT_ASSERT_EQUAL(true, SerializationTestHelper::compare(
+				"witness/serialization/simple.bin", event, 237));
+	}
 
-    LOGUNIT_ASSERT_EQUAL(true, SerializationTestHelper::compare(
-      "witness/serialization/ndc.bin", event, 237));
-    }
 
-  /**
-   * Serialize a logging event with mdc.
-   * @throws Exception if exception during test.
-   *
-   */
-  void testSerializationMDC() {
-    MDC::put("mdckey", "mdcvalue");
- 
-    LoggingEventPtr event =
-      new LoggingEvent(
-        LOG4CXX_STR("root"), Level::getInfo(), LOG4CXX_STR("Hello, world."), LocationInfo::getLocationUnavailable());
+	/**
+	 * Serialize a logging event with an exception and check it against
+	 * a witness.
+	 * @throws Exception if exception during test.
+	 *
+	 */
+	void testSerializationWithLocation()
+	{
+		LoggingEventPtr event =
+			new LoggingEvent(
+			LOG4CXX_STR("root"), Level::getInfo(), LOG4CXX_STR("Hello, world."), LOG4CXX_LOCATION);
 
-    LOGUNIT_ASSERT_EQUAL(true, SerializationTestHelper::compare(
-      "witness/serialization/mdc.bin", event, 237));
-  }
+		LOGUNIT_ASSERT_EQUAL(true, SerializationTestHelper::compare(
+				"witness/serialization/location.bin", event, 237));
+	}
+
+	/**
+	 * Serialize a logging event with ndc.
+	 * @throws Exception if exception during test.
+	 *
+	 */
+	void testSerializationNDC()
+	{
+		NDC::push("ndc test");
+
+		LoggingEventPtr event =
+			new LoggingEvent(
+			LOG4CXX_STR("root"), Level::getInfo(), LOG4CXX_STR("Hello, world."), LocationInfo::getLocationUnavailable());
+
+		LOGUNIT_ASSERT_EQUAL(true, SerializationTestHelper::compare(
+				"witness/serialization/ndc.bin", event, 237));
+	}
+
+	/**
+	 * Serialize a logging event with mdc.
+	 * @throws Exception if exception during test.
+	 *
+	 */
+	void testSerializationMDC()
+	{
+		MDC::put("mdckey", "mdcvalue");
+
+		LoggingEventPtr event =
+			new LoggingEvent(
+			LOG4CXX_STR("root"), Level::getInfo(), LOG4CXX_STR("Hello, world."), LocationInfo::getLocationUnavailable());
+
+		LOGUNIT_ASSERT_EQUAL(true, SerializationTestHelper::compare(
+				"witness/serialization/mdc.bin", event, 237));
+	}
 
 };
 
diff --git a/src/test/cpp/streamtestcase.cpp b/src/test/cpp/streamtestcase.cpp
index 7609e24..271e65e 100644
--- a/src/test/cpp/streamtestcase.cpp
+++ b/src/test/cpp/streamtestcase.cpp
@@ -26,17 +26,19 @@
 #include <log4cxx/stream.h>
 
 #if LOG4CXX_CFSTRING_API
-#include <CoreFoundation/CFString.h>
+	#include <CoreFoundation/CFString.h>
 #endif
 
 using namespace log4cxx;
 using namespace log4cxx::helpers;
 using namespace std;
 
-class ExceptionOnInsert {
-public:
-   ExceptionOnInsert() {
-   }
+class ExceptionOnInsert
+{
+	public:
+		ExceptionOnInsert()
+		{
+		}
 };
 
 //
@@ -46,9 +48,10 @@
 //
 template<class Elem, class Tr>
 ::std::basic_ostream<Elem, Tr>& operator<<(
-   ::std::basic_ostream<Elem, Tr>&,
-   const ExceptionOnInsert&) {
-   throw std::exception();
+	::std::basic_ostream<Elem, Tr>&,
+	const ExceptionOnInsert&)
+{
+	throw std::exception();
 }
 
 
@@ -57,525 +60,587 @@
  */
 LOGUNIT_CLASS(StreamTestCase)
 {
-        LOGUNIT_TEST_SUITE(StreamTestCase);
-                LOGUNIT_TEST(testSimple);
-                LOGUNIT_TEST(testMultiple);
-                LOGUNIT_TEST(testShortCircuit);
-                LOGUNIT_TEST_EXCEPTION(testInsertException, std::exception);
-                LOGUNIT_TEST(testScientific);
-                LOGUNIT_TEST(testPrecision);
-                LOGUNIT_TEST(testWidth);
+	LOGUNIT_TEST_SUITE(StreamTestCase);
+	LOGUNIT_TEST(testSimple);
+	LOGUNIT_TEST(testMultiple);
+	LOGUNIT_TEST(testShortCircuit);
+	LOGUNIT_TEST_EXCEPTION(testInsertException, std::exception);
+	LOGUNIT_TEST(testScientific);
+	LOGUNIT_TEST(testPrecision);
+	LOGUNIT_TEST(testWidth);
 #if LOG4CXX_WCHAR_T_API
-                LOGUNIT_TEST(testWide);
-                LOGUNIT_TEST(testWideAppend);
-                LOGUNIT_TEST(testWideWidth);
+	LOGUNIT_TEST(testWide);
+	LOGUNIT_TEST(testWideAppend);
+	LOGUNIT_TEST(testWideWidth);
 #endif
-                LOGUNIT_TEST(testBaseFlags);
-                LOGUNIT_TEST(testBasePrecisionAndWidth);
-                LOGUNIT_TEST(testLogStreamSimple);
-                LOGUNIT_TEST(testLogStreamMultiple);
-                LOGUNIT_TEST(testLogStreamShortCircuit);
-                LOGUNIT_TEST_EXCEPTION(testLogStreamInsertException, std::exception);
-                LOGUNIT_TEST(testLogStreamScientific);
-                LOGUNIT_TEST(testLogStreamPrecision);
-                LOGUNIT_TEST(testLogStreamWidth);
-                LOGUNIT_TEST(testLogStreamDelegate);
-                LOGUNIT_TEST(testLogStreamFormattingPersists);
-                LOGUNIT_TEST(testSetWidthInsert);
+	LOGUNIT_TEST(testBaseFlags);
+	LOGUNIT_TEST(testBasePrecisionAndWidth);
+	LOGUNIT_TEST(testLogStreamSimple);
+	LOGUNIT_TEST(testLogStreamMultiple);
+	LOGUNIT_TEST(testLogStreamShortCircuit);
+	LOGUNIT_TEST_EXCEPTION(testLogStreamInsertException, std::exception);
+	LOGUNIT_TEST(testLogStreamScientific);
+	LOGUNIT_TEST(testLogStreamPrecision);
+	LOGUNIT_TEST(testLogStreamWidth);
+	LOGUNIT_TEST(testLogStreamDelegate);
+	LOGUNIT_TEST(testLogStreamFormattingPersists);
+	LOGUNIT_TEST(testSetWidthInsert);
 #if LOG4CXX_WCHAR_T_API
-                LOGUNIT_TEST(testWLogStreamSimple);
-                LOGUNIT_TEST(testWLogStreamMultiple);
-                LOGUNIT_TEST(testWLogStreamShortCircuit);
-                LOGUNIT_TEST_EXCEPTION(testWLogStreamInsertException, std::exception);
-                LOGUNIT_TEST(testWLogStreamScientific);
-                LOGUNIT_TEST(testWLogStreamPrecision);
-                LOGUNIT_TEST(testWLogStreamWidth);
-                LOGUNIT_TEST(testWLogStreamDelegate);
-                LOGUNIT_TEST(testWLogStreamFormattingPersists);
-                LOGUNIT_TEST(testWSetWidthInsert);
+	LOGUNIT_TEST(testWLogStreamSimple);
+	LOGUNIT_TEST(testWLogStreamMultiple);
+	LOGUNIT_TEST(testWLogStreamShortCircuit);
+	LOGUNIT_TEST_EXCEPTION(testWLogStreamInsertException, std::exception);
+	LOGUNIT_TEST(testWLogStreamScientific);
+	LOGUNIT_TEST(testWLogStreamPrecision);
+	LOGUNIT_TEST(testWLogStreamWidth);
+	LOGUNIT_TEST(testWLogStreamDelegate);
+	LOGUNIT_TEST(testWLogStreamFormattingPersists);
+	LOGUNIT_TEST(testWSetWidthInsert);
 #endif
 #if LOG4CXX_UNICHAR_API
-                LOGUNIT_TEST(testUniChar);
-                LOGUNIT_TEST(testUniCharAppend);
-//                LOGUNIT_TEST(testUniCharWidth);
-                LOGUNIT_TEST(testULogStreamSimple);
-                LOGUNIT_TEST(testULogStreamMultiple);
-                LOGUNIT_TEST(testULogStreamShortCircuit);
-                LOGUNIT_TEST_EXCEPTION(testULogStreamInsertException, std::exception);
-//                LOGUNIT_TEST(testULogStreamScientific);
-//                LOGUNIT_TEST(testULogStreamPrecision);
-//                LOGUNIT_TEST(testULogStreamWidth);
-                LOGUNIT_TEST(testULogStreamDelegate);
-//                LOGUNIT_TEST(testULogStreamFormattingPersists);
-//                LOGUNIT_TEST(testUSetWidthInsert);
+	LOGUNIT_TEST(testUniChar);
+	LOGUNIT_TEST(testUniCharAppend);
+	//                LOGUNIT_TEST(testUniCharWidth);
+	LOGUNIT_TEST(testULogStreamSimple);
+	LOGUNIT_TEST(testULogStreamMultiple);
+	LOGUNIT_TEST(testULogStreamShortCircuit);
+	LOGUNIT_TEST_EXCEPTION(testULogStreamInsertException, std::exception);
+	//                LOGUNIT_TEST(testULogStreamScientific);
+	//                LOGUNIT_TEST(testULogStreamPrecision);
+	//                LOGUNIT_TEST(testULogStreamWidth);
+	LOGUNIT_TEST(testULogStreamDelegate);
+	//                LOGUNIT_TEST(testULogStreamFormattingPersists);
+	//                LOGUNIT_TEST(testUSetWidthInsert);
 #endif
 #if LOG4CXX_CFSTRING_API
-                LOGUNIT_TEST(testCFString);
-                LOGUNIT_TEST(testCFStringAppend);
-                LOGUNIT_TEST(testULogStreamCFString);
-                LOGUNIT_TEST(testULogStreamCFString2);
+	LOGUNIT_TEST(testCFString);
+	LOGUNIT_TEST(testCFStringAppend);
+	LOGUNIT_TEST(testULogStreamCFString);
+	LOGUNIT_TEST(testULogStreamCFString2);
 #endif
-         LOGUNIT_TEST_SUITE_END();
+	LOGUNIT_TEST_SUITE_END();
 
-        VectorAppenderPtr vectorAppender;
+	VectorAppenderPtr vectorAppender;
 
 public:
-        void setUp() {
-           LoggerPtr root(Logger::getRootLogger());
-           LayoutPtr layout(new SimpleLayout());
-           vectorAppender = new VectorAppender();
-           root->addAppender(vectorAppender);
-        }
+	void setUp()
+	{
+		LoggerPtr root(Logger::getRootLogger());
+		LayoutPtr layout(new SimpleLayout());
+		vectorAppender = new VectorAppender();
+		root->addAppender(vectorAppender);
+	}
 
-        void tearDown()
-        {
-            LogManager::shutdown();
-        }
+	void tearDown()
+	{
+		LogManager::shutdown();
+	}
 
-        void testSimple() {
-            LoggerPtr root(Logger::getRootLogger());
-            LOG4CXX_INFO(root, "This is a test");
-            LOGUNIT_ASSERT_EQUAL((size_t) 1, vectorAppender->getVector().size());
-        }
+	void testSimple()
+	{
+		LoggerPtr root(Logger::getRootLogger());
+		LOG4CXX_INFO(root, "This is a test");
+		LOGUNIT_ASSERT_EQUAL((size_t) 1, vectorAppender->getVector().size());
+	}
 
-        void testMultiple() {
-           LoggerPtr root(Logger::getRootLogger());
-           LOG4CXX_INFO(root, "This is a test" << ": Details to follow");
-           LOGUNIT_ASSERT_EQUAL((size_t) 1, vectorAppender->getVector().size());
-       }
+	void testMultiple()
+	{
+		LoggerPtr root(Logger::getRootLogger());
+		LOG4CXX_INFO(root, "This is a test" << ": Details to follow");
+		LOGUNIT_ASSERT_EQUAL((size_t) 1, vectorAppender->getVector().size());
+	}
 
-       void testShortCircuit() {
-         LoggerPtr logger(Logger::getLogger("StreamTestCase.shortCircuit"));
-         logger->setLevel(Level::getInfo());
-         ExceptionOnInsert someObj;
-         LOG4CXX_DEBUG(logger, someObj);
-         LOGUNIT_ASSERT_EQUAL((size_t) 0, vectorAppender->getVector().size());
-       }
+	void testShortCircuit()
+	{
+		LoggerPtr logger(Logger::getLogger("StreamTestCase.shortCircuit"));
+		logger->setLevel(Level::getInfo());
+		ExceptionOnInsert someObj;
+		LOG4CXX_DEBUG(logger, someObj);
+		LOGUNIT_ASSERT_EQUAL((size_t) 0, vectorAppender->getVector().size());
+	}
 
-       void testInsertException() {
-         LoggerPtr logger(Logger::getLogger("StreamTestCase.insertException"));
-         ExceptionOnInsert someObj;
-         LOG4CXX_INFO(logger, someObj);
-       }
+	void testInsertException()
+	{
+		LoggerPtr logger(Logger::getLogger("StreamTestCase.insertException"));
+		ExceptionOnInsert someObj;
+		LOG4CXX_INFO(logger, someObj);
+	}
 
-       void testScientific() {
-           LoggerPtr root(Logger::getRootLogger());
-           LOG4CXX_INFO(root, std::scientific << 0.000001115);
-           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 testScientific()
+	{
+		LoggerPtr root(Logger::getRootLogger());
+		LOG4CXX_INFO(root, std::scientific << 0.000001115);
+		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 testPrecision() {
-          LoggerPtr root(Logger::getRootLogger());
-          LOG4CXX_INFO(root, std::setprecision(4) << 1.000001);
-          spi::LoggingEventPtr event(vectorAppender->getVector()[0]);
-          LogString msg(event->getMessage());
-          LOGUNIT_ASSERT(msg.find(LOG4CXX_STR("1.00000")) == LogString::npos);
-      }
+	void testPrecision()
+	{
+		LoggerPtr root(Logger::getRootLogger());
+		LOG4CXX_INFO(root, std::setprecision(4) << 1.000001);
+		spi::LoggingEventPtr event(vectorAppender->getVector()[0]);
+		LogString msg(event->getMessage());
+		LOGUNIT_ASSERT(msg.find(LOG4CXX_STR("1.00000")) == LogString::npos);
+	}
 
 
-      void testWidth() {
-          LoggerPtr root(Logger::getRootLogger());
-          LOG4CXX_INFO(root, '[' << std::fixed << std::setprecision(2) << std::setw(7) << std::right << std::setfill('_') << 10.0 << ']');
-          spi::LoggingEventPtr event(vectorAppender->getVector()[0]);
-          LogString msg(event->getMessage());
-          LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("[__10.00]")), msg);
-       }
+	void testWidth()
+	{
+		LoggerPtr root(Logger::getRootLogger());
+		LOG4CXX_INFO(root, '[' << std::fixed << std::setprecision(2) << std::setw(7) << std::right << std::setfill('_') << 10.0 << ']');
+		spi::LoggingEventPtr event(vectorAppender->getVector()[0]);
+		LogString msg(event->getMessage());
+		LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("[__10.00]")), msg);
+	}
 
-       void testBaseFlags() {
-           logstream base1(Logger::getRootLogger(), Level::getInfo());
-           logstream base2(Logger::getRootLogger(), Level::getInfo());
-           base1 << std::boolalpha;
-           base2 << std::noboolalpha;
-           std::ostringstream os1a, os1b, os2a, os2b;
-           os1a << std::boolalpha;
-           int fillchar;
-           if (base1.set_stream_state(os1b, fillchar)) {
-               os1b.fill(fillchar);
-            }
-           LOGUNIT_ASSERT_EQUAL(os1a.flags(), os1b.flags());
-           os2a << std::noboolalpha;
-           if (base2.set_stream_state(os2b, fillchar)) {
-               os2b.fill(fillchar);
-            }
-           LOGUNIT_ASSERT_EQUAL(os2a.flags(), os2b.flags());
-       }
+	void testBaseFlags()
+	{
+		logstream base1(Logger::getRootLogger(), Level::getInfo());
+		logstream base2(Logger::getRootLogger(), Level::getInfo());
+		base1 << std::boolalpha;
+		base2 << std::noboolalpha;
+		std::ostringstream os1a, os1b, os2a, os2b;
+		os1a << std::boolalpha;
+		int fillchar;
+
+		if (base1.set_stream_state(os1b, fillchar))
+		{
+			os1b.fill(fillchar);
+		}
+
+		LOGUNIT_ASSERT_EQUAL(os1a.flags(), os1b.flags());
+		os2a << std::noboolalpha;
+
+		if (base2.set_stream_state(os2b, fillchar))
+		{
+			os2b.fill(fillchar);
+		}
+
+		LOGUNIT_ASSERT_EQUAL(os2a.flags(), os2b.flags());
+	}
 
 
-       void testBasePrecisionAndWidth() {
-           logstream base(Logger::getRootLogger(), Level::getInfo());
-           base.precision(2);
-           base.width(5);
-           std::ostringstream os1, os2;
-           os1.precision(2);
-           os1.width(5);
-           os1 << 3.1415926;
-           int fillchar;
-           if (base.set_stream_state(os2, fillchar)) {
-               os2.fill(fillchar);
-            }
-           os2 << 3.1415926;
-           string expected(os1.str());
-           string actual(os2.str());
-           LOGUNIT_ASSERT_EQUAL(expected, actual);
-       }
-       
-        void testLogStreamSimple() {
-            logstream root(Logger::getRootLogger(), Level::getInfo());
-            root << std::string("This is a test") << LOG4CXX_ENDMSG;
-            LOGUNIT_ASSERT_EQUAL((size_t) 1, vectorAppender->getVector().size());
-        }
+	void testBasePrecisionAndWidth()
+	{
+		logstream base(Logger::getRootLogger(), Level::getInfo());
+		base.precision(2);
+		base.width(5);
+		std::ostringstream os1, os2;
+		os1.precision(2);
+		os1.width(5);
+		os1 << 3.1415926;
+		int fillchar;
 
-        void testLogStreamMultiple() {
-           logstream root(Logger::getRootLogger(), Level::getInfo());
-           root << std::string("This is a test") << std::string(": Details to follow") << LOG4CXX_ENDMSG;
-           LOGUNIT_ASSERT_EQUAL((size_t) 1, vectorAppender->getVector().size());
-       }
+		if (base.set_stream_state(os2, fillchar))
+		{
+			os2.fill(fillchar);
+		}
 
-       void testLogStreamShortCircuit() {
-         LoggerPtr logger(Logger::getLogger("StreamTestCase.shortCircuit"));
-         logger->setLevel(Level::getInfo());
-         logstream os(logger, Level::getDebug());
-         ExceptionOnInsert someObj;
-         os << someObj << LOG4CXX_ENDMSG;
-         LOGUNIT_ASSERT_EQUAL((size_t) 0, vectorAppender->getVector().size());
-       }
+		os2 << 3.1415926;
+		string expected(os1.str());
+		string actual(os2.str());
+		LOGUNIT_ASSERT_EQUAL(expected, actual);
+	}
 
-       void testLogStreamInsertException() {
-         LoggerPtr logger(Logger::getLogger("StreamTestCase.insertException"));
-         ExceptionOnInsert someObj;
-         logstream os(logger, Level::getInfo());
-         os << someObj << LOG4CXX_ENDMSG;
-       }
+	void testLogStreamSimple()
+	{
+		logstream root(Logger::getRootLogger(), Level::getInfo());
+		root << std::string("This is a test") << LOG4CXX_ENDMSG;
+		LOGUNIT_ASSERT_EQUAL((size_t) 1, vectorAppender->getVector().size());
+	}
 
-       void testLogStreamScientific() {
-           LoggerPtr root(Logger::getRootLogger());
-           logstream 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 testLogStreamMultiple()
+	{
+		logstream root(Logger::getRootLogger(), Level::getInfo());
+		root << std::string("This is a test") << std::string(": Details to follow") << LOG4CXX_ENDMSG;
+		LOGUNIT_ASSERT_EQUAL((size_t) 1, vectorAppender->getVector().size());
+	}
 
-       void testLogStreamPrecision() {
-          LoggerPtr root(Logger::getRootLogger());
-          logstream 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 testLogStreamShortCircuit()
+	{
+		LoggerPtr logger(Logger::getLogger("StreamTestCase.shortCircuit"));
+		logger->setLevel(Level::getInfo());
+		logstream os(logger, Level::getDebug());
+		ExceptionOnInsert someObj;
+		os << someObj << LOG4CXX_ENDMSG;
+		LOGUNIT_ASSERT_EQUAL((size_t) 0, vectorAppender->getVector().size());
+	}
+
+	void testLogStreamInsertException()
+	{
+		LoggerPtr logger(Logger::getLogger("StreamTestCase.insertException"));
+		ExceptionOnInsert someObj;
+		logstream os(logger, Level::getInfo());
+		os << someObj << LOG4CXX_ENDMSG;
+	}
+
+	void testLogStreamScientific()
+	{
+		LoggerPtr root(Logger::getRootLogger());
+		logstream 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 testLogStreamPrecision()
+	{
+		LoggerPtr root(Logger::getRootLogger());
+		logstream 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 testLogStreamWidth() {
-          LoggerPtr root(Logger::getRootLogger());
-          logstream os(root, Level::getInfo());
-          os << '[' << std::fixed << std::setprecision(2) << std::setw(7) << std::right << std::setfill('_') << 10.0 << ']' << LOG4CXX_ENDMSG;
-          spi::LoggingEventPtr event(vectorAppender->getVector()[0]);
-          LogString msg(event->getMessage());
-          LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("[__10.00]")), msg);
-       }
-       
-       void report(std::ostream& os) {
-          os << "This just in: \n";
-          os << "Use logstream in places that expect a std::ostream.\n";
-       }
-       
-        void testLogStreamDelegate() {
-            logstream root(Logger::getRootLogger(), Level::getInfo());
-            report(root);
-            root << LOG4CXX_ENDMSG;
-            LOGUNIT_ASSERT_EQUAL((size_t) 1, vectorAppender->getVector().size());
-        }
-        
-        void testLogStreamFormattingPersists() {
-          LoggerPtr root(Logger::getRootLogger());
-          root->setLevel(Level::getInfo());
-          logstream 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 testLogStreamWidth()
+	{
+		LoggerPtr root(Logger::getRootLogger());
+		logstream os(root, Level::getInfo());
+		os << '[' << std::fixed << std::setprecision(2) << std::setw(7) << std::right << std::setfill('_') << 10.0 << ']' << LOG4CXX_ENDMSG;
+		spi::LoggingEventPtr event(vectorAppender->getVector()[0]);
+		LogString msg(event->getMessage());
+		LOGUNIT_ASSERT_EQUAL(LogString(LOG4CXX_STR("[__10.00]")), msg);
+	}
 
-        void testSetWidthInsert() {
-          LoggerPtr root(Logger::getRootLogger());
-          root->setLevel(Level::getInfo());
-          logstream os(root, Level::getInfo());
-          os << std::setw(5);
-          LOGUNIT_ASSERT_EQUAL(5, os.width());
-        }
-        
-        
+	void report(std::ostream & os)
+	{
+		os << "This just in: \n";
+		os << "Use logstream in places that expect a std::ostream.\n";
+	}
+
+	void testLogStreamDelegate()
+	{
+		logstream root(Logger::getRootLogger(), Level::getInfo());
+		report(root);
+		root << LOG4CXX_ENDMSG;
+		LOGUNIT_ASSERT_EQUAL((size_t) 1, vectorAppender->getVector().size());
+	}
+
+	void testLogStreamFormattingPersists()
+	{
+		LoggerPtr root(Logger::getRootLogger());
+		root->setLevel(Level::getInfo());
+		logstream 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 testSetWidthInsert()
+	{
+		LoggerPtr root(Logger::getRootLogger());
+		root->setLevel(Level::getInfo());
+		logstream os(root, Level::getInfo());
+		os << std::setw(5);
+		LOGUNIT_ASSERT_EQUAL(5, os.width());
+	}
+
+
 
 #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 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 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 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 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 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 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 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 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 testWLogStreamInsertException() {
-         LoggerPtr logger(Logger::getLogger("StreamTestCase.insertException"));
-         ExceptionOnInsert someObj;
-         wlogstream os(logger, Level::getInfo());
-         os << someObj << LOG4CXX_ENDMSG;
-       }
+	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 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 testWLogStreamInsertException()
+	{
+		LoggerPtr logger(Logger::getLogger("StreamTestCase.insertException"));
+		ExceptionOnInsert someObj;
+		wlogstream os(logger, Level::getInfo());
+		os << someObj << LOG4CXX_ENDMSG;
+	}
 
-       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 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 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 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        
+	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 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 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 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 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 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 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 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 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 testULogStreamInsertException() {
-         LoggerPtr logger(Logger::getLogger("StreamTestCase.insertException"));
-         ExceptionOnInsert someObj;
-         ulogstream os(logger, Level::getInfo());
-         os << someObj << LOG4CXX_ENDMSG;
-       }
+	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 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 testULogStreamInsertException()
+	{
+		LoggerPtr logger(Logger::getLogger("StreamTestCase.insertException"));
+		ExceptionOnInsert someObj;
+		ulogstream os(logger, Level::getInfo());
+		os << someObj << LOG4CXX_ENDMSG;
+	}
 
-       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 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 testULogStreamWidth()
+	{
+		LoggerPtr root(Logger::getRootLogger());
+		ulogstream os(root, Level::getInfo());
+		const log4cxx::UniChar openBracket[] = { '[', 0 };
+		const log4cxx::UniChar closeBracket[] = { ']', 0 };
 
-        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        
+		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 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 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 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());
-       }
+	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
 
 };
@@ -591,15 +656,15 @@
 //      templated operator<< in class scope.s
 namespace foo
 {
-  class Bar
-  {
-    void fn();
-  };
-  
-std::ostream &operator<<(std::ostream &o, Bar const &b)
-  {
-    return o << "Bar";
-  }
+class Bar
+{
+		void fn();
+};
+
+std::ostream& operator<<(std::ostream& o, Bar const& b)
+{
+	return o << "Bar";
+}
 }
 
 
@@ -607,13 +672,13 @@
 
 namespace
 {
-  log4cxx::LoggerPtr logger(log4cxx::Logger::getLogger("foo"));
-  log4cxx::logstream lout(logger, log4cxx::Level::getDebug());
+log4cxx::LoggerPtr logger(log4cxx::Logger::getLogger("foo"));
+log4cxx::logstream lout(logger, log4cxx::Level::getDebug());
 }
 
 void Bar::fn()
 {
-  lout << "hi" << LOG4CXX_ENDMSG;
+	lout << "hi" << LOG4CXX_ENDMSG;
 }
 #endif
 
diff --git a/src/test/cpp/testchar.h b/src/test/cpp/testchar.h
index 0ea7559..beab2e8 100644
--- a/src/test/cpp/testchar.h
+++ b/src/test/cpp/testchar.h
@@ -23,11 +23,11 @@
 //      check either the wchar_t or char based methods.
 //
 #if LOG4CXX_WCHAR_T_API && defined(LOG4CXX_TEST_WCHAR)
-#define LOG4CXX_TEST_STR(str) L ## str
-typedef wchar_t testchar;
+	#define LOG4CXX_TEST_STR(str) L ## str
+	typedef wchar_t testchar;
 #else
-#define LOG4CXX_TEST_STR(str) str
-typedef char testchar;
+	#define LOG4CXX_TEST_STR(str) str
+	typedef char testchar;
 #endif
 
 #endif
diff --git a/src/test/cpp/util/absolutedateandtimefilter.cpp b/src/test/cpp/util/absolutedateandtimefilter.cpp
index 0e99213..d72129e 100644
--- a/src/test/cpp/util/absolutedateandtimefilter.cpp
+++ b/src/test/cpp/util/absolutedateandtimefilter.cpp
@@ -21,4 +21,4 @@
 using namespace log4cxx::helpers;
 
 AbsoluteDateAndTimeFilter::AbsoluteDateAndTimeFilter() :
-     Filter(ABSOLUTE_DATE_AND_TIME_PAT, "") {}
+	Filter(ABSOLUTE_DATE_AND_TIME_PAT, "") {}
diff --git a/src/test/cpp/util/absolutedateandtimefilter.h b/src/test/cpp/util/absolutedateandtimefilter.h
index 98398eb..821cd86 100644
--- a/src/test/cpp/util/absolutedateandtimefilter.h
+++ b/src/test/cpp/util/absolutedateandtimefilter.h
@@ -22,11 +22,11 @@
 
 namespace log4cxx
 {
-   class AbsoluteDateAndTimeFilter : public Filter
-   {
-   public:
-       AbsoluteDateAndTimeFilter();
-   };
+class AbsoluteDateAndTimeFilter : public Filter
+{
+	public:
+		AbsoluteDateAndTimeFilter();
+};
 }
 
 
diff --git a/src/test/cpp/util/absolutetimefilter.cpp b/src/test/cpp/util/absolutetimefilter.cpp
index 082a579..87ac0a5 100644
--- a/src/test/cpp/util/absolutetimefilter.cpp
+++ b/src/test/cpp/util/absolutetimefilter.cpp
@@ -21,4 +21,4 @@
 using namespace log4cxx::helpers;
 
 AbsoluteTimeFilter::AbsoluteTimeFilter()
-    : Filter(ABSOLUTE_TIME_PAT, "") {}
+	: Filter(ABSOLUTE_TIME_PAT, "") {}
diff --git a/src/test/cpp/util/absolutetimefilter.h b/src/test/cpp/util/absolutetimefilter.h
index 5869da4..3d82f63 100644
--- a/src/test/cpp/util/absolutetimefilter.h
+++ b/src/test/cpp/util/absolutetimefilter.h
@@ -22,11 +22,11 @@
 
 namespace log4cxx
 {
-   class AbsoluteTimeFilter : public Filter
-   {
-   public:
-       AbsoluteTimeFilter();
-   };
+class AbsoluteTimeFilter : public Filter
+{
+	public:
+		AbsoluteTimeFilter();
+};
 }
 
 
diff --git a/src/test/cpp/util/binarycompare.cpp b/src/test/cpp/util/binarycompare.cpp
index 917416b..5752ccb 100644
--- a/src/test/cpp/util/binarycompare.cpp
+++ b/src/test/cpp/util/binarycompare.cpp
@@ -26,57 +26,68 @@
 using namespace log4cxx::helpers;
 
 void BinaryCompare::compare(const char* filename1,
-                            const char* filename2) {
-    Pool p;
-    apr_pool_t* pool = p.getAPRPool();
-    apr_file_t* file1;
-    apr_int32_t flags = APR_FOPEN_READ;
-    apr_fileperms_t perm = APR_OS_DEFAULT;
-    apr_status_t stat1 = apr_file_open(&file1,
-        filename1, flags, perm, pool);
-    if (stat1 != APR_SUCCESS) {
-      LOGUNIT_FAIL(std::string("Unable to open ") + filename1);
-    }
+	const char* filename2)
+{
+	Pool p;
+	apr_pool_t* pool = p.getAPRPool();
+	apr_file_t* file1;
+	apr_int32_t flags = APR_FOPEN_READ;
+	apr_fileperms_t perm = APR_OS_DEFAULT;
+	apr_status_t stat1 = apr_file_open(&file1,
+			filename1, flags, perm, pool);
 
-    apr_file_t* file2;
-    apr_status_t stat2 = apr_file_open(&file2,
-        filename2, flags, perm, pool);
-    if (stat2 != APR_SUCCESS) {
-      LOGUNIT_FAIL(std::string("Unable to open ") + filename2);
-    }
+	if (stat1 != APR_SUCCESS)
+	{
+		LOGUNIT_FAIL(std::string("Unable to open ") + filename1);
+	}
 
-    enum { BUFSIZE = 1024 };
-    char* contents1 = (char*) apr_palloc(pool, BUFSIZE);
-    char* contents2 = (char*) apr_palloc(pool, BUFSIZE);
-    memset(contents1, 0, BUFSIZE);
-    memset(contents2, 0, BUFSIZE);
-    apr_size_t bytesRead1 = BUFSIZE;
-    apr_size_t bytesRead2 = BUFSIZE;
+	apr_file_t* file2;
+	apr_status_t stat2 = apr_file_open(&file2,
+			filename2, flags, perm, pool);
 
-    stat1 = apr_file_read(file1, contents1, &bytesRead1);
-    if (stat1 != APR_SUCCESS) {
-      LOGUNIT_FAIL(std::string("Unable to read ") + filename1);
-    }
+	if (stat2 != APR_SUCCESS)
+	{
+		LOGUNIT_FAIL(std::string("Unable to open ") + filename2);
+	}
 
-    stat2 = apr_file_read(file2, contents2, &bytesRead2);
-    if (stat2 != APR_SUCCESS) {
-      LOGUNIT_FAIL(std::string("Unable to read ") + filename2);
-    }
+	enum { BUFSIZE = 1024 };
+	char* contents1 = (char*) apr_palloc(pool, BUFSIZE);
+	char* contents2 = (char*) apr_palloc(pool, BUFSIZE);
+	memset(contents1, 0, BUFSIZE);
+	memset(contents2, 0, BUFSIZE);
+	apr_size_t bytesRead1 = BUFSIZE;
+	apr_size_t bytesRead2 = BUFSIZE;
 
-    for (int i = 0; i < BUFSIZE; i++) {
-       if (contents1[i] != contents2[i]) {
-         std::string msg("Contents differ at position ");
-         msg += apr_itoa(pool, i);
-         msg += ": [";
-         msg += filename1;
-         msg += "] has ";
-         msg += apr_itoa(pool, contents1[i]);
-         msg += ", [";
-         msg += filename2;
-         msg += "] has ";
-         msg += apr_itoa(pool, contents2[i]);
-         msg += ".";
-         LOGUNIT_FAIL(msg);
-       }
-    }
+	stat1 = apr_file_read(file1, contents1, &bytesRead1);
+
+	if (stat1 != APR_SUCCESS)
+	{
+		LOGUNIT_FAIL(std::string("Unable to read ") + filename1);
+	}
+
+	stat2 = apr_file_read(file2, contents2, &bytesRead2);
+
+	if (stat2 != APR_SUCCESS)
+	{
+		LOGUNIT_FAIL(std::string("Unable to read ") + filename2);
+	}
+
+	for (int i = 0; i < BUFSIZE; i++)
+	{
+		if (contents1[i] != contents2[i])
+		{
+			std::string msg("Contents differ at position ");
+			msg += apr_itoa(pool, i);
+			msg += ": [";
+			msg += filename1;
+			msg += "] has ";
+			msg += apr_itoa(pool, contents1[i]);
+			msg += ", [";
+			msg += filename2;
+			msg += "] has ";
+			msg += apr_itoa(pool, contents2[i]);
+			msg += ".";
+			LOGUNIT_FAIL(msg);
+		}
+	}
 }
diff --git a/src/test/cpp/util/binarycompare.h b/src/test/cpp/util/binarycompare.h
index d4706f3..f6215d8 100644
--- a/src/test/cpp/util/binarycompare.h
+++ b/src/test/cpp/util/binarycompare.h
@@ -19,18 +19,19 @@
 
 namespace log4cxx
 {
-   namespace util {
-        class BinaryCompare
-        {
-        private:
-            /**
-             * Class can not be constructed.
-             */
-            BinaryCompare();
+namespace util
+{
+class BinaryCompare
+{
+	private:
+		/**
+		 * Class can not be constructed.
+		 */
+		BinaryCompare();
 
-        public:
-            static void compare(const char* filename1,
-                            const char* filename2);
-        };
-   }
+	public:
+		static void compare(const char* filename1,
+			const char* filename2);
+};
+}
 }
diff --git a/src/test/cpp/util/compare.cpp b/src/test/cpp/util/compare.cpp
index 6c8aa07..b16fc37 100644
--- a/src/test/cpp/util/compare.cpp
+++ b/src/test/cpp/util/compare.cpp
@@ -28,143 +28,160 @@
 
 bool Compare::compare(const File& file1, const File& file2)
 {
-    Pool pool;
-    InputStreamPtr fileIn1 = new FileInputStream(file1);
-    InputStreamReaderPtr reader1 = new InputStreamReader(fileIn1);
-    LogString in1(reader1->read(pool));
+	Pool pool;
+	InputStreamPtr fileIn1 = new FileInputStream(file1);
+	InputStreamReaderPtr reader1 = new InputStreamReader(fileIn1);
+	LogString in1(reader1->read(pool));
 
-    Pool pool2;
-    InputStreamPtr fileIn2 = new FileInputStream(file2);
-    InputStreamReaderPtr reader2 = new InputStreamReader(fileIn2);
-    LogString in2(reader2->read(pool2));
+	Pool pool2;
+	InputStreamPtr fileIn2 = new FileInputStream(file2);
+	InputStreamReaderPtr reader2 = new InputStreamReader(fileIn2);
+	LogString in2(reader2->read(pool2));
 
-    LogString back1(in1);
-    LogString back2(in2);
+	LogString back1(in1);
+	LogString back2(in2);
 
-    LogString s1;
-    LogString s2;
-        int lineCounter = 0;
+	LogString s1;
+	LogString s2;
+	int lineCounter = 0;
 
-        while (getline(in1, s1))
-        {
-                lineCounter++;
+	while (getline(in1, s1))
+	{
+		lineCounter++;
 
-        if(!getline(in2, s2)) {
-          s2.erase(s2.begin(), s2.end());
-        }
+		if (!getline(in2, s2))
+		{
+			s2.erase(s2.begin(), s2.end());
+		}
 
-        if (s1 != s2) {
-            LogString msg(LOG4CXX_STR("Files ["));
-            msg += file1.getPath();
-            msg += LOG4CXX_STR("] and [");
-            msg += file2.getPath();
-            msg += LOG4CXX_STR("] differ on line ");
-            StringHelper::toString(lineCounter, pool, msg);
-            msg += LOG4CXX_EOL;
-            msg += LOG4CXX_STR("One reads:  [");
-            msg += s1;
-            msg += LOG4CXX_STR("].");
-            msg += LOG4CXX_EOL;
-            msg += LOG4CXX_STR("Other reads:[");
-            msg += s2;
-            msg += LOG4CXX_STR("].");
-            msg += LOG4CXX_EOL;
-            emit(msg);
+		if (s1 != s2)
+		{
+			LogString msg(LOG4CXX_STR("Files ["));
+			msg += file1.getPath();
+			msg += LOG4CXX_STR("] and [");
+			msg += file2.getPath();
+			msg += LOG4CXX_STR("] differ on line ");
+			StringHelper::toString(lineCounter, pool, msg);
+			msg += LOG4CXX_EOL;
+			msg += LOG4CXX_STR("One reads:  [");
+			msg += s1;
+			msg += LOG4CXX_STR("].");
+			msg += LOG4CXX_EOL;
+			msg += LOG4CXX_STR("Other reads:[");
+			msg += s2;
+			msg += LOG4CXX_STR("].");
+			msg += LOG4CXX_EOL;
+			emit(msg);
 
-            outputFile(file1, back1, pool);
-                        outputFile(file2, back2, pool);
+			outputFile(file1, back1, pool);
+			outputFile(file2, back2, pool);
 
-                        return false;
-                }
-        }
+			return false;
+		}
+	}
 
-        // the second file is longer
-    if (getline(in2, s2)) {
-        LogString msg(LOG4CXX_STR("File ["));
-        msg += file2.getPath();
-        msg += LOG4CXX_STR("] longer than file [");
-        msg += file1.getPath();
-        msg += LOG4CXX_STR("].");
-        msg += LOG4CXX_EOL;
-        emit(msg);
-                outputFile(file1, back1, pool);
-                outputFile(file2, back2, pool);
+	// the second file is longer
+	if (getline(in2, s2))
+	{
+		LogString msg(LOG4CXX_STR("File ["));
+		msg += file2.getPath();
+		msg += LOG4CXX_STR("] longer than file [");
+		msg += file1.getPath();
+		msg += LOG4CXX_STR("].");
+		msg += LOG4CXX_EOL;
+		emit(msg);
+		outputFile(file1, back1, pool);
+		outputFile(file2, back2, pool);
 
-                return false;
-        }
+		return false;
+	}
 
-        return true;
+	return true;
 }
 
 void Compare::outputFile(const File& file,
-                        const LogString& contents,
-                        log4cxx::helpers::Pool& pool)
+	const LogString& contents,
+	log4cxx::helpers::Pool& pool)
 {
-        int lineCounter = 0;
-        emit(LOG4CXX_STR("--------------------------------"));
-        emit(LOG4CXX_EOL);
-        LogString msg(LOG4CXX_STR("Contents of "));
-        msg += file.getPath();
-        msg += LOG4CXX_STR(":");
-        msg += LOG4CXX_EOL;
-        emit(msg);
-        LogString in1(contents);
-        LogString s1;
+	int lineCounter = 0;
+	emit(LOG4CXX_STR("--------------------------------"));
+	emit(LOG4CXX_EOL);
+	LogString msg(LOG4CXX_STR("Contents of "));
+	msg += file.getPath();
+	msg += LOG4CXX_STR(":");
+	msg += LOG4CXX_EOL;
+	emit(msg);
+	LogString in1(contents);
+	LogString s1;
 
-        while (getline(in1, s1))
-        {
-                lineCounter++;
-                LogString line;
-                StringHelper::toString(lineCounter, pool, line);
-                emit(line);
+	while (getline(in1, s1))
+	{
+		lineCounter++;
+		LogString line;
+		StringHelper::toString(lineCounter, pool, line);
+		emit(line);
 
-                if (lineCounter < 10)
-                {
-                        emit(LOG4CXX_STR("   : "));
-                }
-                else if (lineCounter < 100)
-                {
-                        emit(LOG4CXX_STR("  : "));
-                }
-                else if (lineCounter < 1000)
-                {
-                        emit(LOG4CXX_STR(" : "));
-                }
-                else
-                {
-                        emit(LOG4CXX_STR(": "));
-                }
-                emit(s1);
-                emit(LOG4CXX_EOL);
-        }
+		if (lineCounter < 10)
+		{
+			emit(LOG4CXX_STR("   : "));
+		}
+		else if (lineCounter < 100)
+		{
+			emit(LOG4CXX_STR("  : "));
+		}
+		else if (lineCounter < 1000)
+		{
+			emit(LOG4CXX_STR(" : "));
+		}
+		else
+		{
+			emit(LOG4CXX_STR(": "));
+		}
+
+		emit(s1);
+		emit(LOG4CXX_EOL);
+	}
 }
 
-void Compare::emit(const LogString& s1) {
-  SystemOutWriter::write(s1);
+void Compare::emit(const LogString& s1)
+{
+	SystemOutWriter::write(s1);
 }
 
 
-bool Compare::getline(LogString& in, LogString& line) {
-  if (in.empty()) {
-    return false;
-  }
-  size_t nl = in.find(0x0A);
-  if (nl == std::string::npos) {
-    line = in;
-    in.erase(in.begin(), in.end());
-  } else {
-      //
-      //  if the file has CR-LF then
-      //    drop the carriage return alse
-      //
-      if(nl > 0 && in[nl -1] ==  0x0D) {
-          line.assign(in, 0, nl - 1);
-      } else {
-          line.assign(in, 0, nl);
-      }
-      in.erase(in.begin(), in.begin() + nl + 1);
-  }
-  return true;
+bool Compare::getline(LogString& in, LogString& line)
+{
+	if (in.empty())
+	{
+		return false;
+	}
+
+	size_t nl = in.find(0x0A);
+
+	if (nl == std::string::npos)
+	{
+		line = in;
+		in.erase(in.begin(), in.end());
+	}
+	else
+	{
+		//
+		//  if the file has CR-LF then
+		//    drop the carriage return alse
+		//
+		if (nl > 0 && in[nl - 1] ==  0x0D)
+		{
+			line.assign(in, 0, nl - 1);
+		}
+		else
+		{
+			line.assign(in, 0, nl);
+		}
+
+		in.erase(in.begin(), in.begin() + nl + 1);
+	}
+
+	return true;
 }
 
 
diff --git a/src/test/cpp/util/compare.h b/src/test/cpp/util/compare.h
index 656ebd2..3881050 100644
--- a/src/test/cpp/util/compare.h
+++ b/src/test/cpp/util/compare.h
@@ -19,25 +19,26 @@
 
 namespace log4cxx
 {
-        class File;
-        namespace helpers {
-            class Pool;
-        }
+class File;
+namespace helpers
+{
+class Pool;
+}
 
-        class Compare
-        {
-        public:
-                static bool compare(const File& file1,
-                  const File& file2);
+class Compare
+{
+	public:
+		static bool compare(const File& file1,
+			const File& file2);
 
-        private:
-                /// Prints file on the console.
-                static void outputFile(const File& file,
-                      const LogString& contents,
-                      log4cxx::helpers::Pool& pool);
+	private:
+		/// Prints file on the console.
+		static void outputFile(const File& file,
+			const LogString& contents,
+			log4cxx::helpers::Pool& pool);
 
-                static void emit(const LogString &line);
-                static bool getline(LogString& buf, LogString& line);
+		static void emit(const LogString& line);
+		static bool getline(LogString& buf, LogString& line);
 
-        };
+};
 }
diff --git a/src/test/cpp/util/controlfilter.cpp b/src/test/cpp/util/controlfilter.cpp
index dfd7dec..46dd39e 100644
--- a/src/test/cpp/util/controlfilter.cpp
+++ b/src/test/cpp/util/controlfilter.cpp
@@ -26,5 +26,5 @@
 
 ControlFilter& ControlFilter::operator<<(const std::string&)
 {
-   return *this;
+	return *this;
 }
diff --git a/src/test/cpp/util/controlfilter.h b/src/test/cpp/util/controlfilter.h
index 5d1b77c..0382d23 100644
--- a/src/test/cpp/util/controlfilter.h
+++ b/src/test/cpp/util/controlfilter.h
@@ -23,13 +23,13 @@
 
 namespace log4cxx
 {
-   class ControlFilter : public Filter
-   {
-   public:
-      ControlFilter();
-      ControlFilter& operator<<(const std::string& allowedPattern);
+class ControlFilter : public Filter
+{
+	public:
+		ControlFilter();
+		ControlFilter& operator<<(const std::string& allowedPattern);
 
-   };
+};
 }
 
 
diff --git a/src/test/cpp/util/filenamefilter.cpp b/src/test/cpp/util/filenamefilter.cpp
index af45768..9963815 100644
--- a/src/test/cpp/util/filenamefilter.cpp
+++ b/src/test/cpp/util/filenamefilter.cpp
@@ -20,19 +20,26 @@
 using namespace log4cxx;
 using namespace log4cxx::helpers;
 
-FilenameFilter::FilenameFilter(const std::string& actual, const std::string& expected) {
-    std::string pattern(actual);
-   size_t backslash = pattern.rfind('\\', pattern.length() - 1);
-   while (backslash != std::string::npos) {
-      pattern.replace(backslash, 1, "\\\\", 2);
-      if (backslash == 0) {
-         backslash = std::string::npos;
-      } else {
-          backslash = pattern.rfind('\\', backslash - 1);
-      }
-   }
-   
-   patterns.push_back( PatternReplacement(pattern, expected) );
+FilenameFilter::FilenameFilter(const std::string& actual, const std::string& expected)
+{
+	std::string pattern(actual);
+	size_t backslash = pattern.rfind('\\', pattern.length() - 1);
+
+	while (backslash != std::string::npos)
+	{
+		pattern.replace(backslash, 1, "\\\\", 2);
+
+		if (backslash == 0)
+		{
+			backslash = std::string::npos;
+		}
+		else
+		{
+			backslash = pattern.rfind('\\', backslash - 1);
+		}
+	}
+
+	patterns.push_back( PatternReplacement(pattern, expected) );
 }
 
 
diff --git a/src/test/cpp/util/filenamefilter.h b/src/test/cpp/util/filenamefilter.h
index ce12bc6..e6fc39b 100644
--- a/src/test/cpp/util/filenamefilter.h
+++ b/src/test/cpp/util/filenamefilter.h
@@ -22,12 +22,12 @@
 
 namespace log4cxx
 {
-   class FilenameFilter : public Filter
-   {
-   public:
-        FilenameFilter(const std::string& actual, const std::string& expected);
-        static const std::string getMatch(const std::string& actual);
-   };
+class FilenameFilter : public Filter
+{
+	public:
+		FilenameFilter(const std::string& actual, const std::string& expected);
+		static const std::string getMatch(const std::string& actual);
+};
 }
 
 
diff --git a/src/test/cpp/util/filter.h b/src/test/cpp/util/filter.h
index fe2a2b1..18b6dc6 100644
--- a/src/test/cpp/util/filter.h
+++ b/src/test/cpp/util/filter.h
@@ -19,8 +19,8 @@
 #define _LOG4CXX_TESTS_UTIL_FILTER_H
 
 #if defined(_MSC_VER)
-#pragma warning (push)
-#pragma warning ( disable: 4231 4251 4275 4786 )
+	#pragma warning (push)
+	#pragma warning ( disable: 4231 4251 4275 4786 )
 #endif
 
 #include <string>
@@ -31,38 +31,40 @@
 #define BASIC_PAT "\\[0x[0-9A-F]*] (FATAL|ERROR|WARN|INFO|DEBUG)"
 #define ISO8601_PAT "[0-9]\\{4\\}-[0-9]\\{2\\}-[0-9]\\{2\\} [0-9]\\{2\\}:[0-9]\\{2\\}:[0-9]\\{2\\},[0-9]\\{3\\}"
 #define ABSOLUTE_DATE_AND_TIME_PAT \
-        "[0-9]\\{1,2\\} .* 2[0-9][0-9][0-9] [0-9]\\{2\\}:[0-9]\\{2\\}:[0-9]\\{2\\},[0-9]\\{3\\}"
+	"[0-9]\\{1,2\\} .* 2[0-9][0-9][0-9] [0-9]\\{2\\}:[0-9]\\{2\\}:[0-9]\\{2\\},[0-9]\\{3\\}"
 #define ABSOLUTE_TIME_PAT "[0-2][0-9]:[0-9][0-9]:[0-9][0-9],[0-9][0-9][0-9]"
 #define RELATIVE_TIME_PAT "^[0-9]+"
 
 namespace log4cxx
 {
-        class UnexpectedFormatException : public std::exception {
-        };
+class UnexpectedFormatException : public std::exception
+{
+};
 
-        class Filter
-        {
-        public:
-            Filter(const std::string& match, const std::string& replacement);
-            Filter();
-            virtual ~Filter();
+class Filter
+{
+	public:
+		Filter(const std::string& match, const std::string& replacement);
+		Filter();
+		virtual ~Filter();
 
-            typedef std::pair<std::string, std::string> PatternReplacement;
-            typedef std::vector <PatternReplacement> PatternList;
-            const PatternList& getPatterns()  const{
-                return patterns;
-            }
+		typedef std::pair<std::string, std::string> PatternReplacement;
+		typedef std::vector <PatternReplacement> PatternList;
+		const PatternList& getPatterns()  const
+		{
+			return patterns;
+		}
 
-        private:
-            Filter(const Filter&);
-            Filter& operator=(const Filter&);
-        protected:
-            PatternList patterns;
-        };
+	private:
+		Filter(const Filter&);
+		Filter& operator=(const Filter&);
+	protected:
+		PatternList patterns;
+};
 }
 
 #if defined(_MSC_VER)
-#pragma warning (pop)
+	#pragma warning (pop)
 #endif
 
 #endif //_LOG4CXX_TESTS_UTIL_FILTER_H
diff --git a/src/test/cpp/util/iso8601filter.h b/src/test/cpp/util/iso8601filter.h
index 13f65eb..7f27809 100644
--- a/src/test/cpp/util/iso8601filter.h
+++ b/src/test/cpp/util/iso8601filter.h
@@ -22,11 +22,11 @@
 
 namespace log4cxx
 {
-   class ISO8601Filter : public Filter
-   {
-   public:
-       ISO8601Filter();
-   };
+class ISO8601Filter : public Filter
+{
+	public:
+		ISO8601Filter();
+};
 }
 
 
diff --git a/src/test/cpp/util/linenumberfilter.cpp b/src/test/cpp/util/linenumberfilter.cpp
index dad37ed..9f3268f 100644
--- a/src/test/cpp/util/linenumberfilter.cpp
+++ b/src/test/cpp/util/linenumberfilter.cpp
@@ -22,6 +22,6 @@
 
 LineNumberFilter::LineNumberFilter()
 {
-    patterns.push_back( PatternReplacement(" [^ ]*[\\\\]", " "));
-    patterns.push_back( PatternReplacement("([0-9]*)", "(X)"));
+	patterns.push_back( PatternReplacement(" [^ ]*[\\\\]", " "));
+	patterns.push_back( PatternReplacement("([0-9]*)", "(X)"));
 }
diff --git a/src/test/cpp/util/linenumberfilter.h b/src/test/cpp/util/linenumberfilter.h
index baa2fde..24a4b76 100644
--- a/src/test/cpp/util/linenumberfilter.h
+++ b/src/test/cpp/util/linenumberfilter.h
@@ -22,11 +22,11 @@
 
 namespace log4cxx
 {
-   class LineNumberFilter : public Filter
-   {
-   public:
-       LineNumberFilter();
-   };
+class LineNumberFilter : public Filter
+{
+	public:
+		LineNumberFilter();
+};
 }
 
 
diff --git a/src/test/cpp/util/relativetimefilter.cpp b/src/test/cpp/util/relativetimefilter.cpp
index 0a2c1bc..743dc51 100644
--- a/src/test/cpp/util/relativetimefilter.cpp
+++ b/src/test/cpp/util/relativetimefilter.cpp
@@ -20,5 +20,5 @@
 using namespace log4cxx;
 using namespace log4cxx::helpers;
 
-RelativeTimeFilter::RelativeTimeFilter() 
-   : Filter(RELATIVE_TIME_PAT, "") {}
+RelativeTimeFilter::RelativeTimeFilter()
+	: Filter(RELATIVE_TIME_PAT, "") {}
diff --git a/src/test/cpp/util/relativetimefilter.h b/src/test/cpp/util/relativetimefilter.h
index 1d625cb..ff7eb0f 100644
--- a/src/test/cpp/util/relativetimefilter.h
+++ b/src/test/cpp/util/relativetimefilter.h
@@ -22,11 +22,11 @@
 
 namespace log4cxx
 {
-   class RelativeTimeFilter : public Filter
-   {
-   public:
-       RelativeTimeFilter();
-   };
+class RelativeTimeFilter : public Filter
+{
+	public:
+		RelativeTimeFilter();
+};
 }
 
 
diff --git a/src/test/cpp/util/serializationtesthelper.cpp b/src/test/cpp/util/serializationtesthelper.cpp
index fa4b715..b495499 100644
--- a/src/test/cpp/util/serializationtesthelper.cpp
+++ b/src/test/cpp/util/serializationtesthelper.cpp
@@ -31,51 +31,58 @@
 
 
 bool SerializationTestHelper::compare(
-    const char* witness, const LoggingEventPtr& event, size_t endCompare)  {
-    ByteArrayOutputStreamPtr memOut = new ByteArrayOutputStream();
-    Pool p;
-    ObjectOutputStream objOut(memOut, p);
-    event->write(objOut, p);
-    objOut.close(p);
-    return compare(witness, memOut->toByteArray(), endCompare, p);
-  }
+	const char* witness, const LoggingEventPtr& event, size_t endCompare)
+{
+	ByteArrayOutputStreamPtr memOut = new ByteArrayOutputStream();
+	Pool p;
+	ObjectOutputStream objOut(memOut, p);
+	event->write(objOut, p);
+	objOut.close(p);
+	return compare(witness, memOut->toByteArray(), endCompare, p);
+}
 
-  /**
-   * Asserts the serialized form of an object.
-   * @param witness file name of expected serialization.
-   * @param actual byte array of actual serialization.
-   * @param skip positions to skip comparison.
-   * @param endCompare position to stop comparison.
-   * @throws IOException thrown on IO or serialization exception.
-   */
+/**
+ * Asserts the serialized form of an object.
+ * @param witness file name of expected serialization.
+ * @param actual byte array of actual serialization.
+ * @param skip positions to skip comparison.
+ * @param endCompare position to stop comparison.
+ * @throws IOException thrown on IO or serialization exception.
+ */
 bool SerializationTestHelper::compare(
-    const char* witness, const std::vector<unsigned char>& actual, 
-    size_t endCompare, Pool& p) {
-    File witnessFile(witness);
+	const char* witness, const std::vector<unsigned char>& actual,
+	size_t endCompare, Pool& p)
+{
+	File witnessFile(witness);
 
-      char* expected = p.pstralloc(actual.size());
-      FileInputStreamPtr is(new FileInputStream(witnessFile));
-      ByteBuffer readBuffer(expected, actual.size());
-      int bytesRead = is->read(readBuffer);
-      is->close();
+	char* expected = p.pstralloc(actual.size());
+	FileInputStreamPtr is(new FileInputStream(witnessFile));
+	ByteBuffer readBuffer(expected, actual.size());
+	int bytesRead = is->read(readBuffer);
+	is->close();
 
-      if(bytesRead < endCompare) {
-          puts("Witness file is shorter than expected");
-          return false;
-      }
+	if (bytesRead < endCompare)
+	{
+		puts("Witness file is shorter than expected");
+		return false;
+	}
 
-      int endScan = actual.size();
+	int endScan = actual.size();
 
-      if (endScan > endCompare) {
-        endScan = endCompare;
-      }
+	if (endScan > endCompare)
+	{
+		endScan = endCompare;
+	}
 
-      for (int i = 0; i < endScan; i++) {
-          if (((unsigned char) expected[i]) != actual[i]) {
-            printf("Difference at offset %d, expected %x, actual %x\n", i, expected[i], actual[i]);
-            return false;
-          }
-        }
-    return true;
-  
+	for (int i = 0; i < endScan; i++)
+	{
+		if (((unsigned char) expected[i]) != actual[i])
+		{
+			printf("Difference at offset %d, expected %x, actual %x\n", i, expected[i], actual[i]);
+			return false;
+		}
+	}
+
+	return true;
+
 }
diff --git a/src/test/cpp/util/serializationtesthelper.h b/src/test/cpp/util/serializationtesthelper.h
index 63b5b74..5d1cdcd 100644
--- a/src/test/cpp/util/serializationtesthelper.h
+++ b/src/test/cpp/util/serializationtesthelper.h
@@ -22,21 +22,23 @@
 
 namespace log4cxx
 {
-       namespace util {
-            class SerializationTestHelper {
-            public:
-                static bool compare(const char* filename,
-                          const log4cxx::spi::LoggingEventPtr& event,
-                          size_t stopCompare);
-                static bool compare(const char* filename,
-                          const std::vector<unsigned char>& array,
-                          size_t stopCompare, log4cxx::helpers::Pool& p);
-            private:
-                SerializationTestHelper();
-                SerializationTestHelper(const SerializationTestHelper&);
-                SerializationTestHelper& operator=(SerializationTestHelper&);
-            };
-        }
+namespace util
+{
+class SerializationTestHelper
+{
+	public:
+		static bool compare(const char* filename,
+			const log4cxx::spi::LoggingEventPtr& event,
+			size_t stopCompare);
+		static bool compare(const char* filename,
+			const std::vector<unsigned char>& array,
+			size_t stopCompare, log4cxx::helpers::Pool& p);
+	private:
+		SerializationTestHelper();
+		SerializationTestHelper(const SerializationTestHelper&);
+		SerializationTestHelper& operator=(SerializationTestHelper&);
+};
+}
 }
 
 #endif
diff --git a/src/test/cpp/util/threadfilter.h b/src/test/cpp/util/threadfilter.h
index 0408fcd..60be36a 100644
--- a/src/test/cpp/util/threadfilter.h
+++ b/src/test/cpp/util/threadfilter.h
@@ -22,11 +22,11 @@
 
 namespace log4cxx
 {
-   class ThreadFilter : public Filter
-   {
-   public:
-       ThreadFilter();
-   };
+class ThreadFilter : public Filter
+{
+	public:
+		ThreadFilter();
+};
 }
 
 
diff --git a/src/test/cpp/util/transformer.cpp b/src/test/cpp/util/transformer.cpp
index b7c8ad8..037dd44 100644
--- a/src/test/cpp/util/transformer.cpp
+++ b/src/test/cpp/util/transformer.cpp
@@ -29,194 +29,214 @@
 using namespace log4cxx::helpers;
 
 #if !defined(APR_FOPEN_READ)
-#define APR_FOPEN_READ APR_READ
-#define APR_FOPEN_CREATE APR_CREATE
-#define APR_FOPEN_WRITE APR_WRITE
-#define APR_FOPEN_TRUNCATE APR_TRUNCATE
-#define APR_FOPEN_APPEND APR_APPEND
+	#define APR_FOPEN_READ APR_READ
+	#define APR_FOPEN_CREATE APR_CREATE
+	#define APR_FOPEN_WRITE APR_WRITE
+	#define APR_FOPEN_TRUNCATE APR_TRUNCATE
+	#define APR_FOPEN_APPEND APR_APPEND
 #endif
 
 void Transformer::transform(const File& in, const File& out,
-        const std::vector<Filter *>& filters)
+	const std::vector<Filter*>& filters)
 {
-     log4cxx::Filter::PatternList patterns;
-     for(std::vector<Filter*>::const_iterator iter = filters.begin();
-         iter != filters.end();
-         iter++) {
+	log4cxx::Filter::PatternList patterns;
 
-         const log4cxx::Filter::PatternList& thesePatterns = (*iter)->getPatterns();
-         for (log4cxx::Filter::PatternList::const_iterator pattern = thesePatterns.begin();
-              pattern != thesePatterns.end();
-              pattern++) {
-              patterns.push_back(*pattern);
-         }
-     }
-     transform(in, out, patterns);
+	for (std::vector<Filter*>::const_iterator iter = filters.begin();
+		iter != filters.end();
+		iter++)
+	{
+
+		const log4cxx::Filter::PatternList& thesePatterns = (*iter)->getPatterns();
+
+		for (log4cxx::Filter::PatternList::const_iterator pattern = thesePatterns.begin();
+			pattern != thesePatterns.end();
+			pattern++)
+		{
+			patterns.push_back(*pattern);
+		}
+	}
+
+	transform(in, out, patterns);
 }
 
 void Transformer::transform(const File& in, const File& out,
-        const Filter& filter)
+	const Filter& filter)
 {
-    transform(in, out, filter.getPatterns());
+	transform(in, out, filter.getPatterns());
 }
 
 
-void Transformer::copyFile(const File& in, const File& out) {
-       Pool p;
-       apr_pool_t* pool = p.getAPRPool();
+void Transformer::copyFile(const File& in, const File& out)
+{
+	Pool p;
+	apr_pool_t* pool = p.getAPRPool();
 
 
-        //
-        //    fairly naive file copy code
-        //
-        //
-        apr_file_t* child_out;
-        apr_int32_t flags = APR_FOPEN_WRITE | APR_FOPEN_CREATE | APR_FOPEN_TRUNCATE;
-        apr_status_t stat = out.open(&child_out, flags, APR_OS_DEFAULT, p);
-        assert(stat == APR_SUCCESS);
+	//
+	//    fairly naive file copy code
+	//
+	//
+	apr_file_t* child_out;
+	apr_int32_t flags = APR_FOPEN_WRITE | APR_FOPEN_CREATE | APR_FOPEN_TRUNCATE;
+	apr_status_t stat = out.open(&child_out, flags, APR_OS_DEFAULT, p);
+	assert(stat == APR_SUCCESS);
 
-        apr_file_t* in_file;
-        stat = in.open(&in_file, APR_FOPEN_READ, APR_OS_DEFAULT, p);
-        assert(stat == APR_SUCCESS);
-        apr_size_t bufsize = 32000;
-        void* buf = apr_palloc(pool, bufsize);
-        apr_size_t bytesRead = bufsize;
+	apr_file_t* in_file;
+	stat = in.open(&in_file, APR_FOPEN_READ, APR_OS_DEFAULT, p);
+	assert(stat == APR_SUCCESS);
+	apr_size_t bufsize = 32000;
+	void* buf = apr_palloc(pool, bufsize);
+	apr_size_t bytesRead = bufsize;
 
-        while(stat == 0 && bytesRead == bufsize) {
-            stat = apr_file_read(in_file, buf, &bytesRead);
-            if (stat == 0 && bytesRead > 0) {
-                stat = apr_file_write(child_out, buf, &bytesRead);
-                assert(stat == APR_SUCCESS);
-            }
-        }
-        stat = apr_file_close(child_out);
-        assert(stat == APR_SUCCESS);
+	while (stat == 0 && bytesRead == bufsize)
+	{
+		stat = apr_file_read(in_file, buf, &bytesRead);
+
+		if (stat == 0 && bytesRead > 0)
+		{
+			stat = apr_file_write(child_out, buf, &bytesRead);
+			assert(stat == APR_SUCCESS);
+		}
+	}
+
+	stat = apr_file_close(child_out);
+	assert(stat == APR_SUCCESS);
 }
 
 void Transformer::createSedCommandFile(const std::string& regexName,
-        const log4cxx::Filter::PatternList& patterns,
-        apr_pool_t* pool) {
-        apr_file_t* regexFile;
-        apr_status_t stat = apr_file_open(&regexFile,
-               regexName.c_str(),
-               APR_FOPEN_WRITE | APR_FOPEN_CREATE | APR_FOPEN_TRUNCATE, APR_OS_DEFAULT,
-               pool);
-        assert(stat == APR_SUCCESS);
+	const log4cxx::Filter::PatternList& patterns,
+	apr_pool_t* pool)
+{
+	apr_file_t* regexFile;
+	apr_status_t stat = apr_file_open(&regexFile,
+			regexName.c_str(),
+			APR_FOPEN_WRITE | APR_FOPEN_CREATE | APR_FOPEN_TRUNCATE, APR_OS_DEFAULT,
+			pool);
+	assert(stat == APR_SUCCESS);
 
-        std::string tmp;
-        for (log4cxx::Filter::PatternList::const_iterator iter = patterns.begin();
-          iter != patterns.end();
-          iter++) {
-          tmp = "sQ";
-          tmp.append(iter->first);
-          tmp.append(1, 'Q');
-          tmp.append(iter->second);
-          tmp.append("Qg\n");
-          apr_file_puts(tmp.c_str(), regexFile);
-        }
-        apr_file_close(regexFile);
+	std::string tmp;
+
+	for (log4cxx::Filter::PatternList::const_iterator iter = patterns.begin();
+		iter != patterns.end();
+		iter++)
+	{
+		tmp = "sQ";
+		tmp.append(iter->first);
+		tmp.append(1, 'Q');
+		tmp.append(iter->second);
+		tmp.append("Qg\n");
+		apr_file_puts(tmp.c_str(), regexFile);
+	}
+
+	apr_file_close(regexFile);
 }
 
 void Transformer::transform(const File& in, const File& out,
-        const log4cxx::Filter::PatternList& patterns)
+	const log4cxx::Filter::PatternList& patterns)
 {
-    //
-    //   if no patterns just copy the file
-    //
-    if (patterns.size() == 0) {
-        copyFile(in, out);
-    } else {
-   Pool p;
-        apr_pool_t* pool = p.getAPRPool();
- 
-        //
-        //   write the regex's to a temporary file since they
-        //      may get mangled if passed as parameters
-        //
-        std::string regexName;
-        Transcoder::encode(in.getPath(), regexName);
-        regexName.append(".sed");
-        createSedCommandFile(regexName, patterns, pool);
+	//
+	//   if no patterns just copy the file
+	//
+	if (patterns.size() == 0)
+	{
+		copyFile(in, out);
+	}
+	else
+	{
+		Pool p;
+		apr_pool_t* pool = p.getAPRPool();
+
+		//
+		//   write the regex's to a temporary file since they
+		//      may get mangled if passed as parameters
+		//
+		std::string regexName;
+		Transcoder::encode(in.getPath(), regexName);
+		regexName.append(".sed");
+		createSedCommandFile(regexName, patterns, pool);
 
 
-        //
-        //  prepare to launch sed
-        //
-        //
-        apr_procattr_t* attr = NULL;
-        apr_status_t stat = apr_procattr_create(&attr, pool);
-        assert(stat == APR_SUCCESS);
+		//
+		//  prepare to launch sed
+		//
+		//
+		apr_procattr_t* attr = NULL;
+		apr_status_t stat = apr_procattr_create(&attr, pool);
+		assert(stat == APR_SUCCESS);
 
-        stat = apr_procattr_io_set(attr, APR_NO_PIPE, APR_FULL_BLOCK,
-                             APR_FULL_BLOCK);
-        assert(stat == APR_SUCCESS);
+		stat = apr_procattr_io_set(attr, APR_NO_PIPE, APR_FULL_BLOCK,
+				APR_FULL_BLOCK);
+		assert(stat == APR_SUCCESS);
 
-        //
-        //   find the program on the path
-        //
-        stat = apr_procattr_cmdtype_set(attr, APR_PROGRAM_PATH);
-        assert(stat == APR_SUCCESS);
+		//
+		//   find the program on the path
+		//
+		stat = apr_procattr_cmdtype_set(attr, APR_PROGRAM_PATH);
+		assert(stat == APR_SUCCESS);
 
-        //
-        //   build the argument list
-        //      using Q as regex separator on s command
-        //
-        const char** args = (const char**)
-          apr_palloc(pool, 5 * sizeof(*args));
-        int i = 0;
+		//
+		//   build the argument list
+		//      using Q as regex separator on s command
+		//
+		const char** args = (const char**)
+			apr_palloc(pool, 5 * sizeof(*args));
+		int i = 0;
 
-        //
-        //   not well documented
-        //     but the first arg is a duplicate of the executable name
-        //
-        args[i++] = "sed";
+		//
+		//   not well documented
+		//     but the first arg is a duplicate of the executable name
+		//
+		args[i++] = "sed";
 
 
-        std::string regexArg("-f");
-        regexArg.append(regexName);
-        args[i++] = apr_pstrdup(pool, regexArg.c_str());
+		std::string regexArg("-f");
+		regexArg.append(regexName);
+		args[i++] = apr_pstrdup(pool, regexArg.c_str());
 
-        //
-        //    specify the input file
-        args[i++] = Transcoder::encode(in.getPath(), p);
-        args[i] = NULL;
+		//
+		//    specify the input file
+		args[i++] = Transcoder::encode(in.getPath(), p);
+		args[i] = NULL;
 
 
 
-        //
-        //    set the output stream to the filtered file
-        //
-        apr_file_t* child_out;
-        apr_int32_t flags = APR_FOPEN_READ | APR_FOPEN_WRITE |
-            APR_FOPEN_CREATE | APR_FOPEN_TRUNCATE;
-        stat = out.open(&child_out, flags, APR_OS_DEFAULT, p);
-        assert(stat == APR_SUCCESS);
+		//
+		//    set the output stream to the filtered file
+		//
+		apr_file_t* child_out;
+		apr_int32_t flags = APR_FOPEN_READ | APR_FOPEN_WRITE |
+			APR_FOPEN_CREATE | APR_FOPEN_TRUNCATE;
+		stat = out.open(&child_out, flags, APR_OS_DEFAULT, p);
+		assert(stat == APR_SUCCESS);
 
-        stat =  apr_procattr_child_out_set(attr, child_out, NULL);
-        assert(stat == APR_SUCCESS);
+		stat =  apr_procattr_child_out_set(attr, child_out, NULL);
+		assert(stat == APR_SUCCESS);
 
-        //
-        //   redirect the child's error stream to this processes' error stream
-        //
-        apr_file_t* child_err;
-        stat = apr_file_open_stderr(&child_err, pool);
-        assert(stat == 0);
-        stat =  apr_procattr_child_err_set(attr, child_err, NULL);
-        assert(stat == APR_SUCCESS);
+		//
+		//   redirect the child's error stream to this processes' error stream
+		//
+		apr_file_t* child_err;
+		stat = apr_file_open_stderr(&child_err, pool);
+		assert(stat == 0);
+		stat =  apr_procattr_child_err_set(attr, child_err, NULL);
+		assert(stat == APR_SUCCESS);
 
 
 
-        apr_proc_t pid;
-        stat = apr_proc_create(&pid,"sed", args, NULL, attr, pool);
-        if (stat != APR_SUCCESS) {
-            puts("Error invoking sed, sed must be on the path in order to run unit tests");
-        }
-        assert(stat == APR_SUCCESS);
+		apr_proc_t pid;
+		stat = apr_proc_create(&pid, "sed", args, NULL, attr, pool);
 
-        apr_proc_wait(&pid, NULL, NULL, APR_WAIT);
-        stat = apr_file_close(child_out);
-        assert(stat == APR_SUCCESS);
-     }
+		if (stat != APR_SUCCESS)
+		{
+			puts("Error invoking sed, sed must be on the path in order to run unit tests");
+		}
+
+		assert(stat == APR_SUCCESS);
+
+		apr_proc_wait(&pid, NULL, NULL, APR_WAIT);
+		stat = apr_file_close(child_out);
+		assert(stat == APR_SUCCESS);
+	}
 
 
 }
diff --git a/src/test/cpp/util/transformer.h b/src/test/cpp/util/transformer.h
index cf7becd..0dd62de 100644
--- a/src/test/cpp/util/transformer.h
+++ b/src/test/cpp/util/transformer.h
@@ -22,35 +22,35 @@
 #include <vector>
 
 extern "C" {
-struct apr_pool_t;
+	struct apr_pool_t;
 }
 
 namespace log4cxx
 {
-       class File;
+class File;
 
-        class Transformer
-        {
-        public:
-                static void transform(const File& in,
-                        const File& out,
-                        const std::vector<Filter *>& filters);
+class Transformer
+{
+	public:
+		static void transform(const File& in,
+			const File& out,
+			const std::vector<Filter*>& filters);
 
-                static void transform(const File& in,
-                        const File& out,
-                        const Filter& filter);
-                        
-                static void transform(const File& in,
-                                      const File& out,
-                                      const std::vector< log4cxx::Filter::PatternReplacement >& patterns);
-        private:
-                static void copyFile(const File& in,
-                                      const File& out);
-                static void createSedCommandFile(const std::string& regexName, 
-                    const log4cxx::Filter::PatternList& patterns,
-                    apr_pool_t* pool);
-        
-        };
+		static void transform(const File& in,
+			const File& out,
+			const Filter& filter);
+
+		static void transform(const File& in,
+			const File& out,
+			const std::vector< log4cxx::Filter::PatternReplacement >& patterns);
+	private:
+		static void copyFile(const File& in,
+			const File& out);
+		static void createSedCommandFile(const std::string& regexName,
+			const log4cxx::Filter::PatternList& patterns,
+			apr_pool_t* pool);
+
+};
 }
 
 #endif //_LOG4CXX_TESTS_UTIL_TRANSFORMER_H
diff --git a/src/test/cpp/util/utilfilter.cpp b/src/test/cpp/util/utilfilter.cpp
index 6ec35e5..811e531 100644
--- a/src/test/cpp/util/utilfilter.cpp
+++ b/src/test/cpp/util/utilfilter.cpp
@@ -24,8 +24,9 @@
 Filter::Filter() {}
 
 Filter::Filter(const std::string& match,
-               const std::string& replacement) {
-     patterns.push_back( PatternReplacement(match, replacement));
+	const std::string& replacement)
+{
+	patterns.push_back( PatternReplacement(match, replacement));
 }
-               
+
 Filter::~Filter() {}
diff --git a/src/test/cpp/util/xmlfilenamefilter.cpp b/src/test/cpp/util/xmlfilenamefilter.cpp
index b2fe716..c310957 100644
--- a/src/test/cpp/util/xmlfilenamefilter.cpp
+++ b/src/test/cpp/util/xmlfilenamefilter.cpp
@@ -20,11 +20,12 @@
 using namespace log4cxx;
 using namespace log4cxx::helpers;
 
-XMLFilenameFilter::XMLFilenameFilter(const std::string& /*actual*/, const std::string& expected) {
-    std::string pattern(" file=\\(.\\).*");
-    pattern += expected;
+XMLFilenameFilter::XMLFilenameFilter(const std::string& /*actual*/, const std::string& expected)
+{
+	std::string pattern(" file=\\(.\\).*");
+	pattern += expected;
 
-    std::string replacement(" file=\\\\1");
-    replacement += expected;
-//    patterns.push_back( PatternReplacement(pattern, replacement) );
+	std::string replacement(" file=\\\\1");
+	replacement += expected;
+	//    patterns.push_back( PatternReplacement(pattern, replacement) );
 }
diff --git a/src/test/cpp/util/xmlfilenamefilter.h b/src/test/cpp/util/xmlfilenamefilter.h
index ff56763..64d8051 100644
--- a/src/test/cpp/util/xmlfilenamefilter.h
+++ b/src/test/cpp/util/xmlfilenamefilter.h
@@ -22,11 +22,11 @@
 
 namespace log4cxx
 {
-   class XMLFilenameFilter : public Filter
-   {
-   public:
-          XMLFilenameFilter(const std::string& actual, const std::string& expected);
-   };
+class XMLFilenameFilter : public Filter
+{
+	public:
+		XMLFilenameFilter(const std::string& actual, const std::string& expected);
+};
 }
 
 
diff --git a/src/test/cpp/util/xmllineattributefilter.cpp b/src/test/cpp/util/xmllineattributefilter.cpp
index b5b9714..6f21688 100644
--- a/src/test/cpp/util/xmllineattributefilter.cpp
+++ b/src/test/cpp/util/xmllineattributefilter.cpp
@@ -20,6 +20,7 @@
 using namespace log4cxx;
 using namespace log4cxx::helpers;
 
-XMLLineAttributeFilter::XMLLineAttributeFilter() {
-        patterns.push_back( PatternReplacement("line=\\(.+\\)[0-9]+", "line=\\\\1X"));
+XMLLineAttributeFilter::XMLLineAttributeFilter()
+{
+	patterns.push_back( PatternReplacement("line=\\(.+\\)[0-9]+", "line=\\\\1X"));
 }
diff --git a/src/test/cpp/util/xmllineattributefilter.h b/src/test/cpp/util/xmllineattributefilter.h
index 36f216f..714f2c7 100644
--- a/src/test/cpp/util/xmllineattributefilter.h
+++ b/src/test/cpp/util/xmllineattributefilter.h
@@ -22,11 +22,11 @@
 
 namespace log4cxx
 {
-   class XMLLineAttributeFilter : public Filter
-   {
-   public:
-       XMLLineAttributeFilter();
-   };
+class XMLLineAttributeFilter : public Filter
+{
+	public:
+		XMLLineAttributeFilter();
+};
 }
 
 
diff --git a/src/test/cpp/util/xmlthreadfilter.cpp b/src/test/cpp/util/xmlthreadfilter.cpp
index 302761e..ec4532f 100644
--- a/src/test/cpp/util/xmlthreadfilter.cpp
+++ b/src/test/cpp/util/xmlthreadfilter.cpp
@@ -21,5 +21,6 @@
 using namespace log4cxx::helpers;
 
 XMLThreadFilter::XMLThreadFilter()
-     : Filter("thread=\\\"[0-9A-Fa-fXx]*", "thread=\\\"main") {
+	: Filter("thread=\\\"[0-9A-Fa-fXx]*", "thread=\\\"main")
+{
 }
diff --git a/src/test/cpp/util/xmlthreadfilter.h b/src/test/cpp/util/xmlthreadfilter.h
index c246fea..6ecc532 100644
--- a/src/test/cpp/util/xmlthreadfilter.h
+++ b/src/test/cpp/util/xmlthreadfilter.h
@@ -22,11 +22,11 @@
 
 namespace log4cxx
 {
-   class XMLThreadFilter : public Filter
-   {
-   public:
-       XMLThreadFilter();
-   };
+class XMLThreadFilter : public Filter
+{
+	public:
+		XMLThreadFilter();
+};
 }
 
 
diff --git a/src/test/cpp/util/xmltimestampfilter.cpp b/src/test/cpp/util/xmltimestampfilter.cpp
index 5094de3..734cadc 100644
--- a/src/test/cpp/util/xmltimestampfilter.cpp
+++ b/src/test/cpp/util/xmltimestampfilter.cpp
@@ -21,6 +21,6 @@
 using namespace log4cxx::helpers;
 
 XMLTimestampFilter::XMLTimestampFilter()
-    : Filter("[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]*", "XXX") {}
+	: Filter("[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]*", "XXX") {}
 
 
diff --git a/src/test/cpp/util/xmltimestampfilter.h b/src/test/cpp/util/xmltimestampfilter.h
index b0ca75b..2139b36 100644
--- a/src/test/cpp/util/xmltimestampfilter.h
+++ b/src/test/cpp/util/xmltimestampfilter.h
@@ -22,11 +22,11 @@
 
 namespace log4cxx
 {
-   class XMLTimestampFilter : public Filter
-   {
-   public:
-       XMLTimestampFilter();
-   };
+class XMLTimestampFilter : public Filter
+{
+	public:
+		XMLTimestampFilter();
+};
 }
 
 
diff --git a/src/test/cpp/varia/errorhandlertestcase.cpp b/src/test/cpp/varia/errorhandlertestcase.cpp
index dc527df..1385182 100644
--- a/src/test/cpp/varia/errorhandlertestcase.cpp
+++ b/src/test/cpp/varia/errorhandlertestcase.cpp
@@ -32,87 +32,87 @@
 
 LOGUNIT_CLASS(ErrorHandlerTestCase)
 {
-        LOGUNIT_TEST_SUITE(ErrorHandlerTestCase);
-                LOGUNIT_TEST(test1);
-        LOGUNIT_TEST_SUITE_END();
+	LOGUNIT_TEST_SUITE(ErrorHandlerTestCase);
+	LOGUNIT_TEST(test1);
+	LOGUNIT_TEST_SUITE_END();
 
-        LoggerPtr root;
-        LoggerPtr logger;
+	LoggerPtr root;
+	LoggerPtr logger;
 
 
 public:
-        void setUp()
-        {
-                root = Logger::getRootLogger();
-                logger = Logger::getLogger("test");
-        }
+	void setUp()
+	{
+		root = Logger::getRootLogger();
+		logger = Logger::getLogger("test");
+	}
 
-        void tearDown()
-        {
-                logger->getLoggerRepository()->resetConfiguration();
-        }
+	void tearDown()
+	{
+		logger->getLoggerRepository()->resetConfiguration();
+	}
 
 
-        void test1()
-        {
-                DOMConfigurator::configure("input/xml/fallback1.xml");
-                FileAppenderPtr primary(root->getAppender(LOG4CXX_STR("PRIMARY")));
-                log4cxx::varia::FallbackErrorHandlerPtr eh(primary->getErrorHandler());
-                LOGUNIT_ASSERT(eh != 0);
-                
-                common();
+	void test1()
+	{
+		DOMConfigurator::configure("input/xml/fallback1.xml");
+		FileAppenderPtr primary(root->getAppender(LOG4CXX_STR("PRIMARY")));
+		log4cxx::varia::FallbackErrorHandlerPtr eh(primary->getErrorHandler());
+		LOGUNIT_ASSERT(eh != 0);
 
-                std::string TEST1_PAT = 
-                       "FALLBACK - (root|test) - Message {0-9}";
+		common();
 
-                ControlFilter cf;
-                cf << TEST1_PAT;
+		std::string TEST1_PAT =
+			"FALLBACK - (root|test) - Message {0-9}";
 
-                LineNumberFilter lineNumberFilter;
+		ControlFilter cf;
+		cf << TEST1_PAT;
 
-                std::vector<Filter *> filters;
-                filters.push_back(&cf);
-                filters.push_back(&lineNumberFilter);
+		LineNumberFilter lineNumberFilter;
 
-                try
-                {
-                        Transformer::transform("output/temp", "output/filtered", filters);
-                }
-                catch(UnexpectedFormatException& e)
-                {
-                    std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
-                        throw;
-                }
+		std::vector<Filter*> filters;
+		filters.push_back(&cf);
+		filters.push_back(&lineNumberFilter);
+
+		try
+		{
+			Transformer::transform("output/temp", "output/filtered", filters);
+		}
+		catch (UnexpectedFormatException& e)
+		{
+			std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
+			throw;
+		}
 
 
-                LOGUNIT_ASSERT(Compare::compare("output/filtered", "witness/fallback1"));
-        }
+		LOGUNIT_ASSERT(Compare::compare("output/filtered", "witness/fallback1"));
+	}
 
-        void common()
-        {
-                int i = -1;
-                  
-                LOG4CXX_DEBUG(logger, "Message " << ++i);
-                LOG4CXX_DEBUG(root, "Message " << i);
+	void common()
+	{
+		int i = -1;
 
-                LOG4CXX_INFO(logger, "Message " << ++i);
-                LOG4CXX_INFO(root, "Message " << i);
+		LOG4CXX_DEBUG(logger, "Message " << ++i);
+		LOG4CXX_DEBUG(root, "Message " << i);
 
-                LOG4CXX_WARN(logger, "Message " << ++i);
-                LOG4CXX_WARN(root, "Message " << i);
+		LOG4CXX_INFO(logger, "Message " << ++i);
+		LOG4CXX_INFO(root, "Message " << i);
 
-                LOG4CXX_ERROR(logger, "Message " << ++i);
-                LOG4CXX_ERROR(root, "Message " << i);
+		LOG4CXX_WARN(logger, "Message " << ++i);
+		LOG4CXX_WARN(root, "Message " << i);
 
-                LOG4CXX_FATAL(logger, "Message " << ++i);
-                LOG4CXX_FATAL(root, "Message " << i);
+		LOG4CXX_ERROR(logger, "Message " << ++i);
+		LOG4CXX_ERROR(root, "Message " << i);
 
-                LOG4CXX_DEBUG(logger, "Message " << ++i);
-                LOG4CXX_DEBUG(root, "Message " << i);
+		LOG4CXX_FATAL(logger, "Message " << ++i);
+		LOG4CXX_FATAL(root, "Message " << i);
 
-                LOG4CXX_ERROR(logger, "Message " << ++i);
-                LOG4CXX_ERROR(root, "Message " << i);
-        }
+		LOG4CXX_DEBUG(logger, "Message " << ++i);
+		LOG4CXX_DEBUG(root, "Message " << i);
+
+		LOG4CXX_ERROR(logger, "Message " << ++i);
+		LOG4CXX_ERROR(root, "Message " << i);
+	}
 };
 
 LOGUNIT_TEST_SUITE_REGISTRATION(ErrorHandlerTestCase)
diff --git a/src/test/cpp/varia/levelmatchfiltertestcase.cpp b/src/test/cpp/varia/levelmatchfiltertestcase.cpp
index 4f4d954..e8f9c7a 100644
--- a/src/test/cpp/varia/levelmatchfiltertestcase.cpp
+++ b/src/test/cpp/varia/levelmatchfiltertestcase.cpp
@@ -38,123 +38,124 @@
 
 LOGUNIT_CLASS(LevelMatchFilterTestCase)
 {
-        LOGUNIT_TEST_SUITE(LevelMatchFilterTestCase);
-                LOGUNIT_TEST(accept);
-                LOGUNIT_TEST(deny);
-        LOGUNIT_TEST_SUITE_END();
+	LOGUNIT_TEST_SUITE(LevelMatchFilterTestCase);
+	LOGUNIT_TEST(accept);
+	LOGUNIT_TEST(deny);
+	LOGUNIT_TEST_SUITE_END();
 
-        LoggerPtr root;
-        LoggerPtr logger;
+	LoggerPtr root;
+	LoggerPtr logger;
 
 public:
-        void setUp()
-        {
-                root = Logger::getRootLogger();
-                root->removeAllAppenders();
-                logger = Logger::getLogger(LOG4CXX_TEST_STR("test"));
-        }
+	void setUp()
+	{
+		root = Logger::getRootLogger();
+		root->removeAllAppenders();
+		logger = Logger::getLogger(LOG4CXX_TEST_STR("test"));
+	}
 
-        void tearDown()
-        {
-                root->getLoggerRepository()->resetConfiguration();
-        }
+	void tearDown()
+	{
+		root->getLoggerRepository()->resetConfiguration();
+	}
 
-        void accept()
-        {
-                // set up appender
-                LayoutPtr layout = new SimpleLayout();
-                AppenderPtr appender = new FileAppender(layout, ACCEPT_FILE, false);
+	void accept()
+	{
+		// set up appender
+		LayoutPtr layout = new SimpleLayout();
+		AppenderPtr appender = new FileAppender(layout, ACCEPT_FILE, false);
 
-                // create LevelMatchFilter
-                LevelMatchFilterPtr matchFilter = new LevelMatchFilter();
+		// create LevelMatchFilter
+		LevelMatchFilterPtr matchFilter = new LevelMatchFilter();
 
-                // attach match filter to appender
-                appender->addFilter(matchFilter);
+		// attach match filter to appender
+		appender->addFilter(matchFilter);
 
-                // attach DenyAllFilter to end of filter chain to deny neutral
-                // (non matching) messages
-                spi::FilterPtr filter(new DenyAllFilter());
-                appender->addFilter(filter);
+		// attach DenyAllFilter to end of filter chain to deny neutral
+		// (non matching) messages
+		spi::FilterPtr filter(new DenyAllFilter());
+		appender->addFilter(filter);
 
-                // set appender on root and set level to debug
-                root->addAppender(appender);
-                root->setLevel(Level::getDebug());
+		// set appender on root and set level to debug
+		root->addAppender(appender);
+		root->setLevel(Level::getDebug());
 
-                LevelPtr levelArray[] =
-                        { Level::getDebug(), Level::getInfo(), Level::getWarn(), Level::getError(), Level::getFatal() };
+		LevelPtr levelArray[] =
+		{ Level::getDebug(), Level::getInfo(), Level::getWarn(), Level::getError(), Level::getFatal() };
 
-                int length = sizeof(levelArray)/sizeof(levelArray[0]);
+		int length = sizeof(levelArray) / sizeof(levelArray[0]);
 
-                Pool pool;
-                for (int x = 0; x < length; x++)
-                {
-                        // set the level to match
-                        matchFilter->setLevelToMatch(levelArray[x]->toString());
-                        LogString sbuf(LOG4CXX_STR("pass "));
-                        StringHelper::toString(x, pool, sbuf);
-                        sbuf.append(LOG4CXX_STR("; filter set to accept only "));
-                        sbuf.append(levelArray[x]->toString());
-                        sbuf.append(LOG4CXX_STR(" msgs"));
-                        common(sbuf);
-                }
+		Pool pool;
 
-                LOGUNIT_ASSERT(Compare::compare(ACCEPT_FILE, ACCEPT_WITNESS));
-        }
+		for (int x = 0; x < length; x++)
+		{
+			// set the level to match
+			matchFilter->setLevelToMatch(levelArray[x]->toString());
+			LogString sbuf(LOG4CXX_STR("pass "));
+			StringHelper::toString(x, pool, sbuf);
+			sbuf.append(LOG4CXX_STR("; filter set to accept only "));
+			sbuf.append(levelArray[x]->toString());
+			sbuf.append(LOG4CXX_STR(" msgs"));
+			common(sbuf);
+		}
 
-        void deny()
-        {
-                // set up appender
-                LayoutPtr layout = new SimpleLayout();
-                AppenderPtr appender = new FileAppender(layout, DENY_FILE, false);
+		LOGUNIT_ASSERT(Compare::compare(ACCEPT_FILE, ACCEPT_WITNESS));
+	}
 
-                // create LevelMatchFilter, set to deny matches
-                LevelMatchFilterPtr matchFilter = new LevelMatchFilter();
-                matchFilter->setAcceptOnMatch(false);
+	void deny()
+	{
+		// set up appender
+		LayoutPtr layout = new SimpleLayout();
+		AppenderPtr appender = new FileAppender(layout, DENY_FILE, false);
 
-                // attach match filter to appender
-                appender->addFilter(matchFilter);
+		// create LevelMatchFilter, set to deny matches
+		LevelMatchFilterPtr matchFilter = new LevelMatchFilter();
+		matchFilter->setAcceptOnMatch(false);
 
-                // set appender on root and set level to debug
-                root->addAppender(appender);
-                root->setLevel(Level::getDebug());
+		// attach match filter to appender
+		appender->addFilter(matchFilter);
 
-                LevelPtr levelArray[] =
-                        { Level::getDebug(), Level::getInfo(), Level::getWarn(), Level::getError(), Level::getFatal() };
+		// set appender on root and set level to debug
+		root->addAppender(appender);
+		root->setLevel(Level::getDebug());
 
-                int length = sizeof(levelArray)/sizeof(levelArray[0]);
+		LevelPtr levelArray[] =
+		{ Level::getDebug(), Level::getInfo(), Level::getWarn(), Level::getError(), Level::getFatal() };
 
-                Pool pool;
+		int length = sizeof(levelArray) / sizeof(levelArray[0]);
 
-                for (int x = 0; x < length; x++)
-                {
-                        // set the level to match
-                        matchFilter->setLevelToMatch(levelArray[x]->toString());
-                        LogString sbuf(LOG4CXX_STR("pass "));
+		Pool pool;
 
-                        StringHelper::toString(x, pool, sbuf);
-                        sbuf.append(LOG4CXX_STR("; filter set to deny only "));
-                        sbuf.append(levelArray[x]->toString());
-                        sbuf.append(LOG4CXX_STR(" msgs"));
-                        common(sbuf);
-                }
+		for (int x = 0; x < length; x++)
+		{
+			// set the level to match
+			matchFilter->setLevelToMatch(levelArray[x]->toString());
+			LogString sbuf(LOG4CXX_STR("pass "));
 
-                LOGUNIT_ASSERT(Compare::compare(DENY_FILE, DENY_WITNESS));
-        }
+			StringHelper::toString(x, pool, sbuf);
+			sbuf.append(LOG4CXX_STR("; filter set to deny only "));
+			sbuf.append(levelArray[x]->toString());
+			sbuf.append(LOG4CXX_STR(" msgs"));
+			common(sbuf);
+		}
 
-        void common(const LogString& msg)
-        {
-                logger->debug(msg);
-                logger->info(msg);
-                logger->warn(msg);
-                logger->error(msg);
-                logger->fatal(msg);
-        }
+		LOGUNIT_ASSERT(Compare::compare(DENY_FILE, DENY_WITNESS));
+	}
+
+	void common(const LogString & msg)
+	{
+		logger->debug(msg);
+		logger->info(msg);
+		logger->warn(msg);
+		logger->error(msg);
+		logger->fatal(msg);
+	}
 
 private:
-        static const LogString ACCEPT_FILE;
-        static const LogString ACCEPT_WITNESS;
-        static const LogString DENY_FILE;
-        static const LogString DENY_WITNESS;
+	static const LogString ACCEPT_FILE;
+	static const LogString ACCEPT_WITNESS;
+	static const LogString DENY_FILE;
+	static const LogString DENY_WITNESS;
 
 
 };
diff --git a/src/test/cpp/varia/levelrangefiltertestcase.cpp b/src/test/cpp/varia/levelrangefiltertestcase.cpp
index f77447a..13c4300 100644
--- a/src/test/cpp/varia/levelrangefiltertestcase.cpp
+++ b/src/test/cpp/varia/levelrangefiltertestcase.cpp
@@ -38,213 +38,217 @@
 
 LOGUNIT_CLASS(LevelRangeFilterTestCase)
 {
-        LOGUNIT_TEST_SUITE(LevelRangeFilterTestCase);
-                LOGUNIT_TEST(accept);
-                LOGUNIT_TEST(neutral);
-        LOGUNIT_TEST_SUITE_END();
+	LOGUNIT_TEST_SUITE(LevelRangeFilterTestCase);
+	LOGUNIT_TEST(accept);
+	LOGUNIT_TEST(neutral);
+	LOGUNIT_TEST_SUITE_END();
 
-        LoggerPtr root;
-        LoggerPtr logger;
+	LoggerPtr root;
+	LoggerPtr logger;
 
 public:
-        void setUp()
-        {
-                root = Logger::getRootLogger();
-                root->removeAllAppenders();
-                logger = Logger::getLogger(LOG4CXX_TEST_STR("test"));
-        }
+	void setUp()
+	{
+		root = Logger::getRootLogger();
+		root->removeAllAppenders();
+		logger = Logger::getLogger(LOG4CXX_TEST_STR("test"));
+	}
 
-        void tearDown()
-        {
-                root->getLoggerRepository()->resetConfiguration();
-        }
+	void tearDown()
+	{
+		root->getLoggerRepository()->resetConfiguration();
+	}
 
-        void accept()
-        {
-                // set up appender
-                LayoutPtr layout = new SimpleLayout();
-                AppenderPtr appender = new FileAppender(layout, ACCEPT_FILE, false);
+	void accept()
+	{
+		// set up appender
+		LayoutPtr layout = new SimpleLayout();
+		AppenderPtr appender = new FileAppender(layout, ACCEPT_FILE, false);
 
-                // create LevelMatchFilter
-                LevelRangeFilterPtr rangeFilter = new LevelRangeFilter();
+		// create LevelMatchFilter
+		LevelRangeFilterPtr rangeFilter = new LevelRangeFilter();
 
-                // set it to accept on a match
-                rangeFilter->setAcceptOnMatch(true);
+		// set it to accept on a match
+		rangeFilter->setAcceptOnMatch(true);
 
-                // attach match filter to appender
-                appender->addFilter(rangeFilter);
+		// attach match filter to appender
+		appender->addFilter(rangeFilter);
 
-                // set appender on root and set level to debug
-                root->addAppender(appender);
-                root->setLevel(Level::getDebug());
+		// set appender on root and set level to debug
+		root->addAppender(appender);
+		root->setLevel(Level::getDebug());
 
-                int passCount = 0;
-                LogString sbuf(LOG4CXX_STR("pass "));
+		int passCount = 0;
+		LogString sbuf(LOG4CXX_STR("pass "));
 
-                Pool pool;
-                StringHelper::toString(passCount, pool, sbuf);
+		Pool pool;
+		StringHelper::toString(passCount, pool, sbuf);
 
-                sbuf.append(LOG4CXX_STR("; no min or max set"));
-                common(sbuf);
-                passCount++;
+		sbuf.append(LOG4CXX_STR("; no min or max set"));
+		common(sbuf);
+		passCount++;
 
-                // test with a min set
-                rangeFilter->setLevelMin(Level::getWarn());
-                sbuf.assign(LOG4CXX_STR("pass "));
-                StringHelper::toString(passCount, pool, sbuf);
-                sbuf.append(LOG4CXX_STR("; min set to WARN, max not set"));
-                common(sbuf);
-                passCount++;
+		// test with a min set
+		rangeFilter->setLevelMin(Level::getWarn());
+		sbuf.assign(LOG4CXX_STR("pass "));
+		StringHelper::toString(passCount, pool, sbuf);
+		sbuf.append(LOG4CXX_STR("; min set to WARN, max not set"));
+		common(sbuf);
+		passCount++;
 
-                // create a clean filter
-                appender->clearFilters();
-                rangeFilter = new LevelRangeFilter();
-                appender->addFilter(rangeFilter);
+		// create a clean filter
+		appender->clearFilters();
+		rangeFilter = new LevelRangeFilter();
+		appender->addFilter(rangeFilter);
 
-                //test with max set
-                rangeFilter->setLevelMax(Level::getWarn());
-                sbuf.assign(LOG4CXX_STR("pass "));
-                StringHelper::toString(passCount, pool, sbuf);
-                sbuf.append(LOG4CXX_STR("; min not set, max set to WARN"));
-                common(sbuf);
-                passCount++;
+		//test with max set
+		rangeFilter->setLevelMax(Level::getWarn());
+		sbuf.assign(LOG4CXX_STR("pass "));
+		StringHelper::toString(passCount, pool, sbuf);
+		sbuf.append(LOG4CXX_STR("; min not set, max set to WARN"));
+		common(sbuf);
+		passCount++;
 
 
-                LevelPtr levelArray[] =
-                        { Level::getDebug(), Level::getInfo(), Level::getWarn(),
-                 Level::getError(), Level::getFatal() };
+		LevelPtr levelArray[] =
+		{
+			Level::getDebug(), Level::getInfo(), Level::getWarn(),
+			Level::getError(), Level::getFatal()
+		};
 
-                int length = sizeof(levelArray)/sizeof(levelArray[0]);
+		int length = sizeof(levelArray) / sizeof(levelArray[0]);
 
-                for (int x = 0; x < length; x++)
-                {
-                        // set the min level to match
-                        rangeFilter->setLevelMin(levelArray[x]);
+		for (int x = 0; x < length; x++)
+		{
+			// set the min level to match
+			rangeFilter->setLevelMin(levelArray[x]);
 
-                        for (int y = length - 1; y >= 0; y--)
-                        {
-                                // set max level to match
-                                rangeFilter->setLevelMax(levelArray[y]);
+			for (int y = length - 1; y >= 0; y--)
+			{
+				// set max level to match
+				rangeFilter->setLevelMax(levelArray[y]);
 
-                                sbuf.assign(LOG4CXX_STR("pass "));
-                                StringHelper::toString(passCount, pool, sbuf);
-                                sbuf.append(LOG4CXX_STR("; filter set to accept between "));
-                                sbuf.append(levelArray[x]->toString());
-                                sbuf.append(LOG4CXX_STR(" and "));
-                                sbuf.append(levelArray[y]->toString());
-                                sbuf.append(LOG4CXX_STR(" msgs"));
-                                common(sbuf);
+				sbuf.assign(LOG4CXX_STR("pass "));
+				StringHelper::toString(passCount, pool, sbuf);
+				sbuf.append(LOG4CXX_STR("; filter set to accept between "));
+				sbuf.append(levelArray[x]->toString());
+				sbuf.append(LOG4CXX_STR(" and "));
+				sbuf.append(levelArray[y]->toString());
+				sbuf.append(LOG4CXX_STR(" msgs"));
+				common(sbuf);
 
-                                // increment passCount
-                                passCount++;
-                        }
-                }
+				// increment passCount
+				passCount++;
+			}
+		}
 
 
-                LOGUNIT_ASSERT(Compare::compare(ACCEPT_FILE, ACCEPT_WITNESS));
-        }
+		LOGUNIT_ASSERT(Compare::compare(ACCEPT_FILE, ACCEPT_WITNESS));
+	}
 
-        void neutral()
-        {
-                // set up appender
-                LayoutPtr layout = new SimpleLayout();
-                AppenderPtr appender = new FileAppender(layout, NEUTRAL_FILE, false);
+	void neutral()
+	{
+		// set up appender
+		LayoutPtr layout = new SimpleLayout();
+		AppenderPtr appender = new FileAppender(layout, NEUTRAL_FILE, false);
 
-                // create LevelMatchFilter
-                LevelRangeFilterPtr rangeFilter = new LevelRangeFilter();
+		// create LevelMatchFilter
+		LevelRangeFilterPtr rangeFilter = new LevelRangeFilter();
 
-                // set it to accept on a match
-                rangeFilter->setAcceptOnMatch(true);
+		// set it to accept on a match
+		rangeFilter->setAcceptOnMatch(true);
 
-                // attach match filter to appender
-                appender->addFilter(rangeFilter);
+		// attach match filter to appender
+		appender->addFilter(rangeFilter);
 
-                // set appender on root and set level to debug
-                root->addAppender(appender);
-                root->setLevel(Level::getDebug());
+		// set appender on root and set level to debug
+		root->addAppender(appender);
+		root->setLevel(Level::getDebug());
 
-                int passCount = 0;
-                LogString sbuf(LOG4CXX_STR("pass "));
+		int passCount = 0;
+		LogString sbuf(LOG4CXX_STR("pass "));
 
-                Pool pool;
-                StringHelper::toString(passCount, pool, sbuf);
+		Pool pool;
+		StringHelper::toString(passCount, pool, sbuf);
 
-                // test with no min or max set
-                sbuf.append(LOG4CXX_STR("; no min or max set"));
-                common(sbuf);
-                passCount++;
+		// test with no min or max set
+		sbuf.append(LOG4CXX_STR("; no min or max set"));
+		common(sbuf);
+		passCount++;
 
-                // test with a min set
-                rangeFilter->setLevelMin(Level::getWarn());
-                sbuf.assign(LOG4CXX_STR("pass "));
+		// test with a min set
+		rangeFilter->setLevelMin(Level::getWarn());
+		sbuf.assign(LOG4CXX_STR("pass "));
 
-                StringHelper::toString(passCount, pool, sbuf);
-                sbuf.append(LOG4CXX_STR("; min set to WARN, max not set"));
-                common(sbuf);
-                passCount++;
+		StringHelper::toString(passCount, pool, sbuf);
+		sbuf.append(LOG4CXX_STR("; min set to WARN, max not set"));
+		common(sbuf);
+		passCount++;
 
-                // create a clean filter
-                appender->clearFilters();
-                rangeFilter = new LevelRangeFilter();
-                appender->addFilter(rangeFilter);
+		// create a clean filter
+		appender->clearFilters();
+		rangeFilter = new LevelRangeFilter();
+		appender->addFilter(rangeFilter);
 
-                //test with max set
-                rangeFilter->setLevelMax(Level::getWarn());
-                sbuf.assign(LOG4CXX_STR("pass "));
+		//test with max set
+		rangeFilter->setLevelMax(Level::getWarn());
+		sbuf.assign(LOG4CXX_STR("pass "));
 
-                StringHelper::toString(passCount, pool, sbuf);
+		StringHelper::toString(passCount, pool, sbuf);
 
-                sbuf.append(LOG4CXX_STR("; min not set, max set to WARN"));
-                common(sbuf);
-                passCount++;
+		sbuf.append(LOG4CXX_STR("; min not set, max set to WARN"));
+		common(sbuf);
+		passCount++;
 
-                LevelPtr levelArray[] =
-                        { Level::getDebug(), Level::getInfo(), Level::getWarn(),
-                 Level::getError(), Level::getFatal() };
+		LevelPtr levelArray[] =
+		{
+			Level::getDebug(), Level::getInfo(), Level::getWarn(),
+			Level::getError(), Level::getFatal()
+		};
 
-                int length = sizeof(levelArray)/sizeof(levelArray[0]);
+		int length = sizeof(levelArray) / sizeof(levelArray[0]);
 
-                for (int x = 0; x < length; x++)
-                {
-                        // set the min level to match
-                        rangeFilter->setLevelMin(levelArray[x]);
+		for (int x = 0; x < length; x++)
+		{
+			// set the min level to match
+			rangeFilter->setLevelMin(levelArray[x]);
 
-                        for (int y = length - 1; y >= 0; y--)
-                        {
-                                // set max level to match
-                                rangeFilter->setLevelMax(levelArray[y]);
+			for (int y = length - 1; y >= 0; y--)
+			{
+				// set max level to match
+				rangeFilter->setLevelMax(levelArray[y]);
 
-                                sbuf.assign(LOG4CXX_STR("pass "));
-                                StringHelper::toString(passCount, pool, sbuf);
-                                sbuf.append(LOG4CXX_STR("; filter set to accept between "));
-                                sbuf.append(levelArray[x]->toString());
-                                sbuf.append(LOG4CXX_STR(" and "));
-                                sbuf.append(levelArray[y]->toString());
-                                sbuf.append(LOG4CXX_STR(" msgs"));
-                                common(sbuf);
+				sbuf.assign(LOG4CXX_STR("pass "));
+				StringHelper::toString(passCount, pool, sbuf);
+				sbuf.append(LOG4CXX_STR("; filter set to accept between "));
+				sbuf.append(levelArray[x]->toString());
+				sbuf.append(LOG4CXX_STR(" and "));
+				sbuf.append(levelArray[y]->toString());
+				sbuf.append(LOG4CXX_STR(" msgs"));
+				common(sbuf);
 
-                                // increment passCount
-                                passCount++;
-                        }
-                }
+				// increment passCount
+				passCount++;
+			}
+		}
 
-                LOGUNIT_ASSERT(Compare::compare(NEUTRAL_FILE, NEUTRAL_WITNESS));
-        }
+		LOGUNIT_ASSERT(Compare::compare(NEUTRAL_FILE, NEUTRAL_WITNESS));
+	}
 
-        void common(const LogString& msg)
-        {
-                logger->debug(msg);
-                logger->info(msg);
-                logger->warn(msg);
-                logger->error(msg);
-                logger->fatal(msg);
-        }
+	void common(const LogString & msg)
+	{
+		logger->debug(msg);
+		logger->info(msg);
+		logger->warn(msg);
+		logger->error(msg);
+		logger->fatal(msg);
+	}
 
-        private:
-        static const LogString ACCEPT_FILE;
-        static const LogString ACCEPT_WITNESS;
-        static const LogString NEUTRAL_FILE;
-        static const LogString NEUTRAL_WITNESS;
+private:
+	static const LogString ACCEPT_FILE;
+	static const LogString ACCEPT_WITNESS;
+	static const LogString NEUTRAL_FILE;
+	static const LogString NEUTRAL_WITNESS;
 
 };
 
diff --git a/src/test/cpp/vectorappender.cpp b/src/test/cpp/vectorappender.cpp
index e91824a..fef8e7c 100644
--- a/src/test/cpp/vectorappender.cpp
+++ b/src/test/cpp/vectorappender.cpp
@@ -25,23 +25,23 @@
 
 void VectorAppender::append(const spi::LoggingEventPtr& event, Pool& /*p*/)
 {
-        try
-        {
-            Thread::sleep(100);
-        }
-        catch (Exception&)
-        {
-        }
+	try
+	{
+		Thread::sleep(100);
+	}
+	catch (Exception&)
+	{
+	}
 
-        vector.push_back(event);
+	vector.push_back(event);
 }
 
 void VectorAppender::close()
 {
-        if (this->closed)
-        {
-                return;
-        }
+	if (this->closed)
+	{
+		return;
+	}
 
-        this->closed = true;
+	this->closed = true;
 }
diff --git a/src/test/cpp/vectorappender.h b/src/test/cpp/vectorappender.h
index 24b3aad..5bbca23 100644
--- a/src/test/cpp/vectorappender.h
+++ b/src/test/cpp/vectorappender.h
@@ -23,37 +23,43 @@
 {
 
 
-        /**
-        An appender that appends logging events to a vector.
-        */
-        class VectorAppender : public AppenderSkeleton
-        {
-        public:
-                DECLARE_LOG4CXX_OBJECT(VectorAppender)
-                BEGIN_LOG4CXX_CAST_MAP()
-                        LOG4CXX_CAST_ENTRY(VectorAppender)
-                        LOG4CXX_CAST_ENTRY_CHAIN(AppenderSkeleton)
-                END_LOG4CXX_CAST_MAP()
+/**
+An appender that appends logging events to a vector.
+*/
+class VectorAppender : public AppenderSkeleton
+{
+	public:
+		DECLARE_LOG4CXX_OBJECT(VectorAppender)
+		BEGIN_LOG4CXX_CAST_MAP()
+		LOG4CXX_CAST_ENTRY(VectorAppender)
+		LOG4CXX_CAST_ENTRY_CHAIN(AppenderSkeleton)
+		END_LOG4CXX_CAST_MAP()
 
-                std::vector<spi::LoggingEventPtr> vector;
+		std::vector<spi::LoggingEventPtr> vector;
 
 
-                /**
-                This method is called by the AppenderSkeleton#doAppend
-                method.
-                */
-                void append(const spi::LoggingEventPtr& event, log4cxx::helpers::Pool& p);
+		/**
+		This method is called by the AppenderSkeleton#doAppend
+		method.
+		*/
+		void append(const spi::LoggingEventPtr& event, log4cxx::helpers::Pool& p);
 
-                const std::vector<spi::LoggingEventPtr>& getVector() const
-                        { return vector; }
+		const std::vector<spi::LoggingEventPtr>& getVector() const
+		{
+			return vector;
+		}
 
-                void close();
+		void close();
 
-                bool isClosed() const
-                        { return closed; }
+		bool isClosed() const
+		{
+			return closed;
+		}
 
-                bool requiresLayout() const
-                        { return false;   }
-        };
-        typedef helpers::ObjectPtrT<VectorAppender> VectorAppenderPtr;
+		bool requiresLayout() const
+		{
+			return false;
+		}
+};
+typedef helpers::ObjectPtrT<VectorAppender> VectorAppenderPtr;
 }
diff --git a/src/test/cpp/writerappendertestcase.cpp b/src/test/cpp/writerappendertestcase.cpp
index 26921d2..35b18ff 100644
--- a/src/test/cpp/writerappendertestcase.cpp
+++ b/src/test/cpp/writerappendertestcase.cpp
@@ -23,6 +23,7 @@
 using namespace log4cxx;
 using namespace log4cxx::helpers;
 
-AppenderSkeleton* WriterAppenderTestCase::createAppenderSkeleton() const {
-    return createWriterAppender();
+AppenderSkeleton* WriterAppenderTestCase::createAppenderSkeleton() const
+{
+	return createWriterAppender();
 }
diff --git a/src/test/cpp/writerappendertestcase.h b/src/test/cpp/writerappendertestcase.h
index dbc3229..dde0b14 100644
--- a/src/test/cpp/writerappendertestcase.h
+++ b/src/test/cpp/writerappendertestcase.h
@@ -26,9 +26,9 @@
 class WriterAppenderTestCase : public AppenderSkeletonTestCase
 {
 
-public:
-        log4cxx::AppenderSkeleton* createAppenderSkeleton() const;
+	public:
+		log4cxx::AppenderSkeleton* createAppenderSkeleton() const;
 
-        virtual log4cxx::WriterAppender* createWriterAppender() const = 0;
+		virtual log4cxx::WriterAppender* createWriterAppender() const = 0;
 
 };
diff --git a/src/test/cpp/xml/customleveltestcase.cpp b/src/test/cpp/xml/customleveltestcase.cpp
index 40b7e4a..d2259a5 100644
--- a/src/test/cpp/xml/customleveltestcase.cpp
+++ b/src/test/cpp/xml/customleveltestcase.cpp
@@ -39,85 +39,85 @@
 
 LOGUNIT_CLASS(CustomLevelTestCase)
 {
-   LOGUNIT_TEST_SUITE(CustomLevelTestCase);
-      LOGUNIT_TEST(test1);
-      LOGUNIT_TEST(test2);
-      LOGUNIT_TEST(test3);
-      LOGUNIT_TEST(test4);
-   LOGUNIT_TEST_SUITE_END();
+	LOGUNIT_TEST_SUITE(CustomLevelTestCase);
+	LOGUNIT_TEST(test1);
+	LOGUNIT_TEST(test2);
+	LOGUNIT_TEST(test3);
+	LOGUNIT_TEST(test4);
+	LOGUNIT_TEST_SUITE_END();
 
-   LoggerPtr root;
-   LoggerPtr logger;
-    static const File TEMP;
+	LoggerPtr root;
+	LoggerPtr logger;
+	static const File TEMP;
 
 public:
-   void setUp()
-   {
-      root = Logger::getRootLogger();
-      logger = Logger::getLogger(LOG4CXX_TEST_STR("xml.CustomLevelTestCase"));
-   }
+	void setUp()
+	{
+		root = Logger::getRootLogger();
+		logger = Logger::getLogger(LOG4CXX_TEST_STR("xml.CustomLevelTestCase"));
+	}
 
-   void tearDown()
-   {
-      root->getLoggerRepository()->resetConfiguration();
+	void tearDown()
+	{
+		root->getLoggerRepository()->resetConfiguration();
 
-      LoggerPtr logger1 = Logger::getLogger(LOG4CXX_TEST_STR("LOG4J"));
-      logger1->setAdditivity(false);
-      logger1->addAppender(
-         new ConsoleAppender(new PatternLayout(LOG4CXX_STR("log4j: %-22c{2} - %m%n"))));
-   }
+		LoggerPtr logger1 = Logger::getLogger(LOG4CXX_TEST_STR("LOG4J"));
+		logger1->setAdditivity(false);
+		logger1->addAppender(
+			new ConsoleAppender(new PatternLayout(LOG4CXX_STR("log4j: %-22c{2} - %m%n"))));
+	}
 
-   void test1()
-   {
-      DOMConfigurator::configure(LOG4CXX_TEST_STR("input/xml/customLevel1.xml"));
-      common();
-        const File witness("witness/customLevel.1");
-      LOGUNIT_ASSERT(Compare::compare(TEMP, witness));
-   }
+	void test1()
+	{
+		DOMConfigurator::configure(LOG4CXX_TEST_STR("input/xml/customLevel1.xml"));
+		common();
+		const File witness("witness/customLevel.1");
+		LOGUNIT_ASSERT(Compare::compare(TEMP, witness));
+	}
 
-   void test2()
-   {
-      DOMConfigurator::configure(LOG4CXX_TEST_STR("input/xml/customLevel2.xml"));
-      common();
-        const File witness("witness/customLevel.2");
-      LOGUNIT_ASSERT(Compare::compare(TEMP, witness));
-   }
+	void test2()
+	{
+		DOMConfigurator::configure(LOG4CXX_TEST_STR("input/xml/customLevel2.xml"));
+		common();
+		const File witness("witness/customLevel.2");
+		LOGUNIT_ASSERT(Compare::compare(TEMP, witness));
+	}
 
-   void test3()
-   {
-      DOMConfigurator::configure(LOG4CXX_TEST_STR("input/xml/customLevel3.xml"));
-      common();
-        const File witness("witness/customLevel.3");
-      LOGUNIT_ASSERT(Compare::compare(TEMP, witness));
-   }
+	void test3()
+	{
+		DOMConfigurator::configure(LOG4CXX_TEST_STR("input/xml/customLevel3.xml"));
+		common();
+		const File witness("witness/customLevel.3");
+		LOGUNIT_ASSERT(Compare::compare(TEMP, witness));
+	}
 
-   void test4()
-   {
-      DOMConfigurator::configure(LOG4CXX_TEST_STR("input/xml/customLevel4.xml"));
-      common();
-        const File witness("witness/customLevel.4");
-      LOGUNIT_ASSERT(Compare::compare(TEMP, witness));
-   }
+	void test4()
+	{
+		DOMConfigurator::configure(LOG4CXX_TEST_STR("input/xml/customLevel4.xml"));
+		common();
+		const File witness("witness/customLevel.4");
+		LOGUNIT_ASSERT(Compare::compare(TEMP, witness));
+	}
 
-   void common()
-   {
-      int i = 0;
-        std::ostringstream os;
-        os << "Message " << ++i;
-      LOG4CXX_DEBUG(logger, os.str());
-        os.str("");
-        os << "Message " <<  ++i;
-      LOG4CXX_INFO(logger, os.str());
-        os.str("");
-        os << "Message " <<  ++i;
-      LOG4CXX_WARN(logger, os.str());
-        os.str("");
-        os << "Message " <<  ++i;
-      LOG4CXX_ERROR(logger, os.str());
-        os.str("");
-        os << "Message " <<  ++i;
-      LOG4CXX_LOG(logger, XLevel::getTrace(), os.str());
-   }
+	void common()
+	{
+		int i = 0;
+		std::ostringstream os;
+		os << "Message " << ++i;
+		LOG4CXX_DEBUG(logger, os.str());
+		os.str("");
+		os << "Message " <<  ++i;
+		LOG4CXX_INFO(logger, os.str());
+		os.str("");
+		os << "Message " <<  ++i;
+		LOG4CXX_WARN(logger, os.str());
+		os.str("");
+		os << "Message " <<  ++i;
+		LOG4CXX_ERROR(logger, os.str());
+		os.str("");
+		os << "Message " <<  ++i;
+		LOG4CXX_LOG(logger, XLevel::getTrace(), os.str());
+	}
 };
 
 LOGUNIT_TEST_SUITE_REGISTRATION(CustomLevelTestCase);
diff --git a/src/test/cpp/xml/domtestcase.cpp b/src/test/cpp/xml/domtestcase.cpp
index a1491c7..251770a 100644
--- a/src/test/cpp/xml/domtestcase.cpp
+++ b/src/test/cpp/xml/domtestcase.cpp
@@ -36,185 +36,189 @@
 using namespace log4cxx::xml;
 
 #define TEST1_1A_PAT \
-		"(DEBUG|INFO |WARN |ERROR|FATAL) \\w*\\.\\w* - Message [0-9]"
+	"(DEBUG|INFO |WARN |ERROR|FATAL) \\w*\\.\\w* - Message [0-9]"
 
 #define TEST1_1B_PAT "(DEBUG|INFO |WARN |ERROR|FATAL) root - Message [0-9]"
 
 #define TEST1_2_PAT "^[0-9]\\{4\\}-[0-9]\\{2\\}-[0-9]\\{2\\} [0-9]\\{2\\}:[0-9]\\{2\\}:[0-9]\\{2\\},[0-9]\\{3\\} " \
-		"\\[0x[0-9A-F]*]\\ (DEBUG|INFO|WARN|ERROR|FATAL) .* - Message [0-9]"
+	"\\[0x[0-9A-F]*]\\ (DEBUG|INFO|WARN|ERROR|FATAL) .* - Message [0-9]"
 
 LOGUNIT_CLASS(DOMTestCase)
 {
-		LOGUNIT_TEST_SUITE(DOMTestCase);
-			LOGUNIT_TEST(test1);
+	LOGUNIT_TEST_SUITE(DOMTestCase);
+	LOGUNIT_TEST(test1);
 #if defined(_WIN32)
-			LOGUNIT_TEST(test2);
+	LOGUNIT_TEST(test2);
 #endif
-			LOGUNIT_TEST(test3);
-			LOGUNIT_TEST(test4);
-		LOGUNIT_TEST_SUITE_END();
+	LOGUNIT_TEST(test3);
+	LOGUNIT_TEST(test4);
+	LOGUNIT_TEST_SUITE_END();
 
-		LoggerPtr root;
-		LoggerPtr logger;
+	LoggerPtr root;
+	LoggerPtr logger;
 
-		static const File TEMP_A1;
-		static const File TEMP_A2;
-		static const File FILTERED_A1;
-		static const File FILTERED_A2;
-		static const File TEMP_A1_2;
-		static const File TEMP_A2_2;
-		static const File FILTERED_A1_2;
-		static const File FILTERED_A2_2;
+	static const File TEMP_A1;
+	static const File TEMP_A2;
+	static const File FILTERED_A1;
+	static const File FILTERED_A2;
+	static const File TEMP_A1_2;
+	static const File TEMP_A2_2;
+	static const File FILTERED_A1_2;
+	static const File FILTERED_A2_2;
 
 public:
-		void setUp()
+	void setUp()
+	{
+		root = Logger::getRootLogger();
+		logger = Logger::getLogger(LOG4CXX_TEST_STR("org.apache.log4j.xml.DOMTestCase"));
+	}
+
+	void tearDown()
+	{
+		root->getLoggerRepository()->resetConfiguration();
+	}
+
+	void test1()
+	{
+		DOMConfigurator::configure(LOG4CXX_TEST_STR("input/xml/DOMTestCase1.xml"));
+		common();
+
+		ControlFilter cf1;
+		cf1 << TEST1_1A_PAT << TEST1_1B_PAT;
+
+		ControlFilter cf2;
+		cf2 << TEST1_2_PAT;
+
+		ThreadFilter threadFilter;
+		ISO8601Filter iso8601Filter;
+
+		std::vector<Filter*> filters1;
+		filters1.push_back(&cf1);
+
+		std::vector<Filter*> filters2;
+		filters2.push_back(&cf2);
+		filters2.push_back(&threadFilter);
+		filters2.push_back(&iso8601Filter);
+
+		try
 		{
-			root = Logger::getRootLogger();
-			logger = Logger::getLogger(LOG4CXX_TEST_STR("org.apache.log4j.xml.DOMTestCase"));
+			Transformer::transform(TEMP_A1, FILTERED_A1, filters1);
+			Transformer::transform(TEMP_A2, FILTERED_A2, filters2);
 		}
-
-		void tearDown()
+		catch (UnexpectedFormatException& e)
 		{
-			root->getLoggerRepository()->resetConfiguration();
+			std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
+			throw;
 		}
 
-		void test1() {
-			DOMConfigurator::configure(LOG4CXX_TEST_STR("input/xml/DOMTestCase1.xml"));
-			common();
-
-			ControlFilter cf1;
-			cf1 << TEST1_1A_PAT << TEST1_1B_PAT;
-
-			ControlFilter cf2;
-			cf2 << TEST1_2_PAT;
-
-			ThreadFilter threadFilter;
-			ISO8601Filter iso8601Filter;
-
-			std::vector<Filter *> filters1;
-			filters1.push_back(&cf1);
-
-			std::vector<Filter *> filters2;
-			filters2.push_back(&cf2);
-			filters2.push_back(&threadFilter);
-			filters2.push_back(&iso8601Filter);
-
-			try
-			{
-					Transformer::transform(TEMP_A1, FILTERED_A1, filters1);
-					Transformer::transform(TEMP_A2, FILTERED_A2, filters2);
-			}
-			catch(UnexpectedFormatException& e)
-			{
-				std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
-					throw;
-			}
-
-			const File witness1(LOG4CXX_TEST_STR("witness/dom.A1.1"));
-			const File witness2(LOG4CXX_TEST_STR("witness/dom.A2.1"));
-			// TODO: A1 doesn't contain duplicate entries
-			//
-			// LOGUNIT_ASSERT(Compare::compare(FILTERED_A1, witness1));
-			LOGUNIT_ASSERT(Compare::compare(FILTERED_A2, witness2));
-		}
-
+		const File witness1(LOG4CXX_TEST_STR("witness/dom.A1.1"));
+		const File witness2(LOG4CXX_TEST_STR("witness/dom.A2.1"));
+		// TODO: A1 doesn't contain duplicate entries
 		//
-		// Same test but backslashes instead of forward
-		//
-		void test2() {
-			DOMConfigurator::configure(LOG4CXX_TEST_STR("input\\xml\\DOMTestCase2.xml"));
-			common();
+		// LOGUNIT_ASSERT(Compare::compare(FILTERED_A1, witness1));
+		LOGUNIT_ASSERT(Compare::compare(FILTERED_A2, witness2));
+	}
 
-			ThreadFilter threadFilter;
-			ISO8601Filter iso8601Filter;
+	//
+	// Same test but backslashes instead of forward
+	//
+	void test2()
+	{
+		DOMConfigurator::configure(LOG4CXX_TEST_STR("input\\xml\\DOMTestCase2.xml"));
+		common();
 
-			std::vector<Filter *> filters1;
+		ThreadFilter threadFilter;
+		ISO8601Filter iso8601Filter;
 
-			std::vector<Filter *> filters2;
-			filters2.push_back(&threadFilter);
-			filters2.push_back(&iso8601Filter);
+		std::vector<Filter*> filters1;
 
-			try
-			{
-					Transformer::transform(TEMP_A1_2, FILTERED_A1_2, filters1);
-					Transformer::transform(TEMP_A2_2, FILTERED_A2_2, filters2);
-			}
-			catch(UnexpectedFormatException& e)
-			{
-				std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
-					throw;
-			}
+		std::vector<Filter*> filters2;
+		filters2.push_back(&threadFilter);
+		filters2.push_back(&iso8601Filter);
 
-			const File witness1(LOG4CXX_TEST_STR("witness/dom.A1.2"));
-			const File witness2(LOG4CXX_TEST_STR("witness/dom.A2.2"));
-			// TODO: A1 doesn't contain duplicate entries
-			//
-			// LOGUNIT_ASSERT(Compare::compare(FILTERED_A1, witness1));
-			LOGUNIT_ASSERT(Compare::compare(FILTERED_A2, witness2));
-		}
-
-
-		void common()
+		try
 		{
-			int i = 0;
-
-			LOG4CXX_DEBUG(logger, "Message " << i);
-			LOG4CXX_DEBUG(root, "Message " << i);
-
-			i++;
-			LOG4CXX_INFO(logger, "Message " << i);
-			LOG4CXX_INFO(root, "Message " << i);
-
-			i++;
-			LOG4CXX_WARN(logger, "Message " << i);
-			LOG4CXX_WARN(root, "Message " << i);
-
-			i++;
-			LOG4CXX_ERROR(logger, "Message " << i);
-			LOG4CXX_ERROR(root, "Message " << i);
-
-			i++;
-			LOG4CXX_FATAL(logger, "Message " << i);
-			LOG4CXX_FATAL(root, "Message " << i);
+			Transformer::transform(TEMP_A1_2, FILTERED_A1_2, filters1);
+			Transformer::transform(TEMP_A2_2, FILTERED_A2_2, filters2);
+		}
+		catch (UnexpectedFormatException& e)
+		{
+			std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
+			throw;
 		}
 
-		/**
-		 * Creates a output file that ends with a superscript 3.
-		 * Output file is checked by build.xml after completion.
-		 */
-		void test3() {
-			DOMConfigurator::configure(LOG4CXX_TEST_STR("input/xml/DOMTestCase3.xml"));
-			LOG4CXX_INFO(logger, "File name is expected to end with a superscript 3");
+		const File witness1(LOG4CXX_TEST_STR("witness/dom.A1.2"));
+		const File witness2(LOG4CXX_TEST_STR("witness/dom.A2.2"));
+		// TODO: A1 doesn't contain duplicate entries
+		//
+		// LOGUNIT_ASSERT(Compare::compare(FILTERED_A1, witness1));
+		LOGUNIT_ASSERT(Compare::compare(FILTERED_A2, witness2));
+	}
+
+
+	void common()
+	{
+		int i = 0;
+
+		LOG4CXX_DEBUG(logger, "Message " << i);
+		LOG4CXX_DEBUG(root, "Message " << i);
+
+		i++;
+		LOG4CXX_INFO(logger, "Message " << i);
+		LOG4CXX_INFO(root, "Message " << i);
+
+		i++;
+		LOG4CXX_WARN(logger, "Message " << i);
+		LOG4CXX_WARN(root, "Message " << i);
+
+		i++;
+		LOG4CXX_ERROR(logger, "Message " << i);
+		LOG4CXX_ERROR(root, "Message " << i);
+
+		i++;
+		LOG4CXX_FATAL(logger, "Message " << i);
+		LOG4CXX_FATAL(root, "Message " << i);
+	}
+
+	/**
+	 * Creates a output file that ends with a superscript 3.
+	 * Output file is checked by build.xml after completion.
+	 */
+	void test3()
+	{
+		DOMConfigurator::configure(LOG4CXX_TEST_STR("input/xml/DOMTestCase3.xml"));
+		LOG4CXX_INFO(logger, "File name is expected to end with a superscript 3");
 #if LOG4CXX_LOGCHAR_IS_UTF8
-			const logchar fname[] = { 0x6F, 0x75, 0x74, 0x70, 0x75, 0x74, 0x2F, 0x64, 0x6F, 0x6D, static_cast<logchar>(0xC2), static_cast<logchar>(0xB3), 0 };
+		const logchar fname[] = { 0x6F, 0x75, 0x74, 0x70, 0x75, 0x74, 0x2F, 0x64, 0x6F, 0x6D, static_cast<logchar>(0xC2), static_cast<logchar>(0xB3), 0 };
 #else
-			const logchar fname[] = { 0x6F, 0x75, 0x74, 0x70, 0x75, 0x74, 0x2F, 0x64, 0x6F, 0x6D, static_cast<logchar>(0xB3), 0 };
+		const logchar fname[] = { 0x6F, 0x75, 0x74, 0x70, 0x75, 0x74, 0x2F, 0x64, 0x6F, 0x6D, static_cast<logchar>(0xB3), 0 };
 #endif
-			File file;
-			file.setPath(fname);
-			Pool p;
-			bool exists = file.exists(p);
-			LOGUNIT_ASSERT(exists);
-		}
+		File file;
+		file.setPath(fname);
+		Pool p;
+		bool exists = file.exists(p);
+		LOGUNIT_ASSERT(exists);
+	}
 
-		/**
-		 * Creates a output file that ends with a ideographic 4.
-		 * Output file is checked by build.xml after completion.
-		 */
-		void test4() {
-			DOMConfigurator::configure(LOG4CXX_TEST_STR("input/xml/DOMTestCase4.xml"));
-			LOG4CXX_INFO(logger, "File name is expected to end with an ideographic 4");
+	/**
+	 * Creates a output file that ends with a ideographic 4.
+	 * Output file is checked by build.xml after completion.
+	 */
+	void test4()
+	{
+		DOMConfigurator::configure(LOG4CXX_TEST_STR("input/xml/DOMTestCase4.xml"));
+		LOG4CXX_INFO(logger, "File name is expected to end with an ideographic 4");
 #if LOG4CXX_LOGCHAR_IS_UTF8
-			const logchar fname[] = { 0x6F, 0x75, 0x74, 0x70, 0x75, 0x74, 0x2F, 0x64, 0x6F, 0x6D, static_cast<logchar>(0xE3), static_cast<logchar>(0x86), static_cast<logchar>(0x95), 0 };
+		const logchar fname[] = { 0x6F, 0x75, 0x74, 0x70, 0x75, 0x74, 0x2F, 0x64, 0x6F, 0x6D, static_cast<logchar>(0xE3), static_cast<logchar>(0x86), static_cast<logchar>(0x95), 0 };
 #else
-			const logchar fname[] = { 0x6F, 0x75, 0x74, 0x70, 0x75, 0x74, 0x2F, 0x64, 0x6F, 0x6D, static_cast<logchar>(0x3195), 0 };
+		const logchar fname[] = { 0x6F, 0x75, 0x74, 0x70, 0x75, 0x74, 0x2F, 0x64, 0x6F, 0x6D, static_cast<logchar>(0x3195), 0 };
 #endif
-			File file;
-			file.setPath(fname);
-			Pool p;
-			bool exists = file.exists(p);
-			LOGUNIT_ASSERT(exists);
-		}
+		File file;
+		file.setPath(fname);
+		Pool p;
+		bool exists = file.exists(p);
+		LOGUNIT_ASSERT(exists);
+	}
 };
 
 LOGUNIT_TEST_SUITE_REGISTRATION(DOMTestCase);
diff --git a/src/test/cpp/xml/xlevel.cpp b/src/test/cpp/xml/xlevel.cpp
index 9888e53..efe9387 100644
--- a/src/test/cpp/xml/xlevel.cpp
+++ b/src/test/cpp/xml/xlevel.cpp
@@ -25,58 +25,67 @@
 
 
 XLevel::XLevel(int level1, const LogString& name1, int syslogEquivalent1)
-: Level(level1, name1, syslogEquivalent1)
+	: Level(level1, name1, syslogEquivalent1)
 {
 }
 
-LevelPtr XLevel::getTrace() {
-  static const LevelPtr trace(new XLevel(XLevel::TRACE_INT, LOG4CXX_STR("TRACE"), 7));
-  return trace;
+LevelPtr XLevel::getTrace()
+{
+	static const LevelPtr trace(new XLevel(XLevel::TRACE_INT, LOG4CXX_STR("TRACE"), 7));
+	return trace;
 }
 
-LevelPtr XLevel::getLethal() {
-  static const LevelPtr lethal(new XLevel(XLevel::LETHAL_INT, LOG4CXX_STR("LETHAL"), 0));
-  return lethal;
+LevelPtr XLevel::getLethal()
+{
+	static const LevelPtr lethal(new XLevel(XLevel::LETHAL_INT, LOG4CXX_STR("LETHAL"), 0));
+	return lethal;
 }
 
 LevelPtr XLevel::toLevelLS(const LogString& sArg)
 {
-   return toLevelLS(sArg, getTrace());
+	return toLevelLS(sArg, getTrace());
 }
 
 
 LevelPtr XLevel::toLevel(int val)
 {
-   return toLevel(val, getTrace());
+	return toLevel(val, getTrace());
 }
 
 LevelPtr XLevel::toLevel(int val, const LevelPtr& defaultLevel)
 {
-   switch(val)
-   {
-      case TRACE_INT: return getTrace();
-      case LETHAL_INT: return getLethal();
-      default: return defaultLevel;
-   }
+	switch (val)
+	{
+		case TRACE_INT:
+			return getTrace();
+
+		case LETHAL_INT:
+			return getLethal();
+
+		default:
+			return defaultLevel;
+	}
 }
 
 LevelPtr XLevel::toLevelLS(const LogString& sArg, const LevelPtr& defaultLevel)
 {
-   if (sArg.empty())
-    {
-       return defaultLevel;
-    }
+	if (sArg.empty())
+	{
+		return defaultLevel;
+	}
 
-    if (StringHelper::equalsIgnoreCase(sArg,
-          LOG4CXX_STR("TRACE"), LOG4CXX_STR("trace"))) {
-      return getTrace();
-    }
+	if (StringHelper::equalsIgnoreCase(sArg,
+			LOG4CXX_STR("TRACE"), LOG4CXX_STR("trace")))
+	{
+		return getTrace();
+	}
 
-    if (StringHelper::equalsIgnoreCase(sArg,
-           LOG4CXX_STR("LETHAL"), LOG4CXX_STR("lethal"))) {
-      return getLethal();
-    }
+	if (StringHelper::equalsIgnoreCase(sArg,
+			LOG4CXX_STR("LETHAL"), LOG4CXX_STR("lethal")))
+	{
+		return getLethal();
+	}
 
-    return Level::toLevel(sArg, defaultLevel);
+	return Level::toLevel(sArg, defaultLevel);
 }
 
diff --git a/src/test/cpp/xml/xlevel.h b/src/test/cpp/xml/xlevel.h
index eed62fa..7530392 100644
--- a/src/test/cpp/xml/xlevel.h
+++ b/src/test/cpp/xml/xlevel.h
@@ -19,48 +19,48 @@
 
 namespace log4cxx
 {
-   class XLevel : public Level
-   {
-      DECLARE_LOG4CXX_LEVEL(XLevel)
+class XLevel : public Level
+{
+		DECLARE_LOG4CXX_LEVEL(XLevel)
 
-   public:
-        enum
-        {
-            TRACE_INT = Level::DEBUG_INT - 1,
-         LETHAL_INT = Level::FATAL_INT + 1
-        };
+	public:
+		enum
+		{
+			TRACE_INT = Level::DEBUG_INT - 1,
+			LETHAL_INT = Level::FATAL_INT + 1
+		};
 
-      static LevelPtr getTrace();
-      static LevelPtr getLethal();
+		static LevelPtr getTrace();
+		static LevelPtr getLethal();
 
 
-      XLevel(int level, const LogString& name, int syslogEquivalent);
-      /**
-      Convert the string passed as argument to a level. If the
-      conversion fails, then this method returns #DEBUG.
-      */
-      static LevelPtr toLevelLS(const LogString& sArg);
+		XLevel(int level, const LogString& name, int syslogEquivalent);
+		/**
+		Convert the string passed as argument to a level. If the
+		conversion fails, then this method returns #DEBUG.
+		*/
+		static LevelPtr toLevelLS(const LogString& sArg);
 
-      /**
-      Convert an integer passed as argument to a level. If the
-      conversion fails, then this method returns #DEBUG.
+		/**
+		Convert an integer passed as argument to a level. If the
+		conversion fails, then this method returns #DEBUG.
 
-      */
-      static LevelPtr toLevel(int val);
+		*/
+		static LevelPtr toLevel(int val);
 
-      /**
-      Convert an integer passed as argument to a level. If the
-      conversion fails, then this method returns the specified default.
-      */
-      static LevelPtr toLevel(int val, const LevelPtr& defaultLevel);
+		/**
+		Convert an integer passed as argument to a level. If the
+		conversion fails, then this method returns the specified default.
+		*/
+		static LevelPtr toLevel(int val, const LevelPtr& defaultLevel);
 
 
-      /**
-      Convert the string passed as argument to a level. If the
-      conversion fails, then this method returns the value of
-      <code>defaultLevel</code>.
-      */
-        static LevelPtr toLevelLS(const LogString& sArg,
-         const LevelPtr& defaultLevel);
-   };
+		/**
+		Convert the string passed as argument to a level. If the
+		conversion fails, then this method returns the value of
+		<code>defaultLevel</code>.
+		*/
+		static LevelPtr toLevelLS(const LogString& sArg,
+			const LevelPtr& defaultLevel);
+};
 }
diff --git a/src/test/cpp/xml/xmllayouttest.cpp b/src/test/cpp/xml/xmllayouttest.cpp
index e1cf8a7..626ee22 100644
--- a/src/test/cpp/xml/xmllayouttest.cpp
+++ b/src/test/cpp/xml/xmllayouttest.cpp
@@ -45,370 +45,413 @@
 using namespace log4cxx::spi;
 
 #if defined(__LOG4CXX_FUNC__)
-#undef __LOG4CXX_FUNC__
-#define __LOG4CXX_FUNC__ "X::X()"
+	#undef __LOG4CXX_FUNC__
+	#define __LOG4CXX_FUNC__ "X::X()"
 #else
-#error __LOG4CXX_FUNC__ expected to be defined
+	#error __LOG4CXX_FUNC__ expected to be defined
 #endif
 /**
  * Test for XMLLayout.
  *
  */
-LOGUNIT_CLASS(XMLLayoutTest) {
-        LOGUNIT_TEST_SUITE(XMLLayoutTest);
-                LOGUNIT_TEST(testGetContentType);
-                LOGUNIT_TEST(testIgnoresThrowable);
-                LOGUNIT_TEST(testGetHeader);
-                LOGUNIT_TEST(testGetFooter);
-                LOGUNIT_TEST(testFormat);
-                LOGUNIT_TEST(testFormatWithNDC);
-                LOGUNIT_TEST(testGetSetLocationInfo);
-                LOGUNIT_TEST(testActivateOptions);
-                LOGUNIT_TEST(testProblemCharacters);
-                LOGUNIT_TEST(testNDCWithCDATA);
-        LOGUNIT_TEST_SUITE_END();
-
-  
-public:  
-    /**
-     * Clear MDC and NDC before test.
-     */
-  void setUp() {
-      NDC::clear();
-      MDC::clear();
-  }
-
-    /**
-     * Clear MDC and NDC after test.
-     */
-  void tearDown() {
-      setUp();
-  }
+LOGUNIT_CLASS(XMLLayoutTest)
+{
+	LOGUNIT_TEST_SUITE(XMLLayoutTest);
+	LOGUNIT_TEST(testGetContentType);
+	LOGUNIT_TEST(testIgnoresThrowable);
+	LOGUNIT_TEST(testGetHeader);
+	LOGUNIT_TEST(testGetFooter);
+	LOGUNIT_TEST(testFormat);
+	LOGUNIT_TEST(testFormatWithNDC);
+	LOGUNIT_TEST(testGetSetLocationInfo);
+	LOGUNIT_TEST(testActivateOptions);
+	LOGUNIT_TEST(testProblemCharacters);
+	LOGUNIT_TEST(testNDCWithCDATA);
+	LOGUNIT_TEST_SUITE_END();
 
 
 public:
-  /**
-   * Tests getContentType.
-   */
-  void testGetContentType() {
-    LogString expected(LOG4CXX_STR("text/plain"));
-    LogString actual(XMLLayout().getContentType());
-    LOGUNIT_ASSERT(expected == actual);
-  }
+	/**
+	 * Clear MDC and NDC before test.
+	 */
+	void setUp()
+	{
+		NDC::clear();
+		MDC::clear();
+	}
 
-  /**
-   * Tests ignoresThrowable.
-   */
-  void testIgnoresThrowable() {
-    LOGUNIT_ASSERT_EQUAL(false, XMLLayout().ignoresThrowable());
-  }
+	/**
+	 * Clear MDC and NDC after test.
+	 */
+	void tearDown()
+	{
+		setUp();
+	}
 
-  /**
-   * Tests getHeader.
-   */
-  void testGetHeader() {
-    Pool p;
-    LogString header;
-    XMLLayout().appendHeader(header, p);
-    LOGUNIT_ASSERT_EQUAL((size_t) 0, header.size());
-  }
 
-  /**
-   * Tests getFooter.
-   */
-  void testGetFooter() {
-    Pool p;
-    LogString footer;
-    XMLLayout().appendFooter(footer, p);
-    LOGUNIT_ASSERT_EQUAL((size_t) 0, footer.size());
-  }
+public:
+	/**
+	 * Tests getContentType.
+	 */
+	void testGetContentType()
+	{
+		LogString expected(LOG4CXX_STR("text/plain"));
+		LogString actual(XMLLayout().getContentType());
+		LOGUNIT_ASSERT(expected == actual);
+	}
+
+	/**
+	 * Tests ignoresThrowable.
+	 */
+	void testIgnoresThrowable()
+	{
+		LOGUNIT_ASSERT_EQUAL(false, XMLLayout().ignoresThrowable());
+	}
+
+	/**
+	 * Tests getHeader.
+	 */
+	void testGetHeader()
+	{
+		Pool p;
+		LogString header;
+		XMLLayout().appendHeader(header, p);
+		LOGUNIT_ASSERT_EQUAL((size_t) 0, header.size());
+	}
+
+	/**
+	 * Tests getFooter.
+	 */
+	void testGetFooter()
+	{
+		Pool p;
+		LogString footer;
+		XMLLayout().appendFooter(footer, p);
+		LOGUNIT_ASSERT_EQUAL((size_t) 0, footer.size());
+	}
 
 private:
-  /**
-   * Parses the string as the body of an XML document and returns the document element.
-   * @param source source string.
-   * @return document element.
-   * @throws Exception if parser can not be constructed or source is not a valid XML document.
-   */
-  static apr_xml_elem* parse(const LogString& source, Pool& p) {
-    char backing[3000];
-    ByteBuffer buf(backing, sizeof(backing));
-    CharsetEncoderPtr encoder(CharsetEncoder::getUTF8Encoder());
-    LogString header(LOG4CXX_STR("<log4j:eventSet xmlns:log4j='http://jakarta.apache.org/log4j/'>"));
-    LogString::const_iterator iter(header.begin());
-    encoder->encode(header, iter, buf);
-    LOGUNIT_ASSERT(iter == header.end());
-    iter = source.begin();
-    encoder->encode(source, iter, buf);
-    LOGUNIT_ASSERT(iter == source.end());
-    LogString footer(LOG4CXX_STR("</log4j:eventSet>"));
-    iter = footer.begin();
-    encoder->encode(footer, iter, buf);
-    buf.flip();
-    apr_pool_t* apr_pool = p.getAPRPool();
-    apr_xml_parser* parser = apr_xml_parser_create(apr_pool);
-    LOGUNIT_ASSERT(parser != 0);
-    apr_status_t stat = apr_xml_parser_feed(parser, buf.data(), buf.remaining());
-    LOGUNIT_ASSERT(stat == APR_SUCCESS);
-    apr_xml_doc* doc = 0;
-    stat = apr_xml_parser_done(parser, &doc);
-    LOGUNIT_ASSERT(doc != 0);
-    apr_xml_elem* eventSet = doc->root;
-    LOGUNIT_ASSERT(eventSet != 0);
-    apr_xml_elem* event = eventSet->first_child;
-    LOGUNIT_ASSERT(event != 0);
-    return event;    
-  }
+	/**
+	 * Parses the string as the body of an XML document and returns the document element.
+	 * @param source source string.
+	 * @return document element.
+	 * @throws Exception if parser can not be constructed or source is not a valid XML document.
+	 */
+	static apr_xml_elem* parse(const LogString & source, Pool & p)
+	{
+		char backing[3000];
+		ByteBuffer buf(backing, sizeof(backing));
+		CharsetEncoderPtr encoder(CharsetEncoder::getUTF8Encoder());
+		LogString header(LOG4CXX_STR("<log4j:eventSet xmlns:log4j='http://jakarta.apache.org/log4j/'>"));
+		LogString::const_iterator iter(header.begin());
+		encoder->encode(header, iter, buf);
+		LOGUNIT_ASSERT(iter == header.end());
+		iter = source.begin();
+		encoder->encode(source, iter, buf);
+		LOGUNIT_ASSERT(iter == source.end());
+		LogString footer(LOG4CXX_STR("</log4j:eventSet>"));
+		iter = footer.begin();
+		encoder->encode(footer, iter, buf);
+		buf.flip();
+		apr_pool_t* apr_pool = p.getAPRPool();
+		apr_xml_parser* parser = apr_xml_parser_create(apr_pool);
+		LOGUNIT_ASSERT(parser != 0);
+		apr_status_t stat = apr_xml_parser_feed(parser, buf.data(), buf.remaining());
+		LOGUNIT_ASSERT(stat == APR_SUCCESS);
+		apr_xml_doc* doc = 0;
+		stat = apr_xml_parser_done(parser, &doc);
+		LOGUNIT_ASSERT(doc != 0);
+		apr_xml_elem* eventSet = doc->root;
+		LOGUNIT_ASSERT(eventSet != 0);
+		apr_xml_elem* event = eventSet->first_child;
+		LOGUNIT_ASSERT(event != 0);
+		return event;
+	}
 
-  std::string getAttribute(apr_xml_elem* elem, const char* attrName) {
-     for(apr_xml_attr* attr = elem->attr;
-         attr != NULL;
-         attr = attr->next) {
-         if (strcmp(attr->name, attrName) == 0) {
-            return attr->value;
-         }
-     }
-     return "";
-  }
+	std::string getAttribute(apr_xml_elem * elem, const char* attrName)
+	{
+		for (apr_xml_attr* attr = elem->attr;
+			attr != NULL;
+			attr = attr->next)
+		{
+			if (strcmp(attr->name, attrName) == 0)
+			{
+				return attr->value;
+			}
+		}
 
-  std::string getText(apr_xml_elem* elem) {
-    std::string dMessage;
-        for(apr_text* t = elem->first_cdata.first;
-            t != NULL;
-            t = t->next) {
-            dMessage.append(t->text);
-        }
-    return dMessage;
-  }
-  /**
-   * Checks a log4j:event element against expectations.
-   * @param element element, may not be null.
-   * @param event event, may not be null.
-   */
-  void checkEventElement(
-    apr_xml_elem* element, LoggingEventPtr& event) {
-    std::string tagName("event");
-    LOGUNIT_ASSERT_EQUAL(tagName, (std::string) element->name);
-    LOG4CXX_ENCODE_CHAR(cLoggerName, event->getLoggerName());
-    LOGUNIT_ASSERT_EQUAL(cLoggerName, getAttribute(element, "logger"));
-    LOG4CXX_ENCODE_CHAR(cLevelName, event->getLevel()->toString());
-    LOGUNIT_ASSERT_EQUAL(cLevelName, getAttribute(element, "level"));
-  }
+		return "";
+	}
 
-  /**
-   * Checks a log4j:message element against expectations.
-   * @param element element, may not be null.
-   * @param message expected message.
-   */
-  void checkMessageElement(
-    apr_xml_elem* element, std::string message) {
-    std::string tagName = "message";
-    LOGUNIT_ASSERT_EQUAL(tagName, (std::string) element->name);
-    LOGUNIT_ASSERT_EQUAL(message, getText(element));
-  }
+	std::string getText(apr_xml_elem * elem)
+	{
+		std::string dMessage;
 
-  /**
-   * Checks a log4j:message element against expectations.
-   * @param element element, may not be null.
-   * @param message expected message.
-   */
-  void checkNDCElement(apr_xml_elem* element, std::string message) {
-    std::string tagName = "NDC";
-    LOGUNIT_ASSERT_EQUAL(tagName, (std::string) element->name);
-    std::string dMessage = getText(element);
-    LOGUNIT_ASSERT_EQUAL(message, dMessage);
-  }
+		for (apr_text* t = elem->first_cdata.first;
+			t != NULL;
+			t = t->next)
+		{
+			dMessage.append(t->text);
+		}
+
+		return dMessage;
+	}
+	/**
+	 * Checks a log4j:event element against expectations.
+	 * @param element element, may not be null.
+	 * @param event event, may not be null.
+	 */
+	void checkEventElement(
+		apr_xml_elem * element, LoggingEventPtr & event)
+	{
+		std::string tagName("event");
+		LOGUNIT_ASSERT_EQUAL(tagName, (std::string) element->name);
+		LOG4CXX_ENCODE_CHAR(cLoggerName, event->getLoggerName());
+		LOGUNIT_ASSERT_EQUAL(cLoggerName, getAttribute(element, "logger"));
+		LOG4CXX_ENCODE_CHAR(cLevelName, event->getLevel()->toString());
+		LOGUNIT_ASSERT_EQUAL(cLevelName, getAttribute(element, "level"));
+	}
+
+	/**
+	 * Checks a log4j:message element against expectations.
+	 * @param element element, may not be null.
+	 * @param message expected message.
+	 */
+	void checkMessageElement(
+		apr_xml_elem * element, std::string message)
+	{
+		std::string tagName = "message";
+		LOGUNIT_ASSERT_EQUAL(tagName, (std::string) element->name);
+		LOGUNIT_ASSERT_EQUAL(message, getText(element));
+	}
+
+	/**
+	 * Checks a log4j:message element against expectations.
+	 * @param element element, may not be null.
+	 * @param message expected message.
+	 */
+	void checkNDCElement(apr_xml_elem * element, std::string message)
+	{
+		std::string tagName = "NDC";
+		LOGUNIT_ASSERT_EQUAL(tagName, (std::string) element->name);
+		std::string dMessage = getText(element);
+		LOGUNIT_ASSERT_EQUAL(message, dMessage);
+	}
 
 
-    /**
-     * Checks a log4j:properties element against expectations.
-     * @param element element, may not be null.
-     * @param key key.
-     * @param value value.
-     */
-    void checkPropertiesElement(
-      apr_xml_elem* element, std::string key, std::string value) {
-    std::string tagName = "properties";
-    std::string dataTag = "data";
-    int childNodeCount = 0;
-    LOGUNIT_ASSERT_EQUAL(tagName, (std::string) element->name);
-    for(apr_xml_elem* child = element->first_child;
-        child != NULL;
-        child = child->next) {
-            LOGUNIT_ASSERT_EQUAL(dataTag, (std::string) child->name);
-            LOGUNIT_ASSERT_EQUAL(key, getAttribute(child, "name"));
-            LOGUNIT_ASSERT_EQUAL(value, getAttribute(child, "value"));
-            childNodeCount++;        
-    }
-    LOGUNIT_ASSERT_EQUAL(1, childNodeCount);
-    }
+	/**
+	 * Checks a log4j:properties element against expectations.
+	 * @param element element, may not be null.
+	 * @param key key.
+	 * @param value value.
+	 */
+	void checkPropertiesElement(
+		apr_xml_elem * element, std::string key, std::string value)
+	{
+		std::string tagName = "properties";
+		std::string dataTag = "data";
+		int childNodeCount = 0;
+		LOGUNIT_ASSERT_EQUAL(tagName, (std::string) element->name);
+
+		for (apr_xml_elem* child = element->first_child;
+			child != NULL;
+			child = child->next)
+		{
+			LOGUNIT_ASSERT_EQUAL(dataTag, (std::string) child->name);
+			LOGUNIT_ASSERT_EQUAL(key, getAttribute(child, "name"));
+			LOGUNIT_ASSERT_EQUAL(value, getAttribute(child, "value"));
+			childNodeCount++;
+		}
+
+		LOGUNIT_ASSERT_EQUAL(1, childNodeCount);
+	}
 
 public:
-  /**
-   * Tests formatted results.
-   * @throws Exception if parser can not be constructed or source is not a valid XML document.
-   */
-  void testFormat() {
-    LogString logger = LOG4CXX_STR("org.apache.log4j.xml.XMLLayoutTest");
-    LoggingEventPtr event =
-      new LoggingEvent(
-        logger, Level::getInfo(), LOG4CXX_STR("Hello, World"), LOG4CXX_LOCATION);
-    Pool p;
-    XMLLayout layout;
-    LogString result;
-    layout.format(result, event, p);
-    apr_xml_elem* parsedResult = parse(result, p);
-    checkEventElement(parsedResult, event);
+	/**
+	 * Tests formatted results.
+	 * @throws Exception if parser can not be constructed or source is not a valid XML document.
+	 */
+	void testFormat()
+	{
+		LogString logger = LOG4CXX_STR("org.apache.log4j.xml.XMLLayoutTest");
+		LoggingEventPtr event =
+			new LoggingEvent(
+			logger, Level::getInfo(), LOG4CXX_STR("Hello, World"), LOG4CXX_LOCATION);
+		Pool p;
+		XMLLayout layout;
+		LogString result;
+		layout.format(result, event, p);
+		apr_xml_elem* parsedResult = parse(result, p);
+		checkEventElement(parsedResult, event);
 
-    int childElementCount = 0;
-    for (
-      apr_xml_elem* node = parsedResult->first_child; 
-      node != NULL;
-      node = node->next) {
-        childElementCount++;
-        checkMessageElement(node, "Hello, World");
-    }
+		int childElementCount = 0;
 
-    LOGUNIT_ASSERT_EQUAL(1, childElementCount);
-  }
+		for (
+			apr_xml_elem* node = parsedResult->first_child;
+			node != NULL;
+			node = node->next)
+		{
+			childElementCount++;
+			checkMessageElement(node, "Hello, World");
+		}
+
+		LOGUNIT_ASSERT_EQUAL(1, childElementCount);
+	}
 
 
-  /**
-   * Tests formatted results with an exception.
-   * @throws Exception if parser can not be constructed or source is not a valid XML document.
-   */
-  void testFormatWithNDC() {
-    LogString logger = LOG4CXX_STR("org.apache.log4j.xml.XMLLayoutTest");
-    NDC::push("NDC goes here");
+	/**
+	 * Tests formatted results with an exception.
+	 * @throws Exception if parser can not be constructed or source is not a valid XML document.
+	 */
+	void testFormatWithNDC()
+	{
+		LogString logger = LOG4CXX_STR("org.apache.log4j.xml.XMLLayoutTest");
+		NDC::push("NDC goes here");
 
-    LoggingEventPtr event =
-      new LoggingEvent(
-        logger, Level::getInfo(), LOG4CXX_STR("Hello, World"), LOG4CXX_LOCATION);
-    Pool p;
-    XMLLayout layout;
-    LogString result;
-    layout.format(result, event, p);
-    NDC::pop();
+		LoggingEventPtr event =
+			new LoggingEvent(
+			logger, Level::getInfo(), LOG4CXX_STR("Hello, World"), LOG4CXX_LOCATION);
+		Pool p;
+		XMLLayout layout;
+		LogString result;
+		layout.format(result, event, p);
+		NDC::pop();
 
-    apr_xml_elem* parsedResult = parse(result, p);
-    checkEventElement(parsedResult, event);
+		apr_xml_elem* parsedResult = parse(result, p);
+		checkEventElement(parsedResult, event);
 
-    int childElementCount = 0;
+		int childElementCount = 0;
 
-    for (
-      apr_xml_elem* node = parsedResult->first_child; node != NULL;
-        node = node->next) {
-        childElementCount++;
+		for (
+			apr_xml_elem* node = parsedResult->first_child; node != NULL;
+			node = node->next)
+		{
+			childElementCount++;
 
-        if (childElementCount == 1) {
-          checkMessageElement(node, "Hello, World");
-        } else {
-          checkNDCElement(node, "NDC goes here");
-        }
-    }
+			if (childElementCount == 1)
+			{
+				checkMessageElement(node, "Hello, World");
+			}
+			else
+			{
+				checkNDCElement(node, "NDC goes here");
+			}
+		}
 
-    LOGUNIT_ASSERT_EQUAL(2, childElementCount);
-  }
+		LOGUNIT_ASSERT_EQUAL(2, childElementCount);
+	}
 
-  /**
-   * Tests getLocationInfo and setLocationInfo.
-   */
- void testGetSetLocationInfo() {
-    XMLLayout layout;
-    LOGUNIT_ASSERT_EQUAL(false, layout.getLocationInfo());
-    layout.setLocationInfo(true);
-    LOGUNIT_ASSERT_EQUAL(true, layout.getLocationInfo());
-    layout.setLocationInfo(false);
-    LOGUNIT_ASSERT_EQUAL(false, layout.getLocationInfo());
-  }
+	/**
+	 * Tests getLocationInfo and setLocationInfo.
+	 */
+	void testGetSetLocationInfo()
+	{
+		XMLLayout layout;
+		LOGUNIT_ASSERT_EQUAL(false, layout.getLocationInfo());
+		layout.setLocationInfo(true);
+		LOGUNIT_ASSERT_EQUAL(true, layout.getLocationInfo());
+		layout.setLocationInfo(false);
+		LOGUNIT_ASSERT_EQUAL(false, layout.getLocationInfo());
+	}
 
-  /**
-   * Tests activateOptions().
-   */
-  void testActivateOptions() {
-    Pool p;
-    XMLLayout layout;
-    layout.activateOptions(p);
-  }
+	/**
+	 * Tests activateOptions().
+	 */
+	void testActivateOptions()
+	{
+		Pool p;
+		XMLLayout layout;
+		layout.activateOptions(p);
+	}
 
-    /**
-     * Tests problematic characters in multiple fields.
-     * @throws Exception if parser can not be constructed or source is not a valid XML document.
-     */
-    void testProblemCharacters()  {
-      std::string problemName = "com.example.bar<>&\"'";
-      LogString problemNameLS = LOG4CXX_STR("com.example.bar<>&\"'");
-      LevelPtr level = new XLevel(6000, problemNameLS, 7);
-      NDC::push(problemName);
-      MDC::clear();
-      MDC::put(problemName, problemName);
-      LoggingEventPtr event =
-        new LoggingEvent(problemNameLS, level, problemNameLS, LOG4CXX_LOCATION);
-      XMLLayout layout;
-      layout.setProperties(true);
-      Pool p;
-      LogString result;
-      layout.format(result, event, p);
-      MDC::clear();
+	/**
+	 * Tests problematic characters in multiple fields.
+	 * @throws Exception if parser can not be constructed or source is not a valid XML document.
+	 */
+	void testProblemCharacters()
+	{
+		std::string problemName = "com.example.bar<>&\"'";
+		LogString problemNameLS = LOG4CXX_STR("com.example.bar<>&\"'");
+		LevelPtr level = new XLevel(6000, problemNameLS, 7);
+		NDC::push(problemName);
+		MDC::clear();
+		MDC::put(problemName, problemName);
+		LoggingEventPtr event =
+			new LoggingEvent(problemNameLS, level, problemNameLS, LOG4CXX_LOCATION);
+		XMLLayout layout;
+		layout.setProperties(true);
+		Pool p;
+		LogString result;
+		layout.format(result, event, p);
+		MDC::clear();
 
-      apr_xml_elem* parsedResult = parse(result, p);
-      checkEventElement(parsedResult, event);
+		apr_xml_elem* parsedResult = parse(result, p);
+		checkEventElement(parsedResult, event);
 
-      int childElementCount = 0;
+		int childElementCount = 0;
 
-      for (
-        apr_xml_elem* node = parsedResult->first_child; node != NULL;
-          node = node->next) {
-          childElementCount++;
-          switch(childElementCount) {
-              case 1:
-              checkMessageElement(node, problemName);
-              break;
+		for (
+			apr_xml_elem* node = parsedResult->first_child; node != NULL;
+			node = node->next)
+		{
+			childElementCount++;
 
-              case 2:
-              checkNDCElement(node, problemName);
-              break;
+			switch (childElementCount)
+			{
+				case 1:
+					checkMessageElement(node, problemName);
+					break;
 
-              case 3:
-              checkPropertiesElement(node, problemName.c_str(), problemName.c_str());
-              break;
+				case 2:
+					checkNDCElement(node, problemName);
+					break;
 
-              default:
-              break;
-          }
+				case 3:
+					checkPropertiesElement(node, problemName.c_str(), problemName.c_str());
+					break;
 
-      }
-      LOGUNIT_ASSERT_EQUAL(3, childElementCount);
-    }
+				default:
+					break;
+			}
 
-    /**
-      * Tests CDATA element within NDC content.  See bug 37560.
-      */
-    void testNDCWithCDATA() {
-        LogString logger = LOG4CXX_STR("com.example.bar");
-        LevelPtr level = Level::getInfo();
-        std::string ndcMessage ="<envelope><faultstring><![CDATA[The EffectiveDate]]></faultstring><envelope>";
-        NDC::push(ndcMessage);
-        LoggingEventPtr event =
-          new LoggingEvent(
-            logger, level, LOG4CXX_STR("Hello, World"), LOG4CXX_LOCATION);
-        XMLLayout layout;
-        Pool p;
-        LogString result;
-        layout.format(result, event, p);
-        NDC::clear();
-        apr_xml_elem* parsedResult = parse(result, p);
-        int ndcCount = 0;
-        for(apr_xml_elem* node = parsedResult->first_child;
-            node != NULL;
-            node = node->next) {
-            if (strcmp(node->name, "NDC") == 0) {
-                ndcCount++;
-                LOGUNIT_ASSERT_EQUAL(ndcMessage, getText(node));
-            }
-        }
-        LOGUNIT_ASSERT_EQUAL(1, ndcCount);
-   }
+		}
+
+		LOGUNIT_ASSERT_EQUAL(3, childElementCount);
+	}
+
+	/**
+	  * Tests CDATA element within NDC content.  See bug 37560.
+	  */
+	void testNDCWithCDATA()
+	{
+		LogString logger = LOG4CXX_STR("com.example.bar");
+		LevelPtr level = Level::getInfo();
+		std::string ndcMessage = "<envelope><faultstring><![CDATA[The EffectiveDate]]></faultstring><envelope>";
+		NDC::push(ndcMessage);
+		LoggingEventPtr event =
+			new LoggingEvent(
+			logger, level, LOG4CXX_STR("Hello, World"), LOG4CXX_LOCATION);
+		XMLLayout layout;
+		Pool p;
+		LogString result;
+		layout.format(result, event, p);
+		NDC::clear();
+		apr_xml_elem* parsedResult = parse(result, p);
+		int ndcCount = 0;
+
+		for (apr_xml_elem* node = parsedResult->first_child;
+			node != NULL;
+			node = node->next)
+		{
+			if (strcmp(node->name, "NDC") == 0)
+			{
+				ndcCount++;
+				LOGUNIT_ASSERT_EQUAL(ndcMessage, getText(node));
+			}
+		}
+
+		LOGUNIT_ASSERT_EQUAL(1, ndcCount);
+	}
 
 };
 
diff --git a/src/test/cpp/xml/xmllayouttestcase.cpp b/src/test/cpp/xml/xmllayouttestcase.cpp
index bd1cc8b..de13ef2 100644
--- a/src/test/cpp/xml/xmllayouttestcase.cpp
+++ b/src/test/cpp/xml/xmllayouttestcase.cpp
@@ -39,117 +39,117 @@
 using namespace log4cxx::xml;
 
 #if defined(__LOG4CXX_FUNC__)
-#undef __LOG4CXX_FUNC__
-#define __LOG4CXX_FUNC__ "X::X()"
+	#undef __LOG4CXX_FUNC__
+	#define __LOG4CXX_FUNC__ "X::X()"
 #else
-#error __LOG4CXX_FUNC__ expected to be defined
+	#error __LOG4CXX_FUNC__ expected to be defined
 #endif
 
 class X
 {
-public:
-        X()
-        {
-                LoggerPtr logger =
-                        Logger::getLogger(LOG4CXX_TEST_STR("org.apache.log4j.xml.XMLLayoutTestCase$X"));
-                LOG4CXX_INFO(logger, LOG4CXX_TEST_STR("in X() constructor"));
-        }
+	public:
+		X()
+		{
+			LoggerPtr logger =
+				Logger::getLogger(LOG4CXX_TEST_STR("org.apache.log4j.xml.XMLLayoutTestCase$X"));
+			LOG4CXX_INFO(logger, LOG4CXX_TEST_STR("in X() constructor"));
+		}
 };
 
 
 LOGUNIT_CLASS(XMLLayoutTestCase)
 {
-        LOGUNIT_TEST_SUITE(XMLLayoutTestCase);
-                LOGUNIT_TEST(basic);
-                LOGUNIT_TEST(locationInfo);
-                LOGUNIT_TEST(testCDATA);
-                LOGUNIT_TEST(testNull);
-                LOGUNIT_TEST(testMDC);
-                LOGUNIT_TEST(testMDCEscaped);
-        LOGUNIT_TEST_SUITE_END();
+	LOGUNIT_TEST_SUITE(XMLLayoutTestCase);
+	LOGUNIT_TEST(basic);
+	LOGUNIT_TEST(locationInfo);
+	LOGUNIT_TEST(testCDATA);
+	LOGUNIT_TEST(testNull);
+	LOGUNIT_TEST(testMDC);
+	LOGUNIT_TEST(testMDCEscaped);
+	LOGUNIT_TEST_SUITE_END();
 
-        LoggerPtr root;
-        LoggerPtr logger;
+	LoggerPtr root;
+	LoggerPtr logger;
 
 public:
-        void setUp()
-        {
-                root = Logger::getRootLogger();
-                root->setLevel(Level::getTrace());
-                logger = Logger::getLogger(LOG4CXX_TEST_STR("org.apache.log4j.xml.XMLLayoutTestCase"));
-                logger->setLevel(Level::getTrace());
-        }
+	void setUp()
+	{
+		root = Logger::getRootLogger();
+		root->setLevel(Level::getTrace());
+		logger = Logger::getLogger(LOG4CXX_TEST_STR("org.apache.log4j.xml.XMLLayoutTestCase"));
+		logger->setLevel(Level::getTrace());
+	}
 
-        void tearDown()
-        {
-                logger->getLoggerRepository()->resetConfiguration();
-        }
+	void tearDown()
+	{
+		logger->getLoggerRepository()->resetConfiguration();
+	}
 
-        void basic()
-        {
-                const LogString tempFileName(LOG4CXX_STR("output/temp.xmlLayout.1"));
-                const File filteredFile("output/filtered.xmlLayout.1");
+	void basic()
+	{
+		const LogString tempFileName(LOG4CXX_STR("output/temp.xmlLayout.1"));
+		const File filteredFile("output/filtered.xmlLayout.1");
 
-                XMLLayoutPtr xmlLayout = new XMLLayout();
-                AppenderPtr appender(new FileAppender(xmlLayout, tempFileName, false));
-                root->addAppender(appender);
-                common();
+		XMLLayoutPtr xmlLayout = new XMLLayout();
+		AppenderPtr appender(new FileAppender(xmlLayout, tempFileName, false));
+		root->addAppender(appender);
+		common();
 
-                XMLTimestampFilter xmlTimestampFilter;
-                XMLThreadFilter xmlThreadFilter;
+		XMLTimestampFilter xmlTimestampFilter;
+		XMLThreadFilter xmlThreadFilter;
 
-                std::vector<Filter *> filters;
-                filters.push_back(&xmlThreadFilter);
-                filters.push_back(&xmlTimestampFilter);
+		std::vector<Filter*> filters;
+		filters.push_back(&xmlThreadFilter);
+		filters.push_back(&xmlTimestampFilter);
 
-                try
-                {
-                        Transformer::transform(tempFileName, filteredFile, filters);
-                }
-                catch(UnexpectedFormatException& e)
-                {
-                        std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
-                        throw;
-                }
+		try
+		{
+			Transformer::transform(tempFileName, filteredFile, filters);
+		}
+		catch (UnexpectedFormatException& e)
+		{
+			std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
+			throw;
+		}
 
-                LOGUNIT_ASSERT(Compare::compare(filteredFile, LOG4CXX_FILE("witness/xmlLayout.1")));
-        }
+		LOGUNIT_ASSERT(Compare::compare(filteredFile, LOG4CXX_FILE("witness/xmlLayout.1")));
+	}
 
-        void locationInfo()
-        {
-                const LogString tempFileName(LOG4CXX_STR("output/temp.xmlLayout.2"));
-                const File filteredFile("output/filtered.xmlLayout.2");
+	void locationInfo()
+	{
+		const LogString tempFileName(LOG4CXX_STR("output/temp.xmlLayout.2"));
+		const File filteredFile("output/filtered.xmlLayout.2");
 
-                XMLLayoutPtr xmlLayout = new XMLLayout();
-                xmlLayout->setLocationInfo(true);
-                root->addAppender(new FileAppender(xmlLayout, tempFileName, false));
-                common();
+		XMLLayoutPtr xmlLayout = new XMLLayout();
+		xmlLayout->setLocationInfo(true);
+		root->addAppender(new FileAppender(xmlLayout, tempFileName, false));
+		common();
 
-                XMLTimestampFilter xmlTimestampFilter;
-                XMLThreadFilter xmlThreadFilter;
-                FilenameFilter xmlFilenameFilter(__FILE__, "XMLLayoutTestCase.java");
-                Filter line2XX("[23][0-9][0-9]", "X");
-                Filter line5X("5[0-9]", "X");
+		XMLTimestampFilter xmlTimestampFilter;
+		XMLThreadFilter xmlThreadFilter;
+		FilenameFilter xmlFilenameFilter(__FILE__, "XMLLayoutTestCase.java");
+		Filter line2XX("[23][0-9][0-9]", "X");
+		Filter line5X("5[0-9]", "X");
 
-                std::vector<Filter *> filters;
-                filters.push_back(&xmlFilenameFilter);
-                filters.push_back(&xmlThreadFilter);
-                filters.push_back(&xmlTimestampFilter);
-                filters.push_back(&line2XX);
-                filters.push_back(&line5X);
+		std::vector<Filter*> filters;
+		filters.push_back(&xmlFilenameFilter);
+		filters.push_back(&xmlThreadFilter);
+		filters.push_back(&xmlTimestampFilter);
+		filters.push_back(&line2XX);
+		filters.push_back(&line5X);
 
-                try
-                {
-                        Transformer::transform(tempFileName, filteredFile, filters);
-                }
-                catch(UnexpectedFormatException& e)
-                {
-                        std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
-                        throw;
-                }
+		try
+		{
+			Transformer::transform(tempFileName, filteredFile, filters);
+		}
+		catch (UnexpectedFormatException& e)
+		{
+			std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
+			throw;
+		}
 
-                LOGUNIT_ASSERT(Compare::compare(filteredFile, LOG4CXX_FILE("witness/xmlLayout.2")));
-        }
+		LOGUNIT_ASSERT(Compare::compare(filteredFile, LOG4CXX_FILE("witness/xmlLayout.2")));
+	}
 
 
 
@@ -158,154 +158,154 @@
 
 
 
-        void testCDATA()
-        {
-                const LogString tempFileName(LOG4CXX_STR("output/temp.xmlLayout.3"));
-                const File filteredFile("output/filtered.xmlLayout.3");
+	void testCDATA()
+	{
+		const LogString tempFileName(LOG4CXX_STR("output/temp.xmlLayout.3"));
+		const File filteredFile("output/filtered.xmlLayout.3");
 
-                XMLLayoutPtr xmlLayout = new XMLLayout();
-                xmlLayout->setLocationInfo(true);
-                FileAppenderPtr appender(new FileAppender(xmlLayout, tempFileName, false));
-                root->addAppender(appender);
+		XMLLayoutPtr xmlLayout = new XMLLayout();
+		xmlLayout->setLocationInfo(true);
+		FileAppenderPtr appender(new FileAppender(xmlLayout, tempFileName, false));
+		root->addAppender(appender);
 
-                LOG4CXX_TRACE(logger,
-                        LOG4CXX_TEST_STR("Message with embedded <![CDATA[<hello>hi</hello>]]>."));
-                LOG4CXX_DEBUG(logger,
-                        LOG4CXX_TEST_STR("Message with embedded <![CDATA[<hello>hi</hello>]]>."));
+		LOG4CXX_TRACE(logger,
+			LOG4CXX_TEST_STR("Message with embedded <![CDATA[<hello>hi</hello>]]>."));
+		LOG4CXX_DEBUG(logger,
+			LOG4CXX_TEST_STR("Message with embedded <![CDATA[<hello>hi</hello>]]>."));
 
-                XMLTimestampFilter xmlTimestampFilter;
-                XMLThreadFilter xmlThreadFilter;
-                FilenameFilter xmlFilenameFilter(__FILE__, "XMLLayoutTestCase.java");
-                Filter line1xx("1[0-9][0-9]", "X");
+		XMLTimestampFilter xmlTimestampFilter;
+		XMLThreadFilter xmlThreadFilter;
+		FilenameFilter xmlFilenameFilter(__FILE__, "XMLLayoutTestCase.java");
+		Filter line1xx("1[0-9][0-9]", "X");
 
-                std::vector<Filter *> filters;
-                filters.push_back(&xmlFilenameFilter);
-                filters.push_back(&xmlThreadFilter);
-                filters.push_back(&xmlTimestampFilter);
-                filters.push_back(&line1xx);
+		std::vector<Filter*> filters;
+		filters.push_back(&xmlFilenameFilter);
+		filters.push_back(&xmlThreadFilter);
+		filters.push_back(&xmlTimestampFilter);
+		filters.push_back(&line1xx);
 
-                try
-                {
-                        Transformer::transform(tempFileName, filteredFile, filters);
-                }
-                catch(UnexpectedFormatException& e)
-                {
-                        std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
-                        throw;
-                }
+		try
+		{
+			Transformer::transform(tempFileName, filteredFile, filters);
+		}
+		catch (UnexpectedFormatException& e)
+		{
+			std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
+			throw;
+		}
 
-                LOGUNIT_ASSERT(Compare::compare(filteredFile, LOG4CXX_FILE("witness/xmlLayout.3")));
-        }
+		LOGUNIT_ASSERT(Compare::compare(filteredFile, LOG4CXX_FILE("witness/xmlLayout.3")));
+	}
 
-        void testNull()
-        {
-                const LogString tempFileName(LOG4CXX_STR("output/temp.xmlLayout.null"));
-                const File filteredFile("output/filtered.xmlLayout.null");
+	void testNull()
+	{
+		const LogString tempFileName(LOG4CXX_STR("output/temp.xmlLayout.null"));
+		const File filteredFile("output/filtered.xmlLayout.null");
 
-                XMLLayoutPtr xmlLayout = new XMLLayout();
-                FileAppenderPtr appender(new FileAppender(xmlLayout, tempFileName, false));
-                root->addAppender(appender);
+		XMLLayoutPtr xmlLayout = new XMLLayout();
+		FileAppenderPtr appender(new FileAppender(xmlLayout, tempFileName, false));
+		root->addAppender(appender);
 
-                LOG4CXX_DEBUG(logger, LOG4CXX_TEST_STR("hi"));
-                LOG4CXX_DEBUG(logger, (char*) 0);
-                LOG4CXX_DEBUG(logger, "hi");
+		LOG4CXX_DEBUG(logger, LOG4CXX_TEST_STR("hi"));
+		LOG4CXX_DEBUG(logger, (char*) 0);
+		LOG4CXX_DEBUG(logger, "hi");
 
-                XMLTimestampFilter xmlTimestampFilter;
-                XMLThreadFilter xmlThreadFilter;
+		XMLTimestampFilter xmlTimestampFilter;
+		XMLThreadFilter xmlThreadFilter;
 
-                std::vector<Filter *> filters;
-                filters.push_back(&xmlThreadFilter);
-                filters.push_back(&xmlTimestampFilter);
+		std::vector<Filter*> filters;
+		filters.push_back(&xmlThreadFilter);
+		filters.push_back(&xmlTimestampFilter);
 
-                try
-                {
-                        Transformer::transform(tempFileName, filteredFile, filters);
-                }
-                catch(UnexpectedFormatException& e)
-                {
-                        std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
-                        throw;
-                }
+		try
+		{
+			Transformer::transform(tempFileName, filteredFile, filters);
+		}
+		catch (UnexpectedFormatException& e)
+		{
+			std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
+			throw;
+		}
 
-                LOGUNIT_ASSERT(Compare::compare(filteredFile, LOG4CXX_FILE("witness/xmlLayout.null")));
-        }
+		LOGUNIT_ASSERT(Compare::compare(filteredFile, LOG4CXX_FILE("witness/xmlLayout.null")));
+	}
 
-        void testMDC()
-        {
-                const LogString tempFileName(LOG4CXX_STR("output/temp.xmlLayout.mdc.1"));
-                const File filteredFile("output/filtered.xmlLayout.mdc.1");
+	void testMDC()
+	{
+		const LogString tempFileName(LOG4CXX_STR("output/temp.xmlLayout.mdc.1"));
+		const File filteredFile("output/filtered.xmlLayout.mdc.1");
 
-                XMLLayoutPtr xmlLayout = new XMLLayout();
-                xmlLayout->setProperties(true);
-                FileAppenderPtr appender(new FileAppender(xmlLayout, tempFileName, false));
-                root->addAppender(appender);
+		XMLLayoutPtr xmlLayout = new XMLLayout();
+		xmlLayout->setProperties(true);
+		FileAppenderPtr appender(new FileAppender(xmlLayout, tempFileName, false));
+		root->addAppender(appender);
 
-                MDC::clear();
-                MDC::put(LOG4CXX_TEST_STR("key1"), LOG4CXX_TEST_STR("val1"));
-                MDC::put(LOG4CXX_TEST_STR("key2"), LOG4CXX_TEST_STR("val2"));
+		MDC::clear();
+		MDC::put(LOG4CXX_TEST_STR("key1"), LOG4CXX_TEST_STR("val1"));
+		MDC::put(LOG4CXX_TEST_STR("key2"), LOG4CXX_TEST_STR("val2"));
 
-                LOG4CXX_DEBUG(logger, LOG4CXX_TEST_STR("Hello"));
+		LOG4CXX_DEBUG(logger, LOG4CXX_TEST_STR("Hello"));
 
-                MDC::clear();
+		MDC::clear();
 
-                XMLTimestampFilter xmlTimestampFilter;
-                XMLThreadFilter xmlThreadFilter;
+		XMLTimestampFilter xmlTimestampFilter;
+		XMLThreadFilter xmlThreadFilter;
 
-                std::vector<Filter *> filters;
-                filters.push_back(&xmlThreadFilter);
-                filters.push_back(&xmlTimestampFilter);
+		std::vector<Filter*> filters;
+		filters.push_back(&xmlThreadFilter);
+		filters.push_back(&xmlTimestampFilter);
 
-                try
-                {
-                        Transformer::transform(tempFileName, filteredFile, filters);
-                }
-                catch(UnexpectedFormatException& e)
-                {
-                        std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
-                        throw;
-                }
+		try
+		{
+			Transformer::transform(tempFileName, filteredFile, filters);
+		}
+		catch (UnexpectedFormatException& e)
+		{
+			std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
+			throw;
+		}
 
-                LOGUNIT_ASSERT(Compare::compare(filteredFile, LOG4CXX_FILE("witness/xmlLayout.mdc.1")));
-        }
+		LOGUNIT_ASSERT(Compare::compare(filteredFile, LOG4CXX_FILE("witness/xmlLayout.mdc.1")));
+	}
 
-        // not incuded in the tests for the moment !
-        void testMDCEscaped()
-        {
-                const LogString tempFileName(LOG4CXX_STR("output/temp.xmlLayout.mdc.2"));
-                const File filteredFile("output/filtered.xmlLayout.mdc.2");
+	// not incuded in the tests for the moment !
+	void testMDCEscaped()
+	{
+		const LogString tempFileName(LOG4CXX_STR("output/temp.xmlLayout.mdc.2"));
+		const File filteredFile("output/filtered.xmlLayout.mdc.2");
 
-                XMLLayoutPtr xmlLayout = new XMLLayout();
-                xmlLayout->setProperties(true);
-                FileAppenderPtr appender(new FileAppender(xmlLayout, tempFileName, false));
-                root->addAppender(appender);
+		XMLLayoutPtr xmlLayout = new XMLLayout();
+		xmlLayout->setProperties(true);
+		FileAppenderPtr appender(new FileAppender(xmlLayout, tempFileName, false));
+		root->addAppender(appender);
 
-                MDC::clear();
-                MDC::put(LOG4CXX_TEST_STR("blahAttribute"), LOG4CXX_TEST_STR("<blah value='blah'>"));
-                MDC::put(LOG4CXX_TEST_STR("<blahKey value='blah'/>"), LOG4CXX_TEST_STR("blahValue"));
+		MDC::clear();
+		MDC::put(LOG4CXX_TEST_STR("blahAttribute"), LOG4CXX_TEST_STR("<blah value='blah'>"));
+		MDC::put(LOG4CXX_TEST_STR("<blahKey value='blah'/>"), LOG4CXX_TEST_STR("blahValue"));
 
-                LOG4CXX_DEBUG(logger, LOG4CXX_TEST_STR("Hello"));
+		LOG4CXX_DEBUG(logger, LOG4CXX_TEST_STR("Hello"));
 
-                MDC::clear();
+		MDC::clear();
 
-                XMLTimestampFilter xmlTimestampFilter;
-                XMLThreadFilter xmlThreadFilter;
+		XMLTimestampFilter xmlTimestampFilter;
+		XMLThreadFilter xmlThreadFilter;
 
-                std::vector<Filter *> filters;
-                filters.push_back(&xmlThreadFilter);
-                filters.push_back(&xmlTimestampFilter);
+		std::vector<Filter*> filters;
+		filters.push_back(&xmlThreadFilter);
+		filters.push_back(&xmlTimestampFilter);
 
-                try
-                {
-                        Transformer::transform(tempFileName, filteredFile, filters);
-                }
-                catch(UnexpectedFormatException& e)
-                {
-                        std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
-                        throw;
-                }
+		try
+		{
+			Transformer::transform(tempFileName, filteredFile, filters);
+		}
+		catch (UnexpectedFormatException& e)
+		{
+			std::cout << "UnexpectedFormatException :" << e.what() << std::endl;
+			throw;
+		}
 
-                LOGUNIT_ASSERT(Compare::compare(filteredFile, LOG4CXX_FILE("witness/xmlLayout.mdc.2")));
-        }
+		LOGUNIT_ASSERT(Compare::compare(filteredFile, LOG4CXX_FILE("witness/xmlLayout.mdc.2")));
+	}
 
 
 
@@ -314,44 +314,44 @@
 
 
 
-        void common()
-        {
-                int i = 0;
-                X x;
+	void common()
+	{
+		int i = 0;
+		X x;
 
-            std::string msg("Message ");
+		std::string msg("Message ");
 
-                LOG4CXX_TRACE(logger, msg << i);
-                LOG4CXX_TRACE(root, msg << i);
+		LOG4CXX_TRACE(logger, msg << i);
+		LOG4CXX_TRACE(root, msg << i);
 
-                i++;
-                LOG4CXX_DEBUG(logger, msg << i);
-                LOG4CXX_DEBUG(root, msg << i);
+		i++;
+		LOG4CXX_DEBUG(logger, msg << i);
+		LOG4CXX_DEBUG(root, msg << i);
 
-                i++;
-                LOG4CXX_INFO(logger, msg << i);
-                LOG4CXX_INFO(root, msg << i);
+		i++;
+		LOG4CXX_INFO(logger, msg << i);
+		LOG4CXX_INFO(root, msg << i);
 
-                i++;
-                LOG4CXX_WARN(logger, msg << i);
-                LOG4CXX_WARN(root, msg << i);
+		i++;
+		LOG4CXX_WARN(logger, msg << i);
+		LOG4CXX_WARN(root, msg << i);
 
-                i++;
-                LOG4CXX_ERROR(logger, msg << i);
-                LOG4CXX_ERROR(root, msg << i);
+		i++;
+		LOG4CXX_ERROR(logger, msg << i);
+		LOG4CXX_ERROR(root, msg << i);
 
-                i++;
-                LOG4CXX_FATAL(logger, msg << i);
-                LOG4CXX_FATAL(root, msg << i);
+		i++;
+		LOG4CXX_FATAL(logger, msg << i);
+		LOG4CXX_FATAL(root, msg << i);
 
-                i++;
-                LOG4CXX_DEBUG(logger, "Message " << i);
-                LOG4CXX_DEBUG(root, "Message " << i);
+		i++;
+		LOG4CXX_DEBUG(logger, "Message " << i);
+		LOG4CXX_DEBUG(root, "Message " << i);
 
-                i++;
-                LOG4CXX_ERROR(logger, "Message " << i);
-                LOG4CXX_ERROR(root, "Message " << i);
-        }
+		i++;
+		LOG4CXX_ERROR(logger, "Message " << i);
+		LOG4CXX_ERROR(root, "Message " << i);
+	}
 };
 
 LOGUNIT_TEST_SUITE_REGISTRATION(XMLLayoutTestCase);
diff --git a/src/test/resources/input/socketServer2.properties b/src/test/resources/input/socketServer2.properties
index aafd7af..4536dc9 100644
--- a/src/test/resources/input/socketServer2.properties
+++ b/src/test/resources/input/socketServer2.properties
@@ -19,5 +19,5 @@
 log4j.appender.A.file=output/temp
 log4j.appender.A.Append=false
 log4j.appender.A.layout=org.apache.log4j.PatternLayout
-log4j.appender.A.layout.ConversionPattern=%5p %x [%t] %C (%F:%L) %m%n
+log4j.appender.A.layout.ConversionPattern=%5p %x [%t] %c{1} (%F:%L) %m%n
 
diff --git a/src/test/resources/input/socketServer3.properties b/src/test/resources/input/socketServer3.properties
index 7ddb85c..bc7e2a1 100644
--- a/src/test/resources/input/socketServer3.properties
+++ b/src/test/resources/input/socketServer3.properties
@@ -19,4 +19,4 @@
 log4j.appender.A.file=output/temp
 log4j.appender.A.Append=false
 log4j.appender.A.layout=org.apache.log4j.PatternLayout
-log4j.appender.A.layout.ConversionPattern=%5p %x [%t] %C (%F:%L) %m%n
+log4j.appender.A.layout.ConversionPattern=%5p %x [%t] %c{1} (%F:%L) %m%n
diff --git a/src/test/resources/witness/socketServer.2 b/src/test/resources/witness/socketServer.2
index 8f9b189..33df315 100644
--- a/src/test/resources/witness/socketServer.2
+++ b/src/test/resources/witness/socketServer.2
@@ -1,7 +1,7 @@
 TRACE T2 [main] SocketServerTestCase (socketservertestcase.cpp:XXX) Message 1
-TRACE T2 [main] SocketServerTestCase (socketservertestcase.cpp:XXX) Message 2
+TRACE T2 [main] root (socketservertestcase.cpp:XXX) Message 2
 DEBUG T2 [main] SocketServerTestCase (socketservertestcase.cpp:XXX) Message 3
-DEBUG T2 [main] SocketServerTestCase (socketservertestcase.cpp:XXX) Message 4
+DEBUG T2 [main] root (socketservertestcase.cpp:XXX) Message 4
  INFO T2 [main] SocketServerTestCase (socketservertestcase.cpp:XXX) Message 5
  WARN T2 [main] SocketServerTestCase (socketservertestcase.cpp:XXX) Message 6
 FATAL T2 [main] SocketServerTestCase (socketservertestcase.cpp:XXX) Message 7
@@ -17,7 +17,7 @@
 	at junit.framework.TestCase.run(TestCase.java:XXX)
 	at junit.framework.TestSuite.runTest(TestSuite.java:XXX)
 	at junit.framework.TestSuite.run(TestSuite.java:XXX)
-ERROR T2 [main] SocketServerTestCase (socketservertestcase.cpp:XXX) Message 9
+ERROR T2 [main] root (socketservertestcase.cpp:XXX) Message 9
 java.lang.Exception: Just testing
 	at org.apache.log4j.net.SocketServerTestCase.common(SocketServerTestCase.java:XXX)
 	at org.apache.log4j.net.SocketServerTestCase.test2(SocketServerTestCase.java:XXX)
diff --git a/src/test/resources/witness/socketServer.3 b/src/test/resources/witness/socketServer.3
index 1f8e8b6..47dca83 100644
--- a/src/test/resources/witness/socketServer.3
+++ b/src/test/resources/witness/socketServer.3
@@ -1,7 +1,7 @@
 TRACE T3 [main] SocketServerTestCase (socketservertestcase.cpp:XXX) Message 1
-TRACE T3 [main] SocketServerTestCase (socketservertestcase.cpp:XXX) Message 2
+TRACE T3 [main] root (socketservertestcase.cpp:XXX) Message 2
 DEBUG T3 [main] SocketServerTestCase (socketservertestcase.cpp:XXX) Message 3
-DEBUG T3 [main] SocketServerTestCase (socketservertestcase.cpp:XXX) Message 4
+DEBUG T3 [main] root (socketservertestcase.cpp:XXX) Message 4
  INFO T3 [main] SocketServerTestCase (socketservertestcase.cpp:XXX) Message 5
  WARN T3 [main] SocketServerTestCase (socketservertestcase.cpp:XXX) Message 6
 FATAL T3 [main] SocketServerTestCase (socketservertestcase.cpp:XXX) Message 7
@@ -17,7 +17,7 @@
 	at junit.framework.TestCase.run(TestCase.java:XXX)
 	at junit.framework.TestSuite.runTest(TestSuite.java:XXX)
 	at junit.framework.TestSuite.run(TestSuite.java:XXX)
-ERROR T3 [main] SocketServerTestCase (socketservertestcase.cpp:XXX) Message 9
+ERROR T3 [main] root (socketservertestcase.cpp:XXX) Message 9
 java.lang.Exception: Just testing
 	at org.apache.log4j.net.SocketServerTestCase.common(SocketServerTestCase.java:XXX)
 	at org.apache.log4j.net.SocketServerTestCase.test3(SocketServerTestCase.java:XXX)