Пример #1
0
 private void ProcessRawData(GenericFile file)
 {
     for (int i = 0; i < file.Length; i++)
     {
         Bits.AppendByte(file.Read(i));
     }
 }
Пример #2
0
        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.");
                }
            }
        }
Пример #3
0
        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));
            }
        }
Пример #4
0
        /// <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);
            }
        }
Пример #5
0
        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));
            }
        }
Пример #6
0
        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
        }
Пример #7
0
        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));
            }
        }
Пример #8
0
        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());
        }
Пример #9
0
 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));
     }
 }
Пример #10
0
 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));
     }
 }
Пример #11
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));
     }
 }
Пример #12
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));
     }
 }
Пример #13
0
 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));
     }
 }
Пример #14
0
 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));
     }
 }
Пример #15
0
 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());
     }
 }
Пример #16
0
 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));
     }
 }
Пример #17
0
 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());
     }
 }
Пример #18
0
 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));
     }
 }
Пример #19
0
 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));
     }
 }
Пример #20
0
 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));
     }
 }
Пример #21
0
 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));
     }
 }
Пример #22
0
        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));
        }
Пример #23
0
 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()));
     }
 }
Пример #24
0
 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()));
     }
 }
Пример #25
0
 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()));
     }
 }
Пример #26
0
 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);
        }
Пример #28
0
 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()));
     }
 }
Пример #29
0
        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()));
            }
        }
Пример #30
0
        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);
            });
        }