/// <summary>
/// This routine takes a list of backup file names and a message that will be logged
/// repeatedly, and generates a collection of objects containing pre-condition and
/// post-condition information. This pre/post information shows the names and expected
/// file sizes for all files just before and just after a message is logged.
/// </summary>
/// <param name="sTestMessage">A message to log repeatedly</param>
/// <param name="sBackupInfo">Filename groups used to indicate backup file name progression
/// that results after each message is logged</param>
/// <param name="iMessagesToLog">How many times the test message will be repeatedly logged</param>
/// <param name="evaluator">Function that can turn a number into a filename</param>
/// <returns></returns>
private static RollConditions[] MakeTestEntries(string sTestMessage, string sBackupInfo, int iMessagesToLog, MatchEvaluator evaluator)
{
string sBackupFiles = ConvertToFiles(sBackupInfo, evaluator);
RollConditions[] table = new RollConditions[iMessagesToLog];
RollingStats rollingStats = InitializeStats(sTestMessage);
RollConditions preCondition = null;
rollingStats.MessagesThisFile = 0;
RollFileEntry currentFile = new RollFileEntry(GetCurrentFile(), 0);
for(int i = 0; i < iMessagesToLog; i++)
{
RollFileEntry currentNext = new RollFileEntry(
GetCurrentFile(),
(1 + rollingStats.MessagesThisFile) * rollingStats.TotalMessageLength);
table[i] = BuildTableEntry(sBackupFiles, preCondition, currentFile, currentNext, rollingStats);
preCondition = table[i];
//System.Diagnostics.Debug.WriteLine( "Message " + i );
//DumpTableEntry( table[i] );
currentFile = MoveNextEntry(rollingStats, currentNext);
}
return table;
}
/// <summary>
/// Uses the externally defined rolling table to verify rolling names/sizes
/// </summary>
/// <remarks>
/// Pattern is: check pre-conditions. Log messages, checking size of current file.
/// when size exceeds limit, check post conditions. Can determine from message the
/// number of messages N that will cause a roll to occur. Challenge is to verify the
/// expected files, their sizes, and the names. For a message of length L, the backups
/// will be of size (N * L), and the current file will be of size (K * L), where K is
/// the number of messages that have been logged to this file.
///
/// File sizes can be checked algorithmically.
///
/// File names are generated using a table driven algorithm, where a number is turned into
/// the actual filename.
///
/// The entries are comma-separated, with spaces between the names. Each comma indicates
/// a 'roll', and the group between commas indicates the numbers for all backup files that
/// occur as a result of the roll. It is assumed that no backup files exist before a roll
/// occurs
/// </remarks>
/// <param name="table"></param>
private void VerifyRolling(RollConditions[] table)
{
ConfigureRootAppender();
RollFromTableEntries(c_fileName, table, GetTestMessage());
}
//private void DumpFileEntry( RollFileEntry entry )
//{
// System.Diagnostics.Debug.WriteLine( "\tfile name: " + entry.FileName );
// System.Diagnostics.Debug.WriteLine( "\tfile length: " + entry.FileLength );
//}
//private void DumpTableEntry( RollConditions entry )
//{
// System.Diagnostics.Debug.WriteLine( "Pre-Conditions" );
// foreach( RollFileEntry file in entry.GetPreLogFileEntries() )
// {
// DumpFileEntry( file );
// }
// System.Diagnostics.Debug.WriteLine( "Post-Conditions" );
// foreach( RollFileEntry file in entry.GetPostLogFileEntries() )
// {
// DumpFileEntry( file );
// }
// // System.Diagnostics.Debug.WriteLine("");
//}
/// <summary>
/// Runs through all table entries, logging messages. Before each message is logged,
/// pre-conditions are checked to ensure the expected files exist and they are the
/// expected size. After logging, verifies the same.
/// </summary>
/// <param name="sBaseFileName"></param>
/// <param name="entries"></param>
/// <param name="sMessageToLog"></param>
private void RollFromTableEntries(string sBaseFileName, RollConditions[] entries, string sMessageToLog)
{
for(int i = 0; i < entries.Length; i++)
{
RollConditions entry = entries[i];
// System.Diagnostics.Debug.WriteLine( i + ": Entry " + i + " pre/post conditions");
// DumpTableEntry( entry );
// System.Diagnostics.Debug.WriteLine( i + ": Testing entry pre-conditions");
VerifyPreConditions(sBaseFileName, entry);
// System.Diagnostics.Debug.WriteLine( i + ": Logging message");
LogMessage(entry, sMessageToLog);
// System.Diagnostics.Debug.WriteLine( i + ": Testing entry post-conditions");
VerifyPostConditions(sBaseFileName, entry);
// System.Diagnostics.Debug.WriteLine( i + ": Finished validating entry\n");
}
}
/// <summary>
/// Generates the pre and post condition arrays from an array of backup files and the
/// current file / next file.
/// </summary>
/// <param name="sBackupFiles"></param>
/// <param name="preCondition"></param>
/// <param name="current"></param>
/// <param name="currentNext"></param>
/// <param name="rollingStats"></param>
/// <returns></returns>
private static RollConditions BuildTableEntry(string sBackupFiles, RollConditions preCondition, RollFileEntry current, RollFileEntry currentNext, RollingStats rollingStats)
{
RollFileEntry[] backupsPost = MakeBackupFileEntriesForPostCondition(sBackupFiles, rollingStats);
RollFileEntry[] post = AddFinalElement(backupsPost, currentNext);
if (null == preCondition)
{
return new RollConditions(AddFinalElement(null, current), post);
}
return new RollConditions(preCondition.GetPostLogFileEntries(), post);
}
/// <summary>
/// Logs a message, verifying the expected message counts against the
/// current running totals.
/// </summary>
/// <param name="entry"></param>
/// <param name="sMessageToLog"></param>
private void LogMessage(RollConditions entry, string sMessageToLog)
{
Assert.AreEqual(_caRoot.Counter, _iMessagesLogged++);
_root.Log(Level.Debug, sMessageToLog, null);
Assert.AreEqual(_caRoot.Counter, _iMessagesLogged);
_iMessagesLoggedThisFile++;
}
/// <summary>
/// Called after logging a message to check that all the expected files exist,
/// and only the expected files. Also verifies the length of all files against
/// the expected length
/// </summary>
/// <param name="sBaseFileName"></param>
/// <param name="entry"></param>
private static void VerifyPostConditions(string sBaseFileName, RollConditions entry)
{
VerifyFileConditions(sBaseFileName, entry.GetPostLogFileEntries());
}
private void DumpTableEntry( RollConditions entry )
{
System.Diagnostics.Debug.WriteLine( "Pre-Conditions" );
foreach( RollFileEntry file in entry.GetPreLogFileEntries() )
{
DumpFileEntry( file );
}
System.Diagnostics.Debug.WriteLine( "Post-Conditions" );
foreach( RollFileEntry file in entry.GetPostLogFileEntries() )
{
DumpFileEntry( file );
}
// System.Diagnostics.Debug.WriteLine("");
}
/// <summary>
/// Called before logging a message to check that all the expected files exist,
/// and only the expected files. Also verifies the length of all files against
/// the expected length
/// </summary>
/// <param name="sBaseFileName"></param>
/// <param name="entry"></param>
private void VerifyPreConditions( string sBaseFileName, RollConditions entry )
{
VerifyFileConditions( sBaseFileName, entry.GetPreLogFileEntries() );
}
/// <summary>
/// Called after logging a message to check that all the expected files exist,
/// and only the expected files. Also verifies the length of all files against
/// the expected length
/// </summary>
/// <param name="sBaseFileName"></param>
/// <param name="entry"></param>
private void VerifyPostConditions( string sBaseFileName, RollConditions entry )
{
VerifyFileConditions( sBaseFileName, entry.PostLogFileEntries );
}
