public void MessageIsSetWhenUsingJsonFormatter()
{
LoggingConfiguration loggingConfiguration = BuildProgrammaticConfigForTrace();
JsonLogFormatter jsonformatter = new JsonLogFormatter(JsonFormatting.Indented);
EmailTraceListener emailListener = new EmailTraceListener(this.toaddress,
this.fromaddress,
"StartOfSubject",
"EndOfSubject", this.smtpserver, jsonformatter);
emailListener.Filter = new EventTypeFilter(SourceLevels.All);
loggingConfiguration.AddLogSource("Email", SourceLevels.All, true, emailListener);
loggingConfiguration.SpecialSources.Unprocessed.Listeners.Add(emailListener);
string message = "Test JSON";
this.writer = new LogWriter(loggingConfiguration);
this.writer.Write(message, "General");
this.writer.Dispose();
LogEntry logEntry = LogFileReader.GetLogEntryFromEmail();
Assert.IsTrue(logEntry.Message == message);
}
public void OnlyApplicableEntriesAreWrittenWhenFlatFileCategoryFilter()
{
LoggingConfiguration loggingConfiguration = BuildProgrammaticConfigForTrace();
this.UpdateFlatFileForConfig(loggingConfiguration);
// Category Filters
ICollection <string> categories = new List <string>();
categories.Add("BlockedByFilter");
var categoryFilter = new CategoryFilter("Category Filter", categories, CategoryFilterMode.DenyAllExceptAllowed);
loggingConfiguration.Filters.Add(categoryFilter);
this.writer = new LogWriter(loggingConfiguration);
this.writer.Write("Test Logging1", "General", 1);
this.writer.Write("Test Logging2", "BlockedByFilter", 2);
this.writer.Dispose();
Assert.IsTrue(File.Exists(Path.Combine(this.strPath, "FlatFile.log")));
string strFileData = LogFileReader.ReadFileWithoutLock(Path.Combine(this.strPath, "FlatFile.log"));
Assert.IsFalse(strFileData.Contains("Message: Test Logging1"));
Assert.IsTrue(strFileData.Contains("Message: Test Logging2"));
}
public void JsonFormatterHeadersAreSetWhenSendingEmail()
{
DateTime messageTimestamp = DateTime.UtcNow;
LoggingConfiguration loggingConfiguration = BuildProgrammaticConfigForTrace();
JsonLogFormatter jsonformatter = new JsonLogFormatter(JsonFormatting.Indented);
EmailTraceListener emailListener = new EmailTraceListener(this.toaddress,
this.fromaddress,
"StartOfSubject",
"EndOfSubject", this.smtpserver, jsonformatter);
emailListener.Filter = new EventTypeFilter(SourceLevels.All);
loggingConfiguration.AddLogSource("Email", SourceLevels.All, true, emailListener);
loggingConfiguration.SpecialSources.Unprocessed.Listeners.Add(emailListener);
string message = "Test JSON";
this.writer = new LogWriter(loggingConfiguration);
this.writer.Write(message, "General");
this.writer.Dispose();
string emailText = LogFileReader.GetEmail();
string endOfHeader = "\r\n\r\n";
int index = emailText.IndexOf(endOfHeader);
string header = emailText.Substring(0, index);
Dictionary <string, string> emailDictionary = Regex.Split(header, "\r\n").Select(e => e.Split(':')).ToDictionary(line => line[0], line => line[1].Trim());
Assert.AreEqual("StartOfSubject Information EndOfSubject", emailDictionary["Subject"]);
Assert.AreEqual(this.fromaddress, emailDictionary["From"]);
Assert.AreEqual(this.toaddress, emailDictionary["To"]);
}
public void EntryIsWrittenWhenFlatFileUnprocessedCategory()
{
LoggingConfiguration loggingConfiguration = BuildProgrammaticConfigForTrace();
this.UpdateFlatFileForConfig(loggingConfiguration);
var unprocessedFlatFileTraceListener = new FlatFileTraceListener(
Path.Combine(strPath, "Unprocessed.log"),
"----------------------------------------",
"----------------------------------------",
null);
loggingConfiguration.SpecialSources.Unprocessed.Listeners.Add(unprocessedFlatFileTraceListener);
this.writer = new LogWriter(loggingConfiguration);
this.writer.Write("Test Logging");
this.writer.Dispose();
Assert.IsTrue(File.Exists(Path.Combine(this.strPath, "FlatFile.log")));
Assert.IsTrue(File.Exists(Path.Combine(this.strPath, "Unprocessed.log")));
string strFileData1 = LogFileReader.ReadFileWithoutLock(Path.Combine(this.strPath, "FlatFile.log"));
Assert.IsTrue(strFileData1.Contains("Message: Test Logging"));
Assert.IsTrue(strFileData1.Contains("Category: General"));
string strFileData = LogFileReader.ReadFileWithoutLock((Path.Combine(this.strPath, "Unprocessed.log")));
Assert.IsTrue(strFileData.Contains("Message: Test Logging"));
Assert.IsTrue(strFileData.Contains("Unprocessed Category Information: 1"));
}
public void Export()
{
StringBuilder csv = new StringBuilder();
var telRead = new LogFileReader("Tmp.zip");
var telProvider = telRead.GetProvider(new[] {"Session","Driver 7427264"}, 0, 1000000);
foreach(var sample in telProvider.GetSamples())
{
var me = sample.Get("Driver 7427264");
var sess = sample.Get("Session");
if(me!= null)
csv.AppendLine(sample.Timestamp + "," +
sess.ReadAs<float>("Time") + "," +
me.ReadAs<string>("TyreCompoundFront") + "," +
me.ReadAs<float>("Speed") + "," +
me.ReadAs<float>("Fuel") + "," +
me.ReadAs<float>("InputThrottle") + "," +
me.ReadAs<float>("InputBrake") + "," +
me.ReadAs<float>("TyreTemperatureInsideLF") + "," +
me.ReadAs<float>("RPM") + "," +
me.ReadAs<int>("Gear"));
}
File.WriteAllText("dump.csv", csv.ToString());
}
public void Run()
{
var logFileListener = new LogFileReader();
logFileListener.RegisterListener(GetListener());
NativeApiWrapper.RunGame();
}
public void Export()
{
if (File.Exists("TelemetryLoggerTests_Tmp.zip") == false)
{
Assert.Ignore();
}
StringBuilder csv = new StringBuilder();
var telRead = new LogFileReader("TelemetryLoggerTests_Tmp.zip");
var telProvider = telRead.GetProvider(new[] { "Session", "Driver 7427264" }, 0, 1000000);
foreach (var sample in telProvider.GetSamples())
{
var me = sample.Get("Driver 7427264");
var sess = sample.Get("Session");
if (me != null)
{
csv.AppendLine(sample.Timestamp + "," +
sess.ReadAs <float>("Time") + "," +
me.ReadAs <string>("TyreCompoundFront") + "," +
me.ReadAs <float>("Speed") + "," +
me.ReadAs <float>("Fuel") + "," +
me.ReadAs <float>("InputThrottle") + "," +
me.ReadAs <float>("InputBrake") + "," +
me.ReadAs <float>("TyreTemperatureInsideLF") + "," +
me.ReadAs <float>("RPM") + "," +
me.ReadAs <int>("Gear"));
}
}
File.WriteAllText("dump.csv", csv.ToString());
}
public static BufferHeader Read(LogFileReader reader)
{
BufferHeader result;
long position = reader.Position;
if (!reader.LoadData(48))
{
return(null);
}
try {
result = new BufferHeader(reader);
} catch {
Console.WriteLine("Exception reading buffer at position {0}", position);
throw;
}
if (!reader.LoadData(result.Length))
{
reader.Position = position; // rollback
return(null);
}
return(result);
}
public void FileIsRolledWhenIntervalSetToMidnightAndOverwrite()
{
fileNameWithoutExtension = Guid.NewGuid().ToString();
fileName = fileNameWithoutExtension + Extension;
using (RollingFlatFileTraceListener traceListener
= new RollingFlatFileTraceListener(fileName, "--header--", "--footer--", null,
0, String.Empty, RollFileExistsBehavior.Overwrite, RollInterval.Midnight))
{
traceListener.TraceData(new TraceEventCache(),
"source",
TraceEventType.Information,
0,
"logged message 1");
traceListener.RollingHelper.DateTimeProvider = dateTimeProvider;
dateTimeProvider.SetCurrentDateTime(DateTime.Now);
Assert.IsTrue(traceListener.RollingHelper.UpdateRollingInformationIfNecessary());
dateTimeProvider.SetCurrentDateTime(DateTime.Now.AddDays(1).Date);
//dateTimeProvider.currentDateTime = DateTime.Now.AddMinutes(2);
Assert.IsTrue(traceListener.RollingHelper.UpdateRollingInformationIfNecessary());
traceListener.TraceData(new TraceEventCache(), "source", TraceEventType.Information, 1, "logged message 2");
}
Assert.IsTrue(File.Exists(fileName));
Assert.IsTrue(LogFileReader.ReadFileWithoutLock(fileName).Contains("logged message 2"));
Assert.IsFalse(LogFileReader.ReadFileWithoutLock(fileName).Contains("logged message 1"));
string[] archiveFiles = Directory.GetFiles(".", fileNameWithoutExtension + "*");
Assert.AreEqual(1, archiveFiles.Length);
}
/// <summary>
/// Gets the dispatcher log data.
/// </summary>
/// <returns>
/// A string buffer containing the current log data
/// </returns>
public string GetSessionLogFiles(string sessionId)
{
SetTraceSessionContext(sessionId);
if (string.IsNullOrEmpty(sessionId))
{
return("Session does not exist");
}
string logFilePath = string.Empty;
string pattern = string.Empty;
if (GlobalSettings.IsDistributedSystem)
{
string location = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
logFilePath = Path.Combine(Path.GetDirectoryName(location), "SessionProxy", "Logs");
//the log extension was missing previously
pattern = "SessionProxy-{0}.log".FormatWith(sessionId);
}
else
{
logFilePath = LogFileReader.DataLogPath();
pattern = "STBConsole.log";
}
StringBuilder builder = new StringBuilder();
var logFiles = LogFileDataCollection.Create(logFilePath);
foreach (var file in logFiles.Items.Where(x => x.FileName.Equals(pattern)))
{
builder.AppendLine(file.FileData);
}
return(builder.ToString());
}
public void EntryIsWrittenWhenWritingAnEntryPassingExtPropsCategoryPriorityEventIdSeverityAndTitle()
{
string originalFile = "ExtPropsCatPriorityEventIdSevTitle.log";
File.Delete(originalFile);
var logWriter = GetWriter(originalFile);
string message = "Test message";
Dictionary <string, object> properties = new Dictionary <string, object>();
properties.Add("one", 1);
properties.Add("two", 2);
properties.Add("three", 3);
logWriter.Write(message, "General", 3, 5, TraceEventType.Critical, "Sample Title", properties);
LogEntry deserializedEntry = LogFileReader.GetEntry(originalFile);
Assert.AreEqual(message, deserializedEntry.Message);
Assert.AreEqual(3, deserializedEntry.Priority);
Assert.AreEqual(TraceEventType.Critical, deserializedEntry.Severity);
Assert.AreEqual("Sample Title", deserializedEntry.Title);
Assert.AreEqual(5, deserializedEntry.EventId);
Assert.AreEqual(3, deserializedEntry.ExtendedProperties.Count);
}
public void OnlyEntriesInPriorityRangeAreWrittenWhenXmlListenerPriorityFilter()
{
File.Delete(Path.Combine(this.strPath, "XmlLogFile.xml"));
LoggingConfiguration loggingConfiguration = BuildProgrammaticConfigForTrace();
this.UpdateConfigForXMLTL(loggingConfiguration);
var priorityFilter = new PriorityFilter("Priority Filter", 2, 99);
loggingConfiguration.Filters.Add(priorityFilter);
this.writer = new LogWriter(loggingConfiguration);
this.writer.Write("Test Logging XML 1", "General", 1);
this.writer.Write("Test Logging XML 2", "General", 2);
this.writer.Write("Test Logging XML 101", "General", 101);
this.writer.Dispose();
Assert.IsTrue(File.Exists(Path.Combine(this.strPath, "XmlLogFile.xml")));
string strFileData = LogFileReader.ReadFileWithoutLock(Path.Combine(this.strPath, "XmlLogFile.xml"));
Assert.IsFalse(strFileData.Contains("<Message>Test Logging XML 1</Message>"));
Assert.IsFalse(strFileData.Contains("<Message>Test Logging XML 101</Message>"));
Assert.IsTrue(strFileData.Contains("<Message>Test Logging XML 2</Message>"));
}
public void EmailIsSent()
{
LogWriterFactory factory = new LogWriterFactory((e) => this.ConfigurationSource.GetSection("loggingConfiguration100"));
factory.Create().Write("Test", "General");
Assert.IsNotNull(LogFileReader.GetEmail());
}
LogBuffer(LogFileReader reader)
{
this.Header = Header.Read(reader);
while (reader.Position < reader.Length)
{
buffers.Add(Buffer.Read(reader));
}
}
public static Event Read(LogFileReader reader, byte extendedInfo)
{
if (extendedInfo == TYPE_JITHELPER)
{
return(new RuntimeJitHelperEvent(reader));
}
throw new ArgumentException("Unknown `RuntimeEventType`: " + extendedInfo);
}
public CoverageClassEvent(LogFileReader reader)
{
Name = reader.ReadNullTerminatedString();
Class = reader.ReadNullTerminatedString();
NumberOfMethods = reader.ReadULeb128();
FullyCovered = reader.ReadULeb128();
PartiallyCovered = reader.ReadULeb128();
}
public static Event Read(LogFileReader reader)
{
byte info = reader.ReadByte();
EventType type = (EventType)(info & 0xF);
byte extendedInfo = (byte)(info & 0xF0);
return(CreateEvent(reader, type, extendedInfo));
}
public CoverageStatementEvent(LogFileReader reader)
{
MethodId = reader.ReadULeb128();
Offset = reader.ReadULeb128();
Counter = reader.ReadULeb128();
Line = reader.ReadULeb128();
Column = reader.ReadULeb128();
}
MetaEvent(LogFileReader reader, byte exinfo)
{
TimeDiff = reader.ReadULeb128();
if (exinfo == TYPE_SYNC_POINT)
{
MonoProfilerSyncPointType = reader.ReadByte();
}
}
GcEvent(LogFileReader reader)
{
TimeDiff = reader.ReadULeb128();
//EventType = (GcEventType) reader.ReadULeb128 ();
//Generation = reader.ReadULeb128 ();
EventType = (GcEventType)reader.ReadByte();
Generation = reader.ReadByte();
}
public UBinSampleEvent(LogFileReader reader)
{
TimeDiff = reader.ReadULeb128();
Address = reader.ReadSLeb128();
Offset = reader.ReadULeb128();
Size = reader.ReadULeb128();
Name = reader.ReadNullTerminatedString();
}
public CountersDescEvent(LogFileReader reader)
{
Len = reader.ReadULeb128();
Sections = new CounterSection[Len];
for (ulong i = 0; i < Len; i++)
{
Sections [i] = new CounterSection(reader);
}
}
public CoverageAssemblyEvent(LogFileReader reader)
{
Name = reader.ReadNullTerminatedString();
Guid = reader.ReadNullTerminatedString();
Filename = reader.ReadNullTerminatedString();
NumberOfMethods = reader.ReadULeb128();
FullyCovered = reader.ReadULeb128();
PartiallyCovered = reader.ReadULeb128();
}
public static Header Read(LogFileReader reader)
{
if (!reader.LoadData(30))
{
return(null);
}
return(new Header(reader));
}
public RuntimeJitHelperEvent(LogFileReader reader) : base(reader)
{
Type = reader.ReadULeb128();
BufferAddress = reader.ReadSLeb128();
BufferSize = reader.ReadULeb128();
if (Type == (ulong)MonoProfilerCodeBufferType.MONO_PROFILER_CODE_BUFFER_SPECIFIC_TRAMPOLINE)
{
Name = reader.ReadNullTerminatedString();
}
}
Buffer(LogFileReader reader)
{
Header = BufferHeader.Read(reader);
var endPos = reader.Position + Header.Length;
while (reader.Position < endPos)
{
Events.Add(Event.Read(reader));
}
}
public ActionResult ViewSysLog()
{
PermissionContext.VerifyPermission(PermissionToken.ViewAuditLog);
var logContents = new LogFileReader().GetLatestLogFileContents();
return(Content(logContents, "text/plain"));
//return View(new ViewSysLog(logContents));
}
public readonly ulong Handle; // GC handle value
HandleDestroyedGcEvent(LogFileReader reader, byte exinfo)
{
TimeDiff = reader.ReadULeb128();
HandleType = reader.ReadULeb128();
Handle = reader.ReadULeb128();
if (exinfo == TYPE_GC_HANDLE_DESTROYED_BT)
{
new Backtrace(reader);
}
}
public ChatLogManager()
{
_reader = new LogFileReader();
AuthentificatedClients = new List <long>();
ChatLogs = new ThreadSafeGenericList <ChatLogEntry>();
AllChatLogs = new ThreadSafeGenericList <ChatLogEntry>();
RecursiveFileOpen("chatlogs");
AuthentificationServiceClient.Instance.Authenticate(ConfigurationManager.AppSettings["AuthentificationServiceAuthKey"]);
Observable.Interval(TimeSpan.FromMinutes(15)).Subscribe(observer => SaveChatLogs());
}
public void ReadInfrequentData()
{
var reader = new LogFileReader("test5.zip");
var sampleProvider = reader.GetProvider(new[] { "test", "Henk" }, 100, 20000); // from 100ms to 20000ms
var lastTime = 99;
int inperiodIntegerCheck = 100 / 20 - 1;
string inperiodStringCheck = "FFFF";
foreach (var sample in sampleProvider.GetSamples())
{
var time = sample.Timestamp;
// The difference is always 1, because test has sample every 1.
Assert.AreEqual(1, time - lastTime);
lastTime = time;
var other = sample.Get("Henk");
var int1 = other.ReadAs <int>("testInt");
var string1 = other.ReadAs <string>("test");
if (time % 20 == 0)
{
inperiodIntegerCheck++;
}
if (time % 20 == 5)
{
byte[] b = new byte[4];
for (int i = 0; i < 4; i++)
{
b[i] = ((byte)(0x41 + (1 + inperiodIntegerCheck) % 26));
}
inperiodStringCheck = Encoding.ASCII.GetString(b);
}
Assert.AreEqual(inperiodIntegerCheck, int1);
Assert.AreEqual(inperiodStringCheck, string1);
}
var sampleProvider2 = reader.GetProvider(new[] { "Henk" }, 100, 2000000); // from 100ms to 20000ms
lastTime = 99;
foreach (var sample in sampleProvider2.GetSamples())
{
var time = sample.Timestamp;
Assert.AreEqual(1, time - lastTime);
lastTime = time;
// even though this group only has new data every '1', the main timeline still has every 1.
// So they are synchronised this way
}
}
public static Event CreateEvent(LogFileReader reader, EventType type, byte extendedInfo)
{
switch (type)
{
case EventType.Alloc:
return(AllocEvent.Read(reader, extendedInfo));
case EventType.Exception:
return(ExceptionEvent.Read(reader, extendedInfo));
case EventType.Gc:
switch (extendedInfo)
{
case TYPE_GC_EVENT:
return(GcEvent.Read(reader));
case TYPE_GC_RESIZE:
return(ResizeGcEvent.Read(reader));
case TYPE_GC_MOVE:
return(MoveGcEvent.Read(reader));
case TYPE_GC_HANDLE_CREATED:
case TYPE_GC_HANDLE_CREATED_BT:
return(HandleCreatedGcEvent.Read(reader, extendedInfo));
case TYPE_GC_HANDLE_DESTROYED:
case TYPE_GC_HANDLE_DESTROYED_BT:
return(HandleDestroyedGcEvent.Read(reader, extendedInfo));
}
throw new InvalidOperationException("unknown gc type:" + extendedInfo);
case EventType.Heap:
return(HeapEvent.Read(reader, extendedInfo));
case EventType.Metadata:
return(MetadataEvent.Read(reader, extendedInfo));
case EventType.Method:
return(MethodEvent.Read(reader, extendedInfo));
case EventType.Monitor:
return(MonitiorEvent.Read(reader, extendedInfo));
case EventType.Sample:
return(SampleEvent.Read(reader, extendedInfo));
case EventType.Runtime:
return(RuntimeEvent.Read(reader, extendedInfo));
case EventType.Coverage:
return(CoverageEvent.Read(reader, extendedInfo));
}
throw new InvalidOperationException("invalid event type " + type);
}
public void Open()
{
var reader = new LogFileReader("test4.zip");
Assert.AreEqual("test4.zip", reader.FileName);
Assert.AreEqual(1, reader.Groups.Count());
Assert.AreEqual("test", reader.Groups.FirstOrDefault().Name);
Assert.AreEqual(2, reader.Groups.FirstOrDefault().Fields.Count());
Assert.AreEqual("testInt", reader.Groups.FirstOrDefault().Fields.FirstOrDefault().Name);
Assert.AreEqual("test", reader.Groups.FirstOrDefault().Fields.Skip(1).FirstOrDefault().Name);
}
public void ReadInfrequentData()
{
var reader = new LogFileReader("test5.zip");
var sampleProvider = reader.GetProvider(new[] { "test", "Henk" }, 100, 20000); // from 100ms to 20000ms
var lastTime = 99;
int inperiodIntegerCheck = 100 / 20 - 1;
string inperiodStringCheck = "FFFF";
foreach (var sample in sampleProvider.GetSamples())
{
var time = sample.Timestamp;
// The difference is always 1, because test has sample every 1.
Assert.AreEqual(1, time - lastTime);
lastTime = time;
var other = sample.Get("Henk");
var int1 = other.ReadAs<int>("testInt");
var string1 = other.ReadAs<string>("test");
if (time % 20 == 0)
inperiodIntegerCheck++;
if (time % 20 == 5)
{
byte[] b = new byte[4];
for (int i = 0; i < 4; i++)
b[i] = ((byte)(0x41 + (1 + inperiodIntegerCheck) % 26));
inperiodStringCheck = Encoding.ASCII.GetString(b);
}
Assert.AreEqual(inperiodIntegerCheck, int1);
Assert.AreEqual(inperiodStringCheck, string1);
}
var sampleProvider2 = reader.GetProvider(new[] { "Henk" }, 100, 2000000); // from 100ms to 20000ms
lastTime = 99;
foreach (var sample in sampleProvider2.GetSamples())
{
var time = sample.Timestamp;
Assert.AreEqual(1, time - lastTime);
lastTime = time;
// even though this group only has new data every '1', the main timeline still has every 1.
// So they are synchronised this way
}
}
public LogSampleProvider(LogFileReader reader, IEnumerable<string> groups, int startTime, int endTime)
{
Reader = reader;
_groups = groups.ToList();
StartTime = startTime;
EndTime = endTime;
// Make base sample.
TimeLine = reader.Groups.SelectMany(x => x.Timeline.Keys).Distinct().OrderBy(x => x).ToList();
// If this time doesn't exist; search the closest related.
if (!TimeLine.Contains(startTime))
startTime = TimeLine.Select(x => x - startTime).OrderBy(x => x).Take(1).FirstOrDefault() + startTime;
Sample = new LogSample(this, startTime, groups.Select(reader.GetGroup));
InitializeSample(Sample, startTime);
}
public void PlaybackTestData()
{
float[] rpmWave;
float[] speedWave;
GetWaves(out rpmWave, out speedWave);
StringBuilder outSine = new StringBuilder();
var telRead = new LogFileReader("Tmp.zip");
var telProvider = telRead.GetProvider(new[] { "Driver" }, 0, 1024*25);
var index = 0;
foreach (var sample in telProvider.GetSamples())
{
var driver = sample.Get("Driver");
Assert.AreEqual(true, driver.ReadAs<bool>("IsPlayer"));
Assert.AreEqual(false, driver.ReadAs<bool>("IsAI"));
Assert.AreEqual(speedWave[index], driver.ReadAs<float>("Speed"));
Assert.AreEqual(rpmWave[index], driver.ReadAs<float>("RPM"));
index++;
outSine.AppendLine(index+","+driver.ReadAs<float>("Speed") + "," + driver.ReadAs<float>("RPM"));
}
File.WriteAllText("sinewave.csv", outSine.ToString());
Assert.AreEqual(1024, index);
telProvider = telRead.GetProvider(new[] { "Driver" }, 512*25, 1024 * 25);
index = 512;
foreach (var sample in telProvider.GetSamples())
{
var driver = sample.Get("Driver");
Assert.AreEqual(true, driver.ReadAs<bool>("IsPlayer"));
Assert.AreEqual(false, driver.ReadAs<bool>("IsAI"));
Assert.AreEqual(speedWave[index], driver.ReadAs<float>("Speed"));
Assert.AreEqual(rpmWave[index], driver.ReadAs<float>("RPM"));
index++;
}
Assert.AreEqual(1024, index);
}
public LogGroup(LogFileReader reader, string name)
{
Name = name;
FileReader = reader;
var xmlData = reader.ReadArchiveFile(name + "/Structure.xml");
var xmlString = Encoding.ASCII.GetString(xmlData);
using (var xmlReader = XmlTextReader.Create(new StringReader(xmlString)))
{
while(xmlReader.Read())
{
if (xmlReader.NodeType == XmlNodeType.Element)
{
switch (xmlReader.Name)
{
case "entity":
if (xmlReader.GetAttribute("name") != this.Name)
Debug.WriteLine("Something is not right");
break;
case "field":
var fieldObj = new LogField(this, xmlReader.GetAttribute("name"),
xmlReader.GetAttribute("id"),
xmlReader.GetAttribute("type"));
_fields.Add(fieldObj);
break;
}
}
}
}
var timeline = FileReader.ReadArchiveFile(Name + "/Time.bin");
int index = 0;
while(index<timeline.Length)
{
int time = BitConverter.ToInt32(timeline, index);
int offset = BitConverter.ToInt32(timeline, index + 4);
_timeline.Add(time, offset);
index += 8;
}
}
public void ReadFrequentData()
{
var reader = new LogFileReader("test4.zip");
var sampleProvider = reader.GetProvider(new[] { "test" }, 100, 20000); // from 100ms to 2000ms
int startI = 100;
foreach (var sample in sampleProvider.GetSamples())
{
var group = sample.Get("test");
var whatWasAnInteger = group.ReadAs<float>("testInt");
Assert.AreEqual((float)startI, whatWasAnInteger);
startI++;
Assert.LessOrEqual(whatWasAnInteger, 20001);
Assert.GreaterOrEqual(whatWasAnInteger, 100);
}
}
public void analyzer()
{
// read the data file
var telRead = new LogFileReader(TestConstants.TestFolder + "\\2013-03-19-18-48 - Session.zip"); // data file of movie
var telProvider = telRead.GetProvider(new[] { "Driver 7427264" }, 0, 100000000); // TODO: end-of-file-time
StringBuilder builder = new StringBuilder();
builder.AppendLine("Time,RPM,Speed,X,Y,Z,Yaw,Whlspd LF, Whlspd RF, Whlspd LR, Whlspd RR,Blocking,Spinning");
foreach (var sample in telProvider.GetSamples())
{
var me = sample.Get("Driver 7427264");
//
builder.AppendLine(sample.Timestamp + "," + me.ReadAs<float>("RPM") + "," + me.ReadAs<float>("Speed") +
"," + me.ReadAs<float>("CoordinateX") + "," + me.ReadAs<float>("CoordinateY") + "," + me.ReadAs<float>("CoordinateZ") + "," + me.ReadAs<float>("Yaw")
+ "," + me.ReadAs<float>("TyreSpeedLF")+ "," + me.ReadAs<float>("TyreSpeedRF")+ "," + me.ReadAs<float>("TyreSpeedLR")+ "," + me.ReadAs<float>("TyreSpeedRR")
+ "," + IsLockingWheels(me) + "," + IsSpinningWheels(me));
}
File .WriteAllText("out.2csv", builder.ToString());
}
public void ReadEmptyFile()
{
LogFileReader reader = new LogFileReader(TestConstants.TestFolder + "EmptyTelemetryFile.zip");
}
