private void ProcessRawData(GenericFile file) { for (int i = 0; i < file.Length; i++) { Bits.AppendByte(file.Read(i)); } }
public async Task DetectableFileTypeDetectorTest() { using (var manager = new PluginManager()) { await manager.LoadCore(new TestCoreMod()); var detector = new DetectableFileTypeDetector(); using (var file0 = new GenericFile()) { file0.CreateFile(new byte[] { 0 }); var results = await detector.DetectFileType(file0, manager); Assert.AreEqual(2, results.Count()); Assert.IsTrue(results.All(x => x.MatchChance == 0.5f), "File0: Not all results have correct match percentage"); Assert.IsTrue(results.Any(x => ReflectionHelpers.IsOfType(x.FileType, typeof(File00).GetTypeInfo())), "File00 should have been a match File0."); Assert.IsTrue(results.Any(x => ReflectionHelpers.IsOfType(x.FileType, typeof(AnyFile).GetTypeInfo())), "AnyFile should have been a match File0."); } using (var fileF = new GenericFile()) { fileF.CreateFile(new byte[] { 0xFF }); var results = await detector.DetectFileType(fileF, manager); Assert.AreEqual(3, results.Count()); Assert.IsTrue(results.All(x => x.MatchChance == 0.5f), "FileF: Not all results have correct match percentage"); Assert.IsTrue(results.Any(x => ReflectionHelpers.IsOfType(x.FileType, typeof(FileFF).GetTypeInfo())), "FileFF should have been a match for FileF."); Assert.IsTrue(results.Any(x => ReflectionHelpers.IsOfType(x.FileType, typeof(AnyFile).GetTypeInfo())), "AnyFile should have been a match FileF."); Assert.IsTrue(results.Any(x => ReflectionHelpers.IsOfType(x.FileType, typeof(TextFile).GetTypeInfo())), "TextFile should have been a match FileF."); } } }
public void WriteByte_Sequence_Sync_Stream() { var testData = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 }; using (var f = new GenericFile()) { f.EnableInMemoryLoad = false; f.CreateFile(new byte[8]); f.WriteByte(testData[0]); f.WriteByte(testData[1]); f.WriteByte(testData[2]); f.WriteByte(testData[3]); f.WriteByte(testData[4]); f.WriteByte(testData[5]); f.WriteByte(testData[6]); f.WriteByte(testData[7]); Assert.AreEqual(testData[0], f.Read(0)); Assert.AreEqual(testData[1], f.Read(1)); Assert.AreEqual(testData[2], f.Read(2)); Assert.AreEqual(testData[3], f.Read(3)); Assert.AreEqual(testData[4], f.Read(4)); Assert.AreEqual(testData[5], f.Read(5)); Assert.AreEqual(testData[6], f.Read(6)); Assert.AreEqual(testData[7], f.Read(7)); } }
/// <remarks> /// Auto-detection only supports up to 32MB files to avoid hogging all the ram. /// </remarks> public async Task <bool> IsOfType(GenericFile file) { if (file.Length > 2 && await file.ReadAsync(0) == 0x78 && new byte[] { 0x1, 0x9C, 0xDA }.Contains(await file.ReadAsync(1)) && file.Length < 32 * 1024 * 1024) { try { using (var compressed = new MemoryStream(await file.ReadAsync())) { compressed.Seek(2, SeekOrigin.Begin); using (var decompressed = new MemoryStream()) { using (var zlib = new DeflateStream(compressed, CompressionMode.Decompress)) { zlib.CopyTo(decompressed); } var rawData = decompressed.ToArray(); } } } catch (Exception) { return(false); } return(true); } else { return(false); } }
public async Task WriteByte_Sequence_Async_Stream() { var testData = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 }; using (var f = new GenericFile()) { f.EnableInMemoryLoad = false; f.CreateFile(new byte[8]); await f.WriteByteAsync(testData[0]); await f.WriteByteAsync(testData[1]); await f.WriteByteAsync(testData[2]); await f.WriteByteAsync(testData[3]); await f.WriteByteAsync(testData[4]); await f.WriteByteAsync(testData[5]); await f.WriteByteAsync(testData[6]); await f.WriteByteAsync(testData[7]); Assert.AreEqual(testData[0], await f.ReadAsync(0)); Assert.AreEqual(testData[1], await f.ReadAsync(1)); Assert.AreEqual(testData[2], await f.ReadAsync(2)); Assert.AreEqual(testData[3], await f.ReadAsync(3)); Assert.AreEqual(testData[4], await f.ReadAsync(4)); Assert.AreEqual(testData[5], await f.ReadAsync(5)); Assert.AreEqual(testData[6], await f.ReadAsync(6)); Assert.AreEqual(testData[7], await f.ReadAsync(7)); } }
public async Task OpenFile_FallsBackToStreamIfFileOver2GB() { // Create a file that's too big // If we tried to do it in memory, it would require over 2GB of RAM. // This isn't practical and won't work on all machines, so let's use the filesystem instead // It's a safer bet we'll have over 2GB of disk space than over 2GB of RAM var provider = new PhysicalFileSystem(); var filename = "a2GBfile.bin"; if (!File.Exists(filename) || (new FileInfo(filename)).Length <= (long)int.MaxValue + 1) { using (var stream = provider.OpenFileWriteOnly(filename)) { var buffer = new byte[50000]; stream.SetLength((long)int.MaxValue + 1); stream.Seek(0, SeekOrigin.Begin); while (stream.Position < stream.Length) { await stream.WriteAsync(buffer, 0, buffer.Length); } } } // Now on with the test var file = new GenericFile(); file.EnableInMemoryLoad = true; await file.OpenFile(filename, provider); Assert.IsFalse(file.IsThreadSafe); // No thread safety indicates we're using an underlying stream }
public void WriteByte_Sync_Memory() { var testData = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 }; using (var f = new GenericFile()) { f.EnableInMemoryLoad = true; f.CreateFile(new byte[8]); f.Write(0, testData[0]); f.Write(1, testData[1]); f.Write(2, testData[2]); f.Write(3, testData[3]); f.Write(4, testData[4]); f.Write(5, testData[5]); f.Write(6, testData[6]); f.Write(7, testData[7]); Assert.AreEqual(testData[0], f.Read(0)); Assert.AreEqual(testData[1], f.Read(1)); Assert.AreEqual(testData[2], f.Read(2)); Assert.AreEqual(testData[3], f.Read(3)); Assert.AreEqual(testData[4], f.Read(4)); Assert.AreEqual(testData[5], f.Read(5)); Assert.AreEqual(testData[6], f.Read(6)); Assert.AreEqual(testData[7], f.Read(7)); } }
new public string PrintHelpText() { StringBuilder help = new StringBuilder(); help.AppendLine("Required flags"); foreach (var prop in this.GetType().GetProperties()) { if (prop.GetCustomAttributes(typeof(CommandLineArgAttribute), true).FirstOrDefault() is CommandLineArgAttribute cmdAttribute) { help.AppendFormat("{0,-40}\t\t{1,-100}", cmdAttribute.Usage, cmdAttribute.Description); //if (!String.IsNullOrWhiteSpace (cmdAttribute.DefaultValue)) // help.AppendFormat ("\t Default:{0,-40}\n", cmdAttribute.DefaultValue); //else // help.Append ("\n"); } } help.AppendLine(new String('-', 180)); help.AppendLine("InfluxDB related flags"); help.Append(InfluxDB.PrintHelpText()); help.AppendLine(new String('-', 180)); help.AppendLine("Perfmon file format related flags"); help.Append(PerfmonFile.PrintHelpText()); help.AppendLine(new String('-', 180)); help.AppendLine("Generic delimited file format related flags"); help.Append(GenericFile.PrintHelpText()); return(help.ToString()); }
public async Task ReadNullTerminatedString_Async() { using (var f = new GenericFile()) { f.CreateFile(new byte[] { 0x50, 0x6F, 0x6B, 0xC3, 0xA9, 0x6D, 0x6F, 0x6E, 0x00, 0x50, 0x6F, 0x6B, 0xC3, 0xA9, 0x6D, 0x6F, 0x6E, 0x00 }); Assert.AreEqual("Pokémon", await f.ReadNullTerminatedStringAsync(0, Encoding.UTF8)); } }
public void ReadNullTerminatedUnicodeString_Sync() { using (var f = new GenericFile()) { f.CreateFile(new byte[] { 0x74, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x00, 0x00 }); Assert.AreEqual("test", f.ReadNullTerminatedUnicodeString(0)); } }
public async Task ReadNullTerminatedUnicodeString_Async() { using (var f = new GenericFile()) { f.CreateFile(new byte[] { 0x74, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x00, 0x00 }); Assert.AreEqual("test", await f.ReadNullTerminatedUnicodeStringAsync(0)); } }
public async Task ReadInt32_Async() { using (var f = new GenericFile()) { f.CreateFile(new byte[] { 42, 00, 00, 00, 255, 255, 255, 255 }); Assert.AreEqual(42, await f.ReadInt32Async(0)); Assert.AreEqual(-1, await f.ReadInt32Async(4)); } }
public void ReadInt32BigEndian_Offset() { using (var f = new GenericFile()) { f.CreateFile(new byte[] { 00, 00, 00, 42, 255, 255, 255, 255 }); Assert.AreEqual(42, f.ReadInt32BigEndian(0)); Assert.AreEqual(-1, f.ReadInt32BigEndian(4)); } }
public void ReadUInt32_Offset() { using (var f = new GenericFile()) { f.CreateFile(new byte[] { 42, 00, 00, 00, 255, 255, 255, 255 }); Assert.AreEqual((UInt32)42, f.ReadUInt32(0)); Assert.AreEqual(UInt32.MaxValue, f.ReadUInt32(4)); } }
public void ReadInt64_Sequence() { using (var f = new GenericFile()) { f.CreateFile(new byte[] { 42, 00, 00, 00, 00, 00, 00, 00, 255, 255, 255, 255, 255, 255, 255, 255 }); Assert.AreEqual(42, f.ReadInt64()); Assert.AreEqual(-1, f.ReadInt64()); } }
public async Task ReadUInt64_Async() { using (var f = new GenericFile()) { f.CreateFile(new byte[] { 42, 00, 00, 00, 00, 00, 00, 00, 255, 255, 255, 255, 255, 255, 255, 255 }); Assert.AreEqual((UInt64)42, await f.ReadUInt64Async(0)); Assert.AreEqual(UInt64.MaxValue, await f.ReadUInt64Async(8)); } }
public void ReadUInt64_Sequence() { using (var f = new GenericFile()) { f.CreateFile(new byte[] { 42, 00, 00, 00, 00, 00, 00, 00, 255, 255, 255, 255, 255, 255, 255, 255 }); Assert.AreEqual((UInt64)42, f.ReadUInt64()); Assert.AreEqual(UInt64.MaxValue, f.ReadUInt64()); } }
public void ReadUInt64BigEndian_Offset() { using (var f = new GenericFile()) { f.CreateFile(new byte[] { 00, 00, 00, 00, 00, 00, 00, 42, 255, 255, 255, 255, 255, 255, 255, 255 }); Assert.AreEqual((UInt64)42, f.ReadUInt64BigEndian(0)); Assert.AreEqual(UInt64.MaxValue, f.ReadUInt64BigEndian(8)); } }
public async Task ReadInt64BigEndian_Async() { using (var f = new GenericFile()) { f.CreateFile(new byte[] { 00, 00, 00, 00, 00, 00, 00, 42, 255, 255, 255, 255, 255, 255, 255, 255 }); Assert.AreEqual(42, await f.ReadInt64BigEndianAsync(0)); Assert.AreEqual(-1, await f.ReadInt64BigEndianAsync(8)); } }
public async Task ReadUInt32BigEndian_Async() { using (var f = new GenericFile()) { f.CreateFile(new byte[] { 00, 00, 00, 42, 255, 255, 255, 255 }); Assert.AreEqual((UInt32)42, await f.ReadUInt32BigEndianAsync(0)); Assert.AreEqual(UInt32.MaxValue, await f.ReadUInt32BigEndianAsync(4)); } }
public void ReadInt16_Offset() { using (var f = new GenericFile()) { f.CreateFile(new byte[] { 42, 00, 255, 255 }); Assert.AreEqual(42, f.ReadInt16(0)); Assert.AreEqual(-1, f.ReadInt16(2)); } }
public static uint Calculate32BitChecksum(GenericFile file, int startIndex, int endIndex) { ulong sum = 0; for (int i = startIndex; i <= endIndex; i += 4) { sum += file.ReadUInt32(i) & 0xFFFFFFFF; } return((uint)(sum & 0xFFFFFFFF)); }
public void WriteInt32_Sequence() { using (var f = new GenericFile()) { f.CreateFile(new byte[8]); f.WriteInt32(42); f.WriteInt32(-1); Assert.IsTrue((new byte[] { 42, 00, 00, 00, 255, 255, 255, 255 }).SequenceEqual(f.Read())); } }
public void WriteUInt16_Sequence() { using (var f = new GenericFile()) { f.CreateFile(new byte[4]); f.WriteUInt16(42); f.WriteUInt16(UInt16.MaxValue); Assert.IsTrue((new byte[] { 42, 00, 255, 255 }).SequenceEqual(f.Read())); } }
public void WriteUInt64_Offset() { using (var f = new GenericFile()) { f.CreateFile(new byte[16]); f.WriteUInt64(0, 42); f.WriteUInt64(8, UInt64.MaxValue); Assert.IsTrue((new byte[] { 42, 00, 00, 00, 00, 00, 00, 00, 255, 255, 255, 255, 255, 255, 255, 255 }).SequenceEqual(f.Read())); } }
public void WriteInt16_Offset() { using (var f = new GenericFile()) { f.CreateFile(new byte[4]); f.WriteInt16(0, 42); f.WriteInt16(2, -1); Assert.IsTrue((new byte[] { 42, 00, 255, 255 }).SequenceEqual(f.Read())); } }
public void M_WhenDoingExpenseMatchingWillFilterOwnedFileForWagesRowsAndExpenseTransactionsOnly() { // Arrange var mock_bank_and_bank_in_loader = new Mock <IBankAndBankInLoader>(); var mock_bank_in_file_io = new Mock <IFileIO <BankRecord> >(); var wages_description = $"Wages ({ReconConsts.Employer_expense_description}) (!! in an inestimable manner, not forthwith - forever 1st outstanding)"; mock_bank_in_file_io.Setup(x => x.Load(It.IsAny <List <string> >(), null)) .Returns(new List <BankRecord> { new BankRecord { Type = Codes.Expenses, Description = Codes.Expenses + "1" }, new BankRecord { Type = "Chq", Description = "something" }, new BankRecord { Type = Codes.Expenses, Description = Codes.Expenses + "2" }, new BankRecord { Type = Codes.Expenses, Description = Codes.Expenses + "3" }, new BankRecord { Type = "Chq", Description = "something" }, new BankRecord { Type = "PCL", Description = wages_description } }); var bank_in_file = new GenericFile <BankRecord>(new CSVFile <BankRecord>(mock_bank_in_file_io.Object)); var mock_actual_bank_file_io = new Mock <IFileIO <ActualBankRecord> >(); mock_actual_bank_file_io.Setup(x => x.Load(It.IsAny <List <string> >(), null)) .Returns(new List <ActualBankRecord> { new ActualBankRecord { Description = $"\"'{ReconConsts.Employer_expense_description}\"" } }); var actual_bank_file = new ActualBankInFile(new CSVFile <ActualBankRecord>(mock_actual_bank_file_io.Object)); var data_loading_info = new DataLoadingInformation <ActualBankRecord, BankRecord> { Sheet_name = MainSheetNames.Bank_in }; var reconciliator = new Reconciliator <ActualBankRecord, BankRecord>(data_loading_info, actual_bank_file, bank_in_file); var matcher = new BankAndBankInMatcher(this, new FakeSpreadsheetRepoFactory(), mock_bank_and_bank_in_loader.Object); // Act matcher.Filter_for_all_wages_rows_and_expense_transactions_from_expected_in(reconciliator); // Assert Assert.AreEqual(4, reconciliator.Owned_file.Records.Count); Assert.AreEqual(Codes.Expenses + "1", reconciliator.Owned_file.Records[0].Description); Assert.AreEqual(Codes.Expenses + "2", reconciliator.Owned_file.Records[1].Description); Assert.AreEqual(Codes.Expenses + "3", reconciliator.Owned_file.Records[2].Description); Assert.AreEqual(wages_description, reconciliator.Owned_file.Records[3].Description); }
public void WriteNullTerminatedString_Sync() { using (var f = new GenericFile()) { var original = new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x50, 0x6F, 0x6B, 0xC3, 0xA9, 0x6D, 0x6F, 0x01 }; f.CreateFile(original); f.WriteNullTerminatedString(0, Encoding.UTF8, "Pokémon"); f.WriteNullTerminatedString(9, Encoding.UTF8, "1234567"); Assert.IsTrue(new byte[] { 0x50, 0x6F, 0x6B, 0xC3, 0xA9, 0x6D, 0x6F, 0x6E, 0x00, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x00 }.SequenceEqual(f.Read())); } }
public async Task Read_Async_Stream() { var testData = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 }; using (var f = new GenericFile()) { f.EnableInMemoryLoad = false; f.CreateFile(testData.Clone() as byte[]); Assert.IsTrue(testData.SequenceEqual(await f.ReadAsync())); } }
public void Read_Sync_Memory() { var testData = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 }; using (var f = new GenericFile()) { f.EnableInMemoryLoad = true; f.CreateFile(testData.Clone() as byte[]); Assert.IsTrue(testData.SequenceEqual(f.Read())); } }
public void CreateInstanceWithInvalidPath() { TestExpectedArgumentException<ArgumentException>( resolver => { var anyFileInfo = new GenericFile(default(string)); }, "fullName"); TestExpectedArgumentException<ArgumentException>( resolver => { var anyFileInfo = new GenericFile(string.Empty); }, "fullName"); TestExpectedArgumentException<ArgumentException>(resolver => { var anyFileInfo = new GenericFile(" "); }, "fullName"); }
public void CreateInstance() { Test(resolver => { const string filePath = @"C:\Test\test.fake"; var anyFileInfo = new GenericFile(filePath); Assert.IsInstanceOfType(anyFileInfo.FileInfo, typeof (GenericFileInfo)); Assert.IsNotNull(anyFileInfo.FileInfo); Assert.AreEqual("test", anyFileInfo.Name); Assert.AreEqual("test.fake", anyFileInfo.FullName); Assert.AreEqual(@"C:\Test", anyFileInfo.Path); Assert.AreEqual(filePath, anyFileInfo.FullPath); }); }