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"); }