Foundation/GTMLoggerRingBufferWriterTest.m - external/google-toolbox-for-mac - Git at Google

 //
 //  GTMLoggerRingBufferWriterTest.m
 //
 //  Copyright 2007-2008 Google Inc.
 //
 //  Licensed 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.
 //

 #import "GTMSenTestCase.h"
 #import "GTMLoggerRingBufferWriter.h"
 #import "GTMLogger.h"

 // --------------------------------------------------
 // CountingWriter keeps a count of the number of times it has been
 // told to write something, and also keeps track of what it was
 // asked to log.

 @interface CountingWriter : NSObject<GTMLogWriter> {
  @private
   NSMutableArray *loggedContents_;
 }

 - (NSUInteger)count;
 - (NSArray *)loggedContents;
 - (void)reset;

 @end  // CountingWriter

 @implementation CountingWriter
 - (void)logMessage:(NSString *)msg level:(GTMLoggerLevel)level {
   if (!loggedContents_) {
     loggedContents_ = [[NSMutableArray alloc] init];
   }
   [loggedContents_ addObject:msg];
 }  // logMessage

 - (void)dealloc {
   [loggedContents_ release];
   [super dealloc];
 }  // dealloc

 - (void)reset {
   [loggedContents_ release];
   loggedContents_ = nil;
 }  // reset

 - (NSUInteger)count {
   return [loggedContents_ count];
 }  // count

 - (NSArray *)loggedContents {
   return loggedContents_;
 }  // loggedContents

 @end  // CountingWriter


 @interface GTMLoggerRingBufferWriterTest : GTMTestCase {
  @private
   GTMLogger *logger_;
   CountingWriter *countingWriter_;
 }
 @end  // GTMLoggerRingBufferWriterTest


 // --------------------------------------------------

 @implementation GTMLoggerRingBufferWriterTest

 // Utilty to compare the set of messages captured by a CountingWriter
 // with an array of expected messages.  The messages are expected to
 // be in the same order in both places.

 - (void)compareWriter:(CountingWriter *)writer
   withExpectedLogging:(NSArray *)expected
                  line:(int)line {
   NSArray *loggedContents = [writer loggedContents];

   XCTAssertEqual([expected count], [loggedContents count],
                  @"count mismatch from line %d", line);

   for (unsigned int i = 0; i < [expected count]; i++) {
     XCTAssertEqualObjects([expected objectAtIndex:i],
                           [loggedContents objectAtIndex:i],
                           @"logging mistmatch at index %d from line %d",
                           i, line);
   }

 }  // compareWithExpectedLogging


 - (void)setUp {
   countingWriter_ = [[CountingWriter alloc] init];
   logger_ = [[GTMLogger alloc] init];
 }  // setUp


 - (void)tearDown {
   [countingWriter_ release];
   [logger_ release];
 }  // tearDown


 - (void)testCreation {

   // Make sure initializers work.
   GTMLoggerRingBufferWriter *writer =
     [GTMLoggerRingBufferWriter ringBufferWriterWithCapacity:32
                                                      writer:countingWriter_];
   XCTAssertEqual([writer capacity], (NSUInteger)32);
   XCTAssertTrue([writer writer] == countingWriter_);
   XCTAssertEqual([writer count], (NSUInteger)0);
   XCTAssertEqual([writer droppedLogCount], (NSUInteger)0);
   XCTAssertEqual([writer totalLogged], (NSUInteger)0);

   // Try with invalid arguments.  Should always get nil back.
   writer =
     [GTMLoggerRingBufferWriter ringBufferWriterWithCapacity:0
                                                      writer:countingWriter_];
   XCTAssertNil(writer);

   writer = [GTMLoggerRingBufferWriter ringBufferWriterWithCapacity:32
                                                              writer:nil];
   XCTAssertNil(writer);

   writer = [[GTMLoggerRingBufferWriter alloc] init];
   XCTAssertNil(writer);

 }  // testCreation


 - (void)testLogging {
   GTMLoggerRingBufferWriter *writer =
     [GTMLoggerRingBufferWriter ringBufferWriterWithCapacity:4
                                                      writer:countingWriter_];
   [logger_ setWriter:writer];

   // Shouldn't do anything if there are no contents.
   [writer dumpContents];
   XCTAssertEqual([writer count], (NSUInteger)0);
   XCTAssertEqual([countingWriter_ count], (NSUInteger)0);

   // Log a single item.  Make sure the counts are accurate.
   [logger_ logDebug:@"oop"];
   XCTAssertEqual([writer count], (NSUInteger)1);
   XCTAssertEqual([writer totalLogged], (NSUInteger)1);
   XCTAssertEqual([writer droppedLogCount], (NSUInteger)0);
   XCTAssertEqual([countingWriter_ count], (NSUInteger)0);

   // Log a second item.  Also make sure counts are accurate.
   [logger_ logDebug:@"ack"];
   XCTAssertEqual([writer count], (NSUInteger)2);
   XCTAssertEqual([writer totalLogged], (NSUInteger)2);
   XCTAssertEqual([writer droppedLogCount], (NSUInteger)0);
   XCTAssertEqual([countingWriter_ count], (NSUInteger)0);

   // Print them, and make sure the countingWriter sees the right stuff.
   [writer dumpContents];
   XCTAssertEqual([countingWriter_ count], (NSUInteger)2);
   XCTAssertEqual([writer count], (NSUInteger)2);  // Should not be zeroed.
   XCTAssertEqual([writer totalLogged], (NSUInteger)2);

   [self compareWriter:countingWriter_
         withExpectedLogging:[NSArray arrayWithObjects:@"oop",@"ack", nil]
                  line:__LINE__];


   // Wipe the slates clean.
   [writer reset];
   [countingWriter_ reset];
   XCTAssertEqual([writer count], (NSUInteger)0);
   XCTAssertEqual([writer totalLogged], (NSUInteger)0);

   // An error log level should print the buffer and empty it.
   [logger_ logDebug:@"oop"];
   [logger_ logInfo:@"ack"];
   XCTAssertEqual([writer droppedLogCount], (NSUInteger)0);
   XCTAssertEqual([writer totalLogged], (NSUInteger)2);

   [logger_ logError:@"blargh"];
   XCTAssertEqual([countingWriter_ count], (NSUInteger)3);
   XCTAssertEqual([writer droppedLogCount], (NSUInteger)0);

   [self compareWriter:countingWriter_
         withExpectedLogging:[NSArray arrayWithObjects:@"oop", @"ack",
                                      @"blargh", nil]
                  line:__LINE__];


   // An assert log level should do the same.  This also fills the
   // buffer to its limit without wrapping.
   [countingWriter_ reset];
   [logger_ logDebug:@"oop"];
   [logger_ logInfo:@"ack"];
   [logger_ logDebug:@"blargh"];
   XCTAssertEqual([writer droppedLogCount], (NSUInteger)0);
   XCTAssertEqual([writer count], (NSUInteger)3);
   XCTAssertEqual([writer totalLogged], (NSUInteger)3);

   [logger_ logAssert:@"ouch"];
   XCTAssertEqual([countingWriter_ count], (NSUInteger)4);
   XCTAssertEqual([writer droppedLogCount], (NSUInteger)0);
   [self compareWriter:countingWriter_
         withExpectedLogging:[NSArray arrayWithObjects:@"oop", @"ack",
                                      @"blargh", @"ouch", nil]
                  line:__LINE__];


   // Try with exactly one wrap around.
   [countingWriter_ reset];
   [logger_ logInfo:@"ack"];
   [logger_ logDebug:@"oop"];
   [logger_ logDebug:@"blargh"];
   [logger_ logDebug:@"flong"];  // Fills buffer
   XCTAssertEqual([writer droppedLogCount], (NSUInteger)0);
   XCTAssertEqual([writer count], (NSUInteger)4);

   [logger_ logAssert:@"ouch"];  // should drop "ack"
   XCTAssertEqual([countingWriter_ count], (NSUInteger)4);

   [self compareWriter:countingWriter_
         withExpectedLogging:[NSArray arrayWithObjects:@"oop", @"blargh",
                                      @"flong", @"ouch", nil]
                  line:__LINE__];


   // Try with more than one wrap around.
   [countingWriter_ reset];
   [logger_ logInfo:@"ack"];
   [logger_ logDebug:@"oop"];
   [logger_ logDebug:@"blargh"];
   [logger_ logDebug:@"flong"];  // Fills buffer
   [logger_ logDebug:@"bloogie"];  // should drop "ack"
   XCTAssertEqual([writer droppedLogCount], (NSUInteger)1);
   XCTAssertEqual([writer count], (NSUInteger)4);

   [logger_ logAssert:@"ouch"];  // should drop "oop"
   XCTAssertEqual([countingWriter_ count], (NSUInteger)4);

   [self compareWriter:countingWriter_
         withExpectedLogging:[NSArray arrayWithObjects:@"blargh",
                                      @"flong", @"bloogie", @"ouch", nil]
                  line:__LINE__];
 }  // testBasics


 - (void)testCornerCases {
   // make sure we work with small buffer sizes.

   GTMLoggerRingBufferWriter *writer =
     [GTMLoggerRingBufferWriter ringBufferWriterWithCapacity:1
                                                      writer:countingWriter_];
   [logger_ setWriter:writer];

   [logger_ logInfo:@"ack"];
   XCTAssertEqual([countingWriter_ count], (NSUInteger)0);
   XCTAssertEqual([writer count], (NSUInteger)1);
   [writer dumpContents];
   XCTAssertEqual([countingWriter_ count], (NSUInteger)1);

   [self compareWriter:countingWriter_
         withExpectedLogging:[NSArray arrayWithObject:@"ack"]
                  line:__LINE__];

   [logger_ logDebug:@"oop"];  // should drop "ack"
   XCTAssertEqual([writer count], (NSUInteger)1);
   XCTAssertEqual([writer droppedLogCount], (NSUInteger)1);

   [countingWriter_ reset];
   [logger_ logError:@"snoogy"];  // should drop "oop"
   XCTAssertEqual([countingWriter_ count], (NSUInteger)1);

   [self compareWriter:countingWriter_
   withExpectedLogging:[NSArray arrayWithObjects:@"snoogy", nil]
                  line:__LINE__];

 }  // testCornerCases


 // Run 10 threads, all logging through the same logger.

 static volatile NSUInteger gStoppedThreads = 0; // Total number that have stopped.

 - (void)bangMe:(id)info {
   NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

   GTMLogger *logger = (GTMLogger *)info;

   // Log a string.
   for (int i = 0; i < 27; i++) {
     [logger logDebug:@"oop"];
   }

   // log another string which should push the first string out.
   // if we see any "oop"s in the logger output, then we know it got
   // confused.
   for (int i = 0; i < 15; i++) {
     [logger logDebug:@"ack"];
   }

   [pool release];
   @synchronized ([self class]) {
     gStoppedThreads++;
   }

 }  // bangMe


 - (void)testThreading {
   const NSUInteger kThreadCount = 10;
   const NSUInteger kCapacity = 10;

   GTMLoggerRingBufferWriter *writer =
     [GTMLoggerRingBufferWriter ringBufferWriterWithCapacity:kCapacity
                                                      writer:countingWriter_];
   [logger_ setWriter:writer];

   for (NSUInteger i = 0; i < kThreadCount; i++) {
     [NSThread detachNewThreadSelector:@selector(bangMe:)
                              toTarget:self
                            withObject:logger_];
   }

   // The threads are running, so wait for them all to finish.
   while (1) {
     NSDate *quick = [NSDate dateWithTimeIntervalSinceNow:0.2];
     [[NSRunLoop currentRunLoop] runUntilDate:quick];
     @synchronized ([self class]) {
       if (gStoppedThreads == kThreadCount) break;
     }
   }

   // Now make sure we get back what's expected.
   XCTAssertEqual([writer count], kThreadCount);
   XCTAssertEqual([countingWriter_ count], (NSUInteger)0);  // Nothing should be logged
   XCTAssertEqual([writer totalLogged], (NSUInteger)420);

   [logger_ logError:@"bork"];
   XCTAssertEqual([countingWriter_ count], kCapacity);

   NSArray *expected = [NSArray arrayWithObjects:
                        @"ack", @"ack", @"ack", @"ack", @"ack",
                        @"ack", @"ack", @"ack", @"ack", @"bork",
                        nil];
   [self compareWriter:countingWriter_
   withExpectedLogging:expected
                  line:__LINE__];

 }  // testThreading

 @end  // GTMLoggerRingBufferWriterTest
	//
	// GTMLoggerRingBufferWriterTest.m
	//
	// Copyright 2007-2008 Google Inc.
	//
	// Licensed 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.
	//

	#import "GTMSenTestCase.h"
	#import "GTMLoggerRingBufferWriter.h"
	#import "GTMLogger.h"

	// --------------------------------------------------
	// CountingWriter keeps a count of the number of times it has been
	// told to write something, and also keeps track of what it was
	// asked to log.

	@interface CountingWriter : NSObject<GTMLogWriter> {
	@private
	NSMutableArray *loggedContents_;
	}

	- (NSUInteger)count;
	- (NSArray *)loggedContents;
	- (void)reset;

	@end // CountingWriter

	@implementation CountingWriter
	- (void)logMessage:(NSString *)msg level:(GTMLoggerLevel)level {
	if (!loggedContents_) {
	loggedContents_ = [[NSMutableArray alloc] init];
	}
	[loggedContents_ addObject:msg];
	} // logMessage

	- (void)dealloc {
	[loggedContents_ release];
	[super dealloc];
	} // dealloc

	- (void)reset {
	[loggedContents_ release];
	loggedContents_ = nil;
	} // reset

	- (NSUInteger)count {
	return [loggedContents_ count];
	} // count

	- (NSArray *)loggedContents {
	return loggedContents_;
	} // loggedContents

	@end // CountingWriter


	@interface GTMLoggerRingBufferWriterTest : GTMTestCase {
	@private
	GTMLogger *logger_;
	CountingWriter *countingWriter_;
	}
	@end // GTMLoggerRingBufferWriterTest


	// --------------------------------------------------

	@implementation GTMLoggerRingBufferWriterTest

	// Utilty to compare the set of messages captured by a CountingWriter
	// with an array of expected messages. The messages are expected to
	// be in the same order in both places.

	- (void)compareWriter:(CountingWriter *)writer
	withExpectedLogging:(NSArray *)expected
	line:(int)line {
	NSArray *loggedContents = [writer loggedContents];

	XCTAssertEqual([expected count], [loggedContents count],
	@"count mismatch from line %d", line);

	for (unsigned int i = 0; i < [expected count]; i++) {
	XCTAssertEqualObjects([expected objectAtIndex:i],
	[loggedContents objectAtIndex:i],
	@"logging mistmatch at index %d from line %d",
	i, line);
	}

	} // compareWithExpectedLogging


	- (void)setUp {
	countingWriter_ = [[CountingWriter alloc] init];
	logger_ = [[GTMLogger alloc] init];
	} // setUp


	- (void)tearDown {
	[countingWriter_ release];
	[logger_ release];
	} // tearDown


	- (void)testCreation {

	// Make sure initializers work.
	GTMLoggerRingBufferWriter *writer =
	[GTMLoggerRingBufferWriter ringBufferWriterWithCapacity:32
	writer:countingWriter_];
	XCTAssertEqual([writer capacity], (NSUInteger)32);
	XCTAssertTrue([writer writer] == countingWriter_);
	XCTAssertEqual([writer count], (NSUInteger)0);
	XCTAssertEqual([writer droppedLogCount], (NSUInteger)0);
	XCTAssertEqual([writer totalLogged], (NSUInteger)0);

	// Try with invalid arguments. Should always get nil back.
	writer =
	[GTMLoggerRingBufferWriter ringBufferWriterWithCapacity:0
	writer:countingWriter_];
	XCTAssertNil(writer);

	writer = [GTMLoggerRingBufferWriter ringBufferWriterWithCapacity:32
	writer:nil];
	XCTAssertNil(writer);

	writer = [[GTMLoggerRingBufferWriter alloc] init];
	XCTAssertNil(writer);

	} // testCreation


	- (void)testLogging {
	GTMLoggerRingBufferWriter *writer =
	[GTMLoggerRingBufferWriter ringBufferWriterWithCapacity:4
	writer:countingWriter_];
	[logger_ setWriter:writer];

	// Shouldn't do anything if there are no contents.
	[writer dumpContents];
	XCTAssertEqual([writer count], (NSUInteger)0);
	XCTAssertEqual([countingWriter_ count], (NSUInteger)0);

	// Log a single item. Make sure the counts are accurate.
	[logger_ logDebug:@"oop"];
	XCTAssertEqual([writer count], (NSUInteger)1);
	XCTAssertEqual([writer totalLogged], (NSUInteger)1);
	XCTAssertEqual([writer droppedLogCount], (NSUInteger)0);
	XCTAssertEqual([countingWriter_ count], (NSUInteger)0);

	// Log a second item. Also make sure counts are accurate.
	[logger_ logDebug:@"ack"];
	XCTAssertEqual([writer count], (NSUInteger)2);
	XCTAssertEqual([writer totalLogged], (NSUInteger)2);
	XCTAssertEqual([writer droppedLogCount], (NSUInteger)0);
	XCTAssertEqual([countingWriter_ count], (NSUInteger)0);

	// Print them, and make sure the countingWriter sees the right stuff.
	[writer dumpContents];
	XCTAssertEqual([countingWriter_ count], (NSUInteger)2);
	XCTAssertEqual([writer count], (NSUInteger)2); // Should not be zeroed.
	XCTAssertEqual([writer totalLogged], (NSUInteger)2);

	[self compareWriter:countingWriter_
	withExpectedLogging:[NSArray arrayWithObjects:@"oop",@"ack", nil]
	line:__LINE__];


	// Wipe the slates clean.
	[writer reset];
	[countingWriter_ reset];
	XCTAssertEqual([writer count], (NSUInteger)0);
	XCTAssertEqual([writer totalLogged], (NSUInteger)0);

	// An error log level should print the buffer and empty it.
	[logger_ logDebug:@"oop"];
	[logger_ logInfo:@"ack"];
	XCTAssertEqual([writer droppedLogCount], (NSUInteger)0);
	XCTAssertEqual([writer totalLogged], (NSUInteger)2);

	[logger_ logError:@"blargh"];
	XCTAssertEqual([countingWriter_ count], (NSUInteger)3);
	XCTAssertEqual([writer droppedLogCount], (NSUInteger)0);

	[self compareWriter:countingWriter_
	withExpectedLogging:[NSArray arrayWithObjects:@"oop", @"ack",
	@"blargh", nil]
	line:__LINE__];


	// An assert log level should do the same. This also fills the
	// buffer to its limit without wrapping.
	[countingWriter_ reset];
	[logger_ logDebug:@"oop"];
	[logger_ logInfo:@"ack"];
	[logger_ logDebug:@"blargh"];
	XCTAssertEqual([writer droppedLogCount], (NSUInteger)0);
	XCTAssertEqual([writer count], (NSUInteger)3);
	XCTAssertEqual([writer totalLogged], (NSUInteger)3);

	[logger_ logAssert:@"ouch"];
	XCTAssertEqual([countingWriter_ count], (NSUInteger)4);
	XCTAssertEqual([writer droppedLogCount], (NSUInteger)0);
	[self compareWriter:countingWriter_
	withExpectedLogging:[NSArray arrayWithObjects:@"oop", @"ack",
	@"blargh", @"ouch", nil]
	line:__LINE__];


	// Try with exactly one wrap around.
	[countingWriter_ reset];
	[logger_ logInfo:@"ack"];
	[logger_ logDebug:@"oop"];
	[logger_ logDebug:@"blargh"];
	[logger_ logDebug:@"flong"]; // Fills buffer
	XCTAssertEqual([writer droppedLogCount], (NSUInteger)0);
	XCTAssertEqual([writer count], (NSUInteger)4);

	[logger_ logAssert:@"ouch"]; // should drop "ack"
	XCTAssertEqual([countingWriter_ count], (NSUInteger)4);

	[self compareWriter:countingWriter_
	withExpectedLogging:[NSArray arrayWithObjects:@"oop", @"blargh",
	@"flong", @"ouch", nil]
	line:__LINE__];


	// Try with more than one wrap around.
	[countingWriter_ reset];
	[logger_ logInfo:@"ack"];
	[logger_ logDebug:@"oop"];
	[logger_ logDebug:@"blargh"];
	[logger_ logDebug:@"flong"]; // Fills buffer
	[logger_ logDebug:@"bloogie"]; // should drop "ack"
	XCTAssertEqual([writer droppedLogCount], (NSUInteger)1);
	XCTAssertEqual([writer count], (NSUInteger)4);

	[logger_ logAssert:@"ouch"]; // should drop "oop"
	XCTAssertEqual([countingWriter_ count], (NSUInteger)4);

	[self compareWriter:countingWriter_
	withExpectedLogging:[NSArray arrayWithObjects:@"blargh",
	@"flong", @"bloogie", @"ouch", nil]
	line:__LINE__];
	} // testBasics


	- (void)testCornerCases {
	// make sure we work with small buffer sizes.

	GTMLoggerRingBufferWriter *writer =
	[GTMLoggerRingBufferWriter ringBufferWriterWithCapacity:1
	writer:countingWriter_];
	[logger_ setWriter:writer];

	[logger_ logInfo:@"ack"];
	XCTAssertEqual([countingWriter_ count], (NSUInteger)0);
	XCTAssertEqual([writer count], (NSUInteger)1);
	[writer dumpContents];
	XCTAssertEqual([countingWriter_ count], (NSUInteger)1);

	[self compareWriter:countingWriter_
	withExpectedLogging:[NSArray arrayWithObject:@"ack"]
	line:__LINE__];

	[logger_ logDebug:@"oop"]; // should drop "ack"
	XCTAssertEqual([writer count], (NSUInteger)1);
	XCTAssertEqual([writer droppedLogCount], (NSUInteger)1);

	[countingWriter_ reset];
	[logger_ logError:@"snoogy"]; // should drop "oop"
	XCTAssertEqual([countingWriter_ count], (NSUInteger)1);

	[self compareWriter:countingWriter_
	withExpectedLogging:[NSArray arrayWithObjects:@"snoogy", nil]
	line:__LINE__];

	} // testCornerCases



	// Run 10 threads, all logging through the same logger.

	static volatile NSUInteger gStoppedThreads = 0; // Total number that have stopped.

	- (void)bangMe:(id)info {
	NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

	GTMLogger logger = (GTMLogger )info;

	// Log a string.
	for (int i = 0; i < 27; i++) {
	[logger logDebug:@"oop"];
	}

	// log another string which should push the first string out.
	// if we see any "oop"s in the logger output, then we know it got
	// confused.
	for (int i = 0; i < 15; i++) {
	[logger logDebug:@"ack"];
	}

	[pool release];
	@synchronized ([self class]) {
	gStoppedThreads++;
	}

	} // bangMe


	- (void)testThreading {
	const NSUInteger kThreadCount = 10;
	const NSUInteger kCapacity = 10;

	GTMLoggerRingBufferWriter *writer =
	[GTMLoggerRingBufferWriter ringBufferWriterWithCapacity:kCapacity
	writer:countingWriter_];
	[logger_ setWriter:writer];

	for (NSUInteger i = 0; i < kThreadCount; i++) {
	[NSThread detachNewThreadSelector:@selector(bangMe:)
	toTarget:self
	withObject:logger_];
	}

	// The threads are running, so wait for them all to finish.
	while (1) {
	NSDate *quick = [NSDate dateWithTimeIntervalSinceNow:0.2];
	[[NSRunLoop currentRunLoop] runUntilDate:quick];
	@synchronized ([self class]) {
	if (gStoppedThreads == kThreadCount) break;
	}
	}

	// Now make sure we get back what's expected.
	XCTAssertEqual([writer count], kThreadCount);
	XCTAssertEqual([countingWriter_ count], (NSUInteger)0); // Nothing should be logged
	XCTAssertEqual([writer totalLogged], (NSUInteger)420);

	[logger_ logError:@"bork"];
	XCTAssertEqual([countingWriter_ count], kCapacity);

	NSArray *expected = [NSArray arrayWithObjects:
	@"ack", @"ack", @"ack", @"ack", @"ack",
	@"ack", @"ack", @"ack", @"ack", @"bork",
	nil];
	[self compareWriter:countingWriter_
	withExpectedLogging:expected
	line:__LINE__];

	} // testThreading

	@end // GTMLoggerRingBufferWriterTest