public async Task Cancellation___OK() { var sut = new NoCompression(); var data = RawDataForTrendAsync(); var expected = RawDataForTrend().Take(2).ToList(); DataPointIterator dataPointIterator = sut.ProcessAsync(data); var cts = new CancellationTokenSource(); var enumerator = dataPointIterator.GetAsyncEnumerator(cts.Token); var actual = new List <DataPoint>(); await enumerator.MoveNextAsync(); actual.Add(enumerator.Current); await enumerator.MoveNextAsync(); actual.Add(enumerator.Current); cts.Cancel(); DataPoint[] res = null; Assert.ThrowsAsync <OperationCanceledException>(async() => res = await dataPointIterator.ToArrayAsync(cts.Token)); CollectionAssert.AreEqual(expected, actual); Assert.IsNull(res); }
public void Cancellation_after_two_items___OK() { var sut = new NoCompression(); var data = RawDataForTrendAsync(); var expected = RawDataForTrend().Take(2).ToList(); var cts = new CancellationTokenSource(); var actual = new List <DataPoint>(); int idx = 0; Assert.ThrowsAsync <OperationCanceledException>(async() => { await foreach (DataPoint dp in sut.ProcessAsync(data).WithCancellation(cts.Token)) { actual.Add(dp); idx++; if (idx == 2) { cts.Cancel(); } } }); CollectionAssert.AreEqual(actual, expected); }
public void Cloning_iterates_over_fresh_set() { var sut = new NoCompression(); var data = KnownSequence().ToArray().Select(dp => dp); var expected = KnownSequence().ToArray(); var filter = sut.Process(data); var iterator = filter.GetEnumerator(); iterator.MoveNext(); iterator = filter.Clone().GetEnumerator(); Assert.Multiple(() => { int step = 0; Assert.IsTrue(iterator.MoveNext(), $"MoveNext step: {step}"); Assert.AreEqual(expected[step], iterator.Current, $"Equal step: {step}"); step++; Assert.IsTrue(iterator.MoveNext(), $"MoveNext step: {step}"); Assert.AreEqual(expected[step], iterator.Current, $"Equal step: {step}"); step++; Assert.IsTrue(iterator.MoveNext(), $"MoveNext step: {step}"); Assert.AreEqual(expected[step], iterator.Current, $"Equal step: {step}"); step++; Assert.IsFalse(iterator.MoveNext(), $"MoveNext step: {step++}"); }); }
static void Main(string[] args) { var isPix = args[0] == "-p"; ICompressor compressor; switch (args[1]) { case "-l": compressor = new LZ4Compressor(); break; case "-s": compressor = new SnappyCompressor(); break; default: compressor = new NoCompression(); break; } if (isPix) { new PixServer(compressor).Start(); } else { new LiteServer(compressor).Start(); } }
public void Known_sequence_as_array___correct_result() { var sut = new NoCompression(); var data = KnownSequence().ToArray(); var iterator = sut.Process(data).GetEnumerator(); var expected = KnownSequence().ToArray(); Assert.Multiple(() => { int step = 0; Assert.IsTrue(iterator.MoveNext(), $"MoveNext step: {step}"); Assert.AreEqual(expected[step], iterator.Current, $"Equal step: {step}"); step++; Assert.IsTrue(iterator.MoveNext(), $"MoveNext step: {step}"); Assert.AreEqual(expected[step], iterator.Current, $"Equal step: {step}"); step++; Assert.IsTrue(iterator.MoveNext(), $"MoveNext step: {step}"); Assert.AreEqual(expected[step], iterator.Current, $"Equal step: {step}"); step++; Assert.IsTrue(iterator.MoveNext(), $"MoveNext step: {step}"); Assert.AreEqual(expected[step], iterator.Current, $"Equal step: {step}"); step++; Assert.IsTrue(iterator.MoveNext(), $"MoveNext step: {step}"); Assert.AreEqual(expected[step], iterator.Current, $"Equal step: {step}"); step++; Assert.IsFalse(iterator.MoveNext(), $"MoveNext step: {step++}"); }); }
public async Task Empty_IAsyncEnumerable___empty_result() { var sut = new NoCompression(); var data = EmptyAsync(); var iterator = sut.ProcessAsync(data).GetAsyncEnumerator(); Assert.IsFalse(await iterator.MoveNextAsync()); }
public void Empty_IEnumerable___empty_result() { var sut = new NoCompression(); var data = Empty(); var iterator = sut.Process(data).GetEnumerator(); Assert.IsFalse(iterator.MoveNext()); }
public void MoveNext_without_GetEnumerator___throws_InvalidOperation() { var sut = new NoCompression(); var data = RawDataForTrend(); var iterator = sut.Process(data); Assert.Throws <InvalidOperationException>(() => iterator.MoveNext()); }
public void Data_IList_with_maxDeltaX___OK() { var sut = new NoCompression(); var data = RawDataForMaxDelta().ToList().AsReadOnly(); var expected = RawDataForMaxDelta().ToList(); var actual = sut.Process(data).ToList(); CollectionAssert.AreEqual(expected, actual); }
public void Data_given_as_IList___OK() { var sut = new NoCompression(); var data = RawDataForTrend().ToList().AsReadOnly(); var expected = RawDataForTrend().ToList(); var actual = sut.Process(data).ToList(); CollectionAssert.AreEqual(expected, actual); }
public async Task Data_IAsyncEnumerable_with_maxDeltaX___OK() { var sut = new NoCompression(); var data = RawDataForMaxDeltaAsync(); var expected = RawDataForMaxDelta().ToList(); var actual = await sut.ProcessAsync(data).ToArrayAsync(); CollectionAssert.AreEqual(expected, actual); }
public async Task Data_given_as_IAsyncEnumerable___OK() { var sut = new NoCompression(); var data = RawDataForTrendAsync(); var expected = RawDataForTrend().ToList(); var actual = await sut.ProcessAsync(data).ToArrayAsync(); CollectionAssert.AreEqual(expected, actual); }
public void One_DataPoint_IEnumerable___OK() { var sut = new NoCompression(); var data = RawDataForMaxDelta().Take(1); var expected = RawDataForMaxDelta().Take(1).ToList(); var actual = sut.Process(data).ToList(); CollectionAssert.AreEqual(expected, actual); }
public void Two_DataPoint_IList___OK() { var sut = new NoCompression(); var data = RawDataForMaxDelta().Take(2).ToList().AsReadOnly(); var expected = RawDataForMaxDelta().Take(2).ToList(); var actual = sut.Process(data).ToArray(); CollectionAssert.AreEqual(expected, actual); }
private void BenchmarkCompressionSpeed() { using (Bitmap bmpScreenCapture = new Bitmap(Screen.PrimaryScreen.Bounds.Width, Screen.PrimaryScreen.Bounds.Height)) { using (Graphics g = Graphics.FromImage(bmpScreenCapture)) { g.CopyFromScreen(Screen.PrimaryScreen.Bounds.X, Screen.PrimaryScreen.Bounds.Y, 0, 0, bmpScreenCapture.Size, CopyPixelOperation.SourceCopy); } using (var jpgCompressor = new JpgCompression(70)) { for (int i = 0; i < 5; i++) { var sw = Stopwatch.StartNew(); GC.Collect(); GC.WaitForPendingFinalizers(); using (var outStream = new MemoryStream(10000)) { jpgCompressor.Compress(bmpScreenCapture, outStream); var data = outStream.ToArray(); Debug.Print("Managed JPG: Time neeeded: " + sw.ElapsedMilliseconds + ", size: " + data.Length); } } } using (var turboJpg = new NoCompression()) { turboJpg.Quality = 70; var lockBits = bmpScreenCapture.LockBits(new Rectangle(0, 0, bmpScreenCapture.Width, bmpScreenCapture.Height), ImageLockMode.ReadOnly, bmpScreenCapture.PixelFormat); for (int i = 0; i < 5; i++) { GC.Collect(); GC.WaitForPendingFinalizers(); var sw = Stopwatch.StartNew(); var data = turboJpg.Compress(lockBits.Scan0, lockBits.Stride, new System.Drawing.Size(lockBits.Width, lockBits.Height), lockBits.PixelFormat); Debug.Print("LZF: Time neeeded: " + sw.ElapsedMilliseconds + ", size: " + data.Length); } bmpScreenCapture.UnlockBits(lockBits); } } }
public void Data_given_as_List___OK() { var sut = new NoCompression(); var data = RawDataForTrend().ToList(); var expected = RawDataForTrend().ToList(); var actual = new List<DataPoint>(); foreach (DataPoint dp in sut.Process(data)) actual.Add(dp); CollectionAssert.AreEqual(expected, actual); }
public void One_DataPoint_IEnumerable___OK() { var sut = new NoCompression(); var data = KnownSequence().Take(1); var expected = KnownSequence().Take(1).ToList(); var actual = new List<DataPoint>(); foreach (DataPoint dp in sut.Process(data)) actual.Add(dp); CollectionAssert.AreEqual(expected, actual); }
public void Data_IList_with_maxDeltaX___OK() { var sut = new NoCompression(); var data = RawDataForMaxDelta().ToList().AsReadOnly(); var expected = RawDataForMaxDelta().ToList(); var actual = new List<DataPoint>(); foreach (DataPoint dp in sut.Process(data)) actual.Add(dp); CollectionAssert.AreEqual(expected, actual); }
public async Task Empty_IAsyncEnumerable_foreach___empty_result() { var sut = new NoCompression(); var data = EmptyAsync(); int count = 0; await foreach (DataPoint db in sut.ProcessAsync(data)) { count++; } Assert.AreEqual(0, count); }
public void Empty_IEnumerable_foreach___empty_result() { var sut = new NoCompression(); var data = Empty(); int count = 0; foreach (DataPoint dp in sut.Process(data)) { count++; } Assert.AreEqual(0, count); }
public void Two_DataPoint_IList___OK() { var sut = new NoCompression(); var data = KnownSequence().Take(2).ToList().AsReadOnly(); var expected = KnownSequence().Take(2).ToList(); var actual = new List <DataPoint>(); foreach (DataPoint dp in sut.Process(data)) { actual.Add(dp); } CollectionAssert.AreEqual(expected, actual); }
public void Two_DataPoint_List___OK() { var sut = new NoCompression(); var data = RawDataForMaxDelta().Take(2).ToList(); var expected = RawDataForMaxDelta().Take(2).ToList(); var actual = new List <DataPoint>(); foreach (DataPoint dp in sut.Process(data)) { actual.Add(dp); } CollectionAssert.AreEqual(expected, actual); }
public async Task Data_IAsyncEnumerable_with_maxDeltaX___OK() { var sut = new NoCompression(); var data = RawDataForMaxDeltaAsync(); var expected = RawDataForMaxDelta().ToList(); var actual = new List <DataPoint>(); await foreach (DataPoint dp in sut.ProcessAsync(data)) { actual.Add(dp); } CollectionAssert.AreEqual(expected, actual); }
public void Known_sequence_as_array_foreach___correct_result() { var sut = new NoCompression(); var data = KnownSequence().ToArray(); var result = sut.Process(data); var expected = KnownSequence().ToArray(); var actual = new List <DataPoint>(); foreach (DataPoint dp in result) { actual.Add(dp); } CollectionAssert.AreEqual(expected, actual); }
public void List_iterated_and_ToList___OK() { var sut = new NoCompression(); var data = RawDataForTrend().ToList(); var expected = RawDataForTrend().ToList(); DataPointIterator dataPointIterator = sut.Process(data); DataPointIterator enumerator = dataPointIterator.GetEnumerator(); enumerator.MoveNext(); enumerator.MoveNext(); var actual = dataPointIterator.ToList(); CollectionAssert.AreEqual(expected, actual); }
public async Task IAsyncEnumerable_iterated_and_ToArray___OK() { var sut = new NoCompression(); var data = RawDataForTrendAsync(); var expected = RawDataForTrend().ToList(); DataPointIterator dataPointIterator = sut.ProcessAsync(data); var enumerator = dataPointIterator.GetAsyncEnumerator(); await enumerator.MoveNextAsync(); await enumerator.MoveNextAsync(); var actual = await dataPointIterator.ToArrayAsync(); CollectionAssert.AreEqual(expected, actual); }
public async Task Known_sequence_foreach___correct_result() { var sut = new NoCompression(); var data = KnownSequenceAsync(); var result = sut.ProcessAsync(data); var expected = new List <DataPoint>(); var actual = new List <DataPoint>(); await foreach (DataPoint dp in KnownSequenceAsync()) { expected.Add(dp); } await foreach (DataPoint dp in result) { actual.Add(dp); } CollectionAssert.AreEqual(expected, actual); }
public async Task Known_sequence___correct_result() { var sut = new NoCompression(); var data = KnownSequenceAsync(); var iterator = sut.ProcessAsync(data).GetAsyncEnumerator(); var expected = new List <DataPoint>(); await foreach (DataPoint dp in KnownSequenceAsync()) { expected.Add(dp); } Assert.Multiple(async() => { await iterator.MoveNextAsync(); Assert.AreEqual(expected[0], iterator.Current); await iterator.MoveNextAsync(); Assert.AreEqual(expected[1], iterator.Current); await iterator.MoveNextAsync(); Assert.AreEqual(expected[2], iterator.Current); }); }
static void Main(string[] args) { var isPix = args[0] == "-p"; var rooms = args.Length == 3 ? int.Parse(args[2]) : 10; ICompressor compressor; switch (args[1]) { case "-l": compressor = new LZ4Compressor(); break; case "-s": compressor = new SnappyCompressor(); break; default: compressor = new NoCompression(); break; } for (var i = 0; i < rooms * 12; i++) { if (isPix) { Task.Run((Action) new PixClient(compressor).Start); } else { Task.Run((Action) new LiteClient(compressor).Start); } } Console.ReadLine(); }
/// <summary> /// Extracts data from a Brutal Legend package. /// </summary> /// <param name="HeaderFile">The *.~h Header file path</param> /// <param name="DataFile">The ~.~p Data file path</param> /// <param name="OutFolder">The output folder</param> /// <returns>False if header file is invalid, true otherwise</returns> public static bool Extract(string HeaderFile, string DataFile, string OutFolder) { FileStream Header = new FileStream(HeaderFile, FileMode.Open); FileStream Data = new FileStream(DataFile, FileMode.Open); EndianBinaryReader Reader = new EndianBinaryReader(Header, Endian.Big); if (StringUtilities.ReadASCIIString(Header, 4) != "dfpf") { return(false); } Header.Seek(0x14, SeekOrigin.Begin); uint StringsTableOffset = Reader.ReadUInt32(); uint StringsTableFlags = Reader.ReadUInt32(); uint StringsTableLength = Reader.ReadUInt32(); uint FilesCount = Reader.ReadUInt32(); Header.Seek(0x18, SeekOrigin.Current); uint FilesTableOffset = Reader.ReadUInt32(); for (int Index = 0; Index < FilesCount; Index++) { Header.Seek(FilesTableOffset + Index * 0x10, SeekOrigin.Begin); //Lengths uint DecompressedLength = Reader.ReadUInt24(); uint LengthDifference = (uint)(Reader.ReadUInt16() << 1) | ((DecompressedLength & 1) << 17); //Probably for "obfuscation" uint CompressedLength = Reader.ReadUInt24(); LengthDifference |= CompressedLength >> 23; DecompressedLength = (DecompressedLength >> 1) + LengthDifference; CompressedLength = (CompressedLength & 0x7fffff) >> 1; //Offsets uint DataOffset = Reader.ReadUInt24() << 5; byte DataFormat = Reader.ReadByte(); DataOffset |= (uint)(DataFormat & 0xf8) >> 3; DataFormat &= 7; uint NameOffset = (Reader.ReadUInt24() >> 3) + StringsTableOffset; byte Flags = Reader.ReadByte(); Header.Seek(NameOffset, SeekOrigin.Begin); string FileName = StringUtilities.ReadASCIIString(Header); if (OnStatusReport != null) { BrutalStatusReport Report = new BrutalStatusReport(); Report.Status = "Extracting " + FileName + "..."; Report.ProcessedFiles = Index; Report.TotalFiles = (int)FilesCount; OnStatusReport(null, Report); } Data.Seek(DataOffset, SeekOrigin.Begin); byte[] Buffer = new byte[CompressedLength]; Data.Read(Buffer, 0, Buffer.Length); ICompression Decompressor; switch ((CompressionType)((Flags >> 1) & 3)) { case CompressionType.None: Decompressor = new NoCompression(); break; case CompressionType.ZLib: Decompressor = new ZLib(); break; case CompressionType.LZX: Decompressor = new LZX(); break; default: throw new Exception("Unknown compression!"); } Buffer = Decompressor.Decompress(Buffer, DecompressedLength); string FullName = Path.Combine(OutFolder, FileName); string DirName = Path.GetDirectoryName(FullName); if (!Directory.Exists(DirName)) { Directory.CreateDirectory(DirName); } File.WriteAllBytes(FullName + ".bin", Buffer); } Header.Close(); Data.Close(); return(true); }