/// <summary>
/// Show log profiles settings in the UI
/// </summary>
/// <param name="profile">log profile</param>
void IUserInterface.ShowNewProfileSettings(LogProfile profile)
{
Trace("ShowNewProfileSettings");
foreach (DataGridViewRow row in this.parameterGrid.Rows)
{
row.Cells[(int)GridColumns.Enabled].Value = false;
foreach (LogColumn column in profile.Columns)
{
Parameter parameter = column.Parameter;
Parameter rowParameter = (Parameter)row.Cells[(int)GridColumns.Parameter].Value;
if (rowParameter.Id == parameter.Id)
{
row.Cells[(int)GridColumns.Enabled].Value = true;
DataGridViewComboBoxCell cell = (DataGridViewComboBoxCell)row.Cells[(int)GridColumns.Conversions];
Conversion selectedConversion = profile.GetConversions(parameter)[0];
string selectedUnits = selectedConversion.Units;
foreach (Conversion conversion in cell.Items)
{
if (conversion.Units == selectedUnits)
{
cell.Value = conversion;
}
}
}
}
}
}
public void LoggerManualLoggingChangeProfile()
{
ManualLoggingTest(delegate(ParameterDatabase database)
{
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(0.1));
int entriesBefore = this.logEntryCalls;
LogProfile newProfile = LogProfile.CreateInstance();
foreach (SsmParameter parameter in database.Parameters)
{
switch (parameter.Name)
{
case "Injector Duty Cycle":
case "Manifold Rel. Pressure (Corrected)":
newProfile.Add(parameter, parameter.Conversions[0]);
break;
}
}
this.logger.SetProfile(newProfile, database);
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(0.5));
int entriesAfter = this.logEntryCalls;
this.logEntryCallsAfterChange = entriesAfter - entriesBefore;
});
Console.WriteLine("LogEntry calls: " + this.logEntryCalls);
Assert.AreEqual(2, this.logStartCalls, "LogStart calls");
Assert.IsTrue(this.logEntryCalls > 1, "LogEntry calls > 1");
Assert.IsTrue(this.logEntryCallsAfterChange > 3, "LogEntry calls after change");
Assert.AreEqual(2, this.logEndCalls, "LogEnd calls");
Assert.AreEqual(0, this.logErrorCalls, "LogError calls");
}
/// <summary>
/// Get log profile settings from the UI
/// </summary>
/// <param name="profile">log profile</param>
void IUserInterface.GetNewProfileSettings(LogProfile profile)
{
Trace("MainForm.GetNewProfileSettings");
foreach (DataGridViewRow row in this.parameterGrid.Rows)
{
if ((bool)row.Cells[(int)GridColumns.Enabled].Value)
{
DataGridViewComboBoxCell conversionCell = (DataGridViewComboBoxCell)row.Cells[(int)GridColumns.Conversions];
Conversion conversion = null;
foreach (Conversion candidate in conversionCell.Items)
{
// The cell.Value can be a string. WTF?
if ((candidate.Units == conversionCell.Value as string) ||
(candidate == conversionCell.Value as Conversion))
{
conversion = candidate;
break;
}
}
if (conversion != null)
{
Parameter parameter = (Parameter)row.Cells[(int)GridColumns.Parameter].Value;
profile.Add(parameter, conversion);
}
else
{
// TODO: apologize to user?
}
}
}
}
private void LoadProfile(string newProfilePath)
{
Trace("Lumberjack.LoadProfile");
if (string.IsNullOrEmpty(newProfilePath))
{
return;
}
this.ui.Invoke(delegate
{
try
{
LogProfile newProfile = LogProfile.Load(newProfilePath, this.database);
this.logger.SetProfile(newProfile);
this.Settings.LastProfilePath = newProfilePath;
this.Settings.Save();
Trace("Lumberjack.ContinueLoadProfile: setting ignore");
this.ignoreProfileSettingsChangeNotifications = true;
this.ShowNewProfileSettings();
this.ignoreProfileSettingsChangeNotifications = false;
Trace("Lumberjack.ContinueLoadProfile: clearing ignore");
this.ui.SetSaveButtonState(true);
this.currentProfileIsChanged = false;
this.SetTitle();
this.logger.StartLogging();
}
catch (Exception exception)
{
Trace("Exception thrown during ContinueLoadProfile on UI thread");
Trace(exception.ToString());
}
});
}
/// <summary>
/// Create a log profile from the application's configuration settings
/// </summary>
private LogProfile CreateLogProfile()
{
Trace.WriteLine("CreateLogProfile");
LogProfile profile = LogProfile.CreateInstance();
for (int i = 0; i < 6; i++)
{
string combined = ConfigurationManager.AppSettings[i.ToString()];
string[] idAndUnits = combined.Split(',');
if (idAndUnits.Length != 2)
{
throw new ApplicationException("Parameter " + i.ToString() +
"is not of the form \"P12,units\"." + Environment.NewLine +
"Please fix this in TreeHugger.exe.config and try again");
}
string id = idAndUnits[0];
string units = idAndUnits[1];
this.AddParameter(profile, id, units);
}
return(profile);
}
static void ManualLoggingTest(Stream ecuStream, SerialPort port)
{
SsmLogger logger = SsmLogger.GetInstance(Environment.CurrentDirectory, ecuStream);
IAsyncResult asyncResult = logger.BeginConnect(ConnectCallback, logger);
asyncResult.AsyncWaitHandle.WaitOne();
LogProfile profile = LogProfile.GetInstance();
foreach (SsmParameter parameter in logger.Database.Parameters)
{
switch (parameter.Name)
{
case "Engine Load":
case "Manifold Relative Pressure":
case "Engine Speed":
profile.Add(parameter, parameter.Conversions[0]);
break;
}
}
logger.SetProfile(profile);
logger.LogStart += LogStart;
logger.LogEntry += LogEntry;
logger.LogStop += LogEnd;
logger.StartLogging();
for (int i = 0; i < 100000 && !Console.KeyAvailable; i++)
{
Thread.Sleep(1);
}
logger.StopLogging();
Thread.Sleep(500);
}
public void LoggerAddressesDuplicates()
{
this.logger = SsmLogger.GetInstance(Environment.CurrentDirectory, MockEcuStream.PortName);
IAsyncResult result = logger.BeginConnect(null, null);
result.AsyncWaitHandle.WaitOne();
ParameterSource source = logger.EndConnect(result);
ParameterDatabase database = ParameterDatabase.GetInstance();
database.Add(source);
LogProfile profile = LogProfile.CreateInstance();
Parameter parameter;
database.TryGetParameterById("P8", out parameter);
profile.Add(parameter, parameter.Conversions[0]);
database.TryGetParameterById("P201", out parameter);
profile.Add(parameter, parameter.Conversions[0]);
database.TryGetParameterById("P202", out parameter);
profile.Add(parameter, parameter.Conversions[0]);
database.TryGetParameterById("P7", out parameter);
profile.Add(parameter, parameter.Conversions[0]);
this.logger.SetProfile(profile, database);
List <int> addresses = this.logger.Addresses;
Assert.AreEqual(5, addresses.Count);
int[] expected = new int[] { 14, 15, 13, 32, 35 };
Utility.CompareArrays("Address arrays", expected, addresses.ToArray());
}
public void BasicLoggerAddressesDuplicates()
{
MockEcuStream stream = MockEcuStream.CreateInstance();
this.logger = SsmBasicLogger.GetInstance(Environment.CurrentDirectory, stream);
IAsyncResult result = logger.BeginConnect(null, null);
result.AsyncWaitHandle.WaitOne();
ParameterSource source = logger.EndConnect(result);
ParameterDatabase database = ParameterDatabase.GetInstance();
database.Add(source);
LogProfile profile = LogProfile.CreateInstance();
Parameter parameter;
database.TryGetParameterById("P8", out parameter); // engine speed (14)
profile.Add(parameter, parameter.Conversions[0]);
database.TryGetParameterById("P201", out parameter); // IDC, requires engine speed (14), IPW (32)
profile.Add(parameter, parameter.Conversions[0]);
database.TryGetParameterById("P202", out parameter); // MRP(corrected), requires MAP (13), Atmo (35)
profile.Add(parameter, parameter.Conversions[0]);
database.TryGetParameterById("P7", out parameter); // MAP (13)
profile.Add(parameter, parameter.Conversions[0]);
// IPW is not in the resulting set of addresses, why?
this.logger.SetProfile(profile, database);
List <int> addresses = this.logger.Addresses;
Assert.AreEqual(5, addresses.Count);
int[] expected = new int[] { 14, 15, 13, 32, 35 };
Utility.CompareArrays("Address arrays", expected, addresses.ToArray());
}
/// <summary>
/// Call this after the user has changed the set of parameters to log.
/// </summary>
public void SelectedProfileSettingsChanged()
{
if (this.logger == null)
{
Trace("Lumberjack.SelectedProfileSettingsChanged: this.logger is null - assuming this is startup time");
return;
}
if (this.ignoreProfileSettingsChangeNotifications)
{
Trace("Lumberjack.SelectedProfileSettingsChanged: ignoring");
return;
}
Trace("Lumberjack.SelectedProfileSettingsChanged: creating new profile");
LogProfile profile = LogProfile.CreateInstance();
this.ui.GetNewProfileSettings(profile);
this.ui.SetSaveButtonState(true);
this.logger.SetProfile(profile);
this.logger.StartLogging();
this.currentProfileIsChanged = true;
this.SetTitle();
}
/// <summary>
/// Switch to a new screen
/// </summary>
public void SetCurrentScreen(SawMillScreen screen)
{
this.currentScreen = screen;
LogProfile profile = this.GenerateProfile();
profile.UserData = this.currentScreen;
this.logger.SetProfile(profile, this.database);
}
/// <summary>
/// Start logging
/// </summary>
private void StartLogging()
{
LogProfile profile = this.CreateLogProfile();
this.logger.SetProfile(profile, database);
if (this.powerOn)
{
this.logger.StartLogging();
}
}
public void AddLogProfile(string name, Guid globalId, Person owner)
{
var logProfile = new LogProfile
{
Name = name,
GlobalId = globalId,
Person = owner
};
_dbContext.LogProfiles.Add(logProfile);
}
public void LoggerSuspendResume()
{
this.logger = SsmLogger.GetInstance(Environment.CurrentDirectory, MockEcuStream.PortName);
IAsyncResult result = logger.BeginConnect(null, null);
result.AsyncWaitHandle.WaitOne();
ParameterSource source = logger.EndConnect(result);
ParameterDatabase database = ParameterDatabase.GetInstance();
database.Add(source);
LogProfile profile = LogProfile.CreateInstance();
foreach (SsmParameter parameter in database.Parameters)
{
profile.Add(parameter, parameter.Conversions[0]);
if (profile.Columns.Count > 3)
{
break;
}
}
this.logStartCalls = 0;
this.logEntryCalls = 0;
this.logEndCalls = 0;
this.logErrorCalls = 0;
this.logger.SetProfile(profile, database);
this.logger.LogStart += this.LogStart;
this.logger.LogEntry += this.LogEntry;
this.logger.LogStop += this.LogStop;
this.logger.LogError += this.LogError;
this.logger.StartLogging();
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(0.25));
this.logger.Suspend();
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(0.25));
int entriesBeforeSuspend = this.logEntryCalls;
Debug.WriteLine("Entries before suspend: " + entriesBeforeSuspend.ToString());
this.logger.Resume(TimeSpan.FromMilliseconds(250));
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(0.5));
int entriesAfterSuspend = this.logEntryCalls;
Debug.WriteLine("Entries after suspend: " + entriesAfterSuspend.ToString());
this.logger.BeginStopLogging(NoOp, null);
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(0.1));
Assert.IsTrue(entriesAfterSuspend > entriesBeforeSuspend, "Resumed logging after suspend/resume.");
}
public void BasicLoggerDependencyConversions()
{
MockEcuStream stream = MockEcuStream.CreateInstance();
this.logger = SsmBasicLogger.GetInstance(Environment.CurrentDirectory, stream);
IAsyncResult result = logger.BeginConnect(null, null);
result.AsyncWaitHandle.WaitOne();
ParameterSource source = logger.EndConnect(result);
ParameterDatabase database = ParameterDatabase.GetInstance();
database.Add(source);
LogProfile baseParameters = LogProfile.CreateInstance();
foreach (SsmParameter parameter in database.Parameters)
{
if (parameter.Id == "P201")
{
baseParameters.Add(parameter, parameter.Conversions[0]);
}
if (parameter.Id == "P202")
{
baseParameters.Add(parameter, parameter.Conversions[0]);
break;
}
}
this.logger.SetProfile(baseParameters, database);
LogEventArgs args = this.logger.GetOneRow();
Utility.AssertColumnParameterId(args, 0, "P201");
Utility.AssertColumnParameterId(args, 1, "P202");
Utility.AssertColumnParameterId(args, 2, "P8");
Utility.AssertColumnParameterId(args, 3, "P21");
Utility.AssertColumnParameterId(args, 4, "P7");
Utility.AssertColumnParameterId(args, 5, "P24");
Assert.AreEqual(6, args.Row.Columns.Count);
List <int> addresses = this.logger.Addresses;
Assert.AreEqual(5, addresses.Count);
int[] expected = new int[] { 14, 15, 32, 13, 35 };
Utility.CompareArrays("Address arrays", expected, addresses.ToArray());
// Values from observation...
Assert.AreEqual("2.08", args.Row.Columns[0].ValueAsString);
Assert.AreEqual("1.02", args.Row.Columns[1].ValueAsString);
}
public void InternalLogProfileNoParameters()
{
ParameterDatabase database = ParameterDatabase.GetInstance();
MockParameterSource source = new MockParameterSource();
database.Add(source);
LogProfile publicProfile = LogProfile.CreateInstance();
InternalLogProfile internalProfile = InternalLogProfile.GetInstance(publicProfile, database);
Assert.AreEqual(0, internalProfile.Addresses.Count);
}
private static void AreEqual(LogProfile exp, LogProfile act)
{
if (exp != null)
{
CompareListString(exp.Categories, act.Categories);
CompareListString(exp.Locations, act.Locations);
Assert.Equal(exp.RetentionPolicy.Enabled, act.RetentionPolicy.Enabled);
Assert.Equal(exp.RetentionPolicy.Days, act.RetentionPolicy.Days);
Assert.Equal(exp.ServiceBusRuleId, act.ServiceBusRuleId);
Assert.Equal(exp.StorageAccountId, act.StorageAccountId);
}
}
/// <summary>
/// Call this when the user wants to create a new profile.
/// </summary>
public void ProfileNew()
{
Trace("Lumberjack.ProfileNew");
LogProfile empty = LogProfile.CreateInstance();
this.logger.SetProfile(empty);
this.Settings.LastProfilePath = null;
this.ShowNewProfileSettings();
this.ui.SelectProfile(null);
this.ui.SetSaveButtonState(false);
this.currentProfileIsChanged = false;
this.SetTitle();
}
/// <summary>
/// Initializes a new instance of the <see cref="PSLogProfile"/> class.
/// </summary>
public PSLogProfile(string id, string name, LogProfile logProfile)
{
this.Id = id;
this.Name = name;
this.Categories = logProfile.Categories.Select(x => x).ToList();
this.Locations = logProfile.Locations.Select(x => x).ToList();
this.RetentionPolicy = new RetentionPolicy()
{
Days = logProfile.RetentionPolicy.Days,
Enabled = logProfile.RetentionPolicy.Enabled
};
this.ServiceBusRuleId = logProfile.ServiceBusRuleId;
this.StorageAccountId = logProfile.StorageAccountId;
}
public void InternalLogProfileMockParameters()
{
ParameterDatabase database = ParameterDatabase.GetInstance();
MockParameterSource source = new MockParameterSource();
database.Add(source);
LogProfile publicProfile = LogProfile.CreateInstance();
publicProfile.Add(database.Parameters[0], database.Parameters[0].Conversions[0]);
publicProfile.Add(database.Parameters[1], database.Parameters[1].Conversions[0]);
InternalLogProfile internalProfile = InternalLogProfile.GetInstance(publicProfile, database);
Assert.AreEqual(0, internalProfile.Addresses.Count);
Assert.AreEqual(2, internalProfile.LogEventArgs.Row.Columns.Count);
}
/// <summary>
/// Second half of LoadSelectedProfile
/// </summary>
private void ContinueLoadSelectedProfile(IAsyncResult asyncResult)
{
Trace("Lumberjack.ContinueLoadSelectedProfile");
string profilePath = (string)asyncResult.AsyncState;
this.ui.Invoke(delegate
{
Trace("Lumberjack.ContinueLoadSelectedProfile (UI thread)");
LogProfile profile;
if (profilePath == null)
{
Trace("Lumberjack.ContinueLoadSelectedProfile: creating trivial profile");
profile = LogProfile.CreateInstance();
/* foreach (SsmParameter parameter in this.logger.Database.Parameters)
* {
* // Add the RPM parameter and nothing else.
* if (parameter.Id == "P8")
* {
* profile.Add(parameter, parameter.Conversions[0]);
* break;
* }
* }
*/
}
else
{
Trace("Lumberjack.ContinueLoadSelectedProfile: loading " + profilePath);
profile = LogProfile.Load(profilePath, this.database);
}
this.logger.SetProfile(profile);
this.logger.StartLogging();
this.Settings.LastProfilePath = profilePath;
this.Settings.Save();
this.ignoreProfileSettingsChangeNotifications = true;
this.ui.ShowNewProfileSettings(this.logger.CurrentProfile);
this.ui.SelectProfile(this.Settings.LastProfilePath);
this.ignoreProfileSettingsChangeNotifications = false;
this.currentProfileIsChanged = false;
this.ui.SetSaveButtonState(true);
this.SetTitle();
});
}
public void AddLogProfile(string name, Guid globalId, string email)
{
var person = _dbContext.People.Include(l => l.LogProfiles).FirstOrDefault(p => p.Email == email);
if (person == null || person.LogProfiles.Any(lp => lp.Name == name))
{
throw new ArgumentException("error creating logprofile");
}
var logProfile = new LogProfile
{
Name = name,
GlobalId = globalId,
Person = person
};
_dbContext.LogProfiles.Add(logProfile);
}
/* internal static void CompareArrays<T>(T[] expected, T[] actual)
* {
* Assert.AreEqual(expected.Length, actual.Length, "Packet length");
* for (int i = 0; i < expected.Length; i++)
* {
* Assert.AreEqual(expected[i], actual[i], "Offset[" + i.ToString() + "]");
* }
* }*/
internal static void AssertContains(LogProfile profile, string parameterId, string conversionUnits)
{
foreach (LogColumn column in profile.Columns)
{
if (column.Parameter.Id == parameterId)
{
IList <Conversion> conversions = profile.GetConversions(column.Parameter);
foreach (Conversion conversion in conversions)
{
if (conversion.Units == conversionUnits)
{
return;
}
}
}
}
Assert.Fail("Selected parameters does not contain " + parameterId + " / " + conversionUnits);
}
private LogProfile GenerateProfile()
{
LogProfile profile = LogProfile.CreateInstance();
this.AddScreenParameters(profile, this.currentScreen);
foreach (SawMillScreen screen in this.screens)
{
if ((screen.ForegroundOnly) || (screen == this.currentScreen))
{
continue;
}
AddScreenParameters(profile, screen);
}
profile.Add("P200", "g/rev", this.database);
return(profile);
}
private void AddGlocoseLevel(LogMessage logMessage, LogProfile logProfile)
{
if (logMessage.Value <= 0)
{
return;
}
var newLogId = Guid.NewGuid();
var glucoseLevel = new GlucoseLevel
{
LogDate = logMessage.LogDate,
Message = logMessage.Message,
Value = logMessage.Value,
GlobalId = newLogId,
LogProfile = logProfile
};
_dbContext.GlucoseLevels.Add(glucoseLevel);
logMessage.GlobalId = newLogId;
}
public void ManualLoggingTest(Action <ParameterDatabase> callback)
{
MockEcuStream stream = MockEcuStream.CreateInstance();
FragmentedStream fragStream = FragmentedStream.GetInstance(stream);
this.logger = SsmBasicLogger.GetInstance(Environment.CurrentDirectory, fragStream);
IAsyncResult result = logger.BeginConnect(null, null);
result.AsyncWaitHandle.WaitOne();
ParameterSource source = logger.EndConnect(result);
ParameterDatabase database = ParameterDatabase.GetInstance();
database.Add(source);
LogProfile Profile = LogProfile.CreateInstance();
foreach (SsmParameter parameter in database.Parameters)
{
Profile.Add(parameter, parameter.Conversions[0]);
if (Profile.Columns.Count > 3)
{
break;
}
}
this.logStartCalls = 0;
this.logEntryCalls = 0;
this.logEndCalls = 0;
this.logErrorCalls = 0;
this.logger.SetProfile(Profile, database);
this.logger.LogStart += this.LogStart;
this.logger.LogEntry += this.LogEntry;
this.logger.LogStop += this.LogStop;
this.logger.LogError += this.LogError;
this.logger.StartLogging();
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(0.25));
callback(database);
this.logger.BeginStopLogging(NoOp, null);
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(0.1));
}
/// <summary>
/// Create a LogProfile, using parameters passed to ctor and the given SsmLogger's database.
/// </summary>
public LogProfile GetProfile(ParameterDatabase database)
{
if (database == null)
{
throw new ArgumentNullException("database");
}
if (this.profile != null)
{
return(this.profile);
}
this.profile = LogProfile.CreateInstance();
foreach (string combined in this.parameters)
{
string[] idAndUnits = combined.Split(',');
if (idAndUnits.Length != 2)
{
continue;
}
string id = idAndUnits[0];
string units = idAndUnits[1];
try
{
profile.Add(id, units, database);
}
catch (ArgumentException)
{
MessageBox.Show("Parameter " + id + " is not supported for your car." + Environment.NewLine +
"The " + this.name + " screen will not work.");
}
}
if (this.profile.UserData != null)
{
System.Diagnostics.Debugger.Break();
}
this.profile.UserData = this;
return(this.profile);
}
private void AddScreenParameters(LogProfile profile, SawMillScreen screen)
{
if (this.database == null)
{
throw new InvalidOperationException("Logger must be connected and database must be initialized before calling AddScreenParameters");
}
LogProfile screenProfile = screen.GetProfile(this.database);
foreach (LogColumn column in screenProfile.Columns)
{
Parameter parameter = column.Parameter;
IList <Conversion> conversions = screenProfile.GetConversions(parameter);
foreach (Conversion conversion in conversions)
{
profile.Add(parameter, conversion);
}
}
}
private void AddFood(LogMessage logMessage, LogProfile logProfile)
{
if (logMessage.Calories <= 0)
{
return;
}
var newFoodId = Guid.NewGuid();
var item = new Food
{
GlobalId = newFoodId,
LogDate = logMessage.LogDate,
LogProfile = logProfile,
Message = logMessage.Message,
Calories = logMessage.Calories,
FoodTypes = logMessage.FoodTypes
};
_dbContext.Foods.Add(item);
}
private void AddTerapy(LogMessage logMessage, LogProfile logProfile)
{
if (logMessage.TerapyValue <= 0)
{
return;
}
var newTerapyId = Guid.NewGuid();
var terapy = new Terapy
{
GlobalId = newTerapyId,
IsSlow = logMessage.IsSlow,
LogDate = logMessage.LogDate,
LogProfile = logProfile,
Message = logMessage.Message,
Value = logMessage.TerapyValue
};
_dbContext.Terapies.Add(terapy);
logMessage.TerapyGlobalId = newTerapyId;
}
public void LoggerUserData()
{
SsmLogger logger = SsmLogger.GetInstance(Environment.CurrentDirectory, MockEcuStream.PortName);
IAsyncResult result = logger.BeginConnect(null, null);
result.AsyncWaitHandle.WaitOne();
ParameterSource source = logger.EndConnect(result);
ParameterDatabase database = ParameterDatabase.GetInstance();
database.Add(source);
LogProfile profile = LogProfile.CreateInstance();
foreach (SsmParameter parameter in database.Parameters)
{
profile.Add(parameter, parameter.Conversions[0]);
if (profile.Columns.Count == 8)
{
break;
}
}
string userData = "UserData";
profile.UserData = userData;
logger.SetProfile(profile, database);
logger.LogStart += this.LoggerUserDataLogStart;
logger.LogEntry += this.LoggerUserDataLogEntry;
logger.LogStop += this.LoggerUserDataLogStop;
logger.StartLogging();
System.Threading.Thread.Sleep(500);
IAsyncResult stopResult = logger.BeginStopLogging(null, null);
stopResult.AsyncWaitHandle.WaitOne();
logger.EndStopLogging(stopResult);
Assert.AreSame(userData, userDataFromLogStart);
Assert.AreSame(userData, userDataFromLogEntry);
Assert.AreSame(userData, userDataFromLogStop);
}
