test: repeatability and refactoring

test/ICSharpCode.SharpZipLib.Tests/BZip2/Bzip2Tests.cs

@@ -1,7 +1,6 @@
 using ICSharpCode.SharpZipLib.BZip2;
 using ICSharpCode.SharpZipLib.Tests.TestSupport;
 using NUnit.Framework;
-using System;
 using System.IO;
 
 namespace ICSharpCode.SharpZipLib.Tests.BZip2
@@ -24,34 +23,30 @@ public void BasicRoundTrip()
 		{
 			var ms = new MemoryStream();
 			var outStream = new BZip2OutputStream(ms);
+
+			var buf = Utils.GetDummyBytes(size: 10000, RandomSeed);
 
-			byte[] buf = new byte[10000];
-			var rnd = new Random(RandomSeed);
-			rnd.NextBytes(buf);
-
-			outStream.Write(buf, 0, buf.Length);
+			outStream.Write(buf, offset: 0, buf.Length);
 			outStream.Close();
 			ms = new MemoryStream(ms.GetBuffer());
-			ms.Seek(0, SeekOrigin.Begin);
+			ms.Seek(offset: 0, SeekOrigin.Begin);
 
-			using (BZip2InputStream inStream = new BZip2InputStream(ms))
+			using BZip2InputStream inStream = new BZip2InputStream(ms);
+			var buf2 = new byte[buf.Length];
+			var pos = 0;
+			while (true)
 			{
-				byte[] buf2 = new byte[buf.Length];
-				int pos = 0;
-				while (true)
+				var numRead = inStream.Read(buf2, pos, count: 4096);
+				if (numRead <= 0)
 				{
-					int numRead = inStream.Read(buf2, pos, 4096);
-					if (numRead <= 0)
-					{
-						break;
-					}
-					pos += numRead;
+					break;
 				}
+				pos += numRead;
+			}
 
-				for (int i = 0; i < buf.Length; ++i)
-				{
-					Assert.AreEqual(buf2[i], buf[i]);
-				}
+			for (var i = 0; i < buf.Length; ++i)
+			{
+				Assert.AreEqual(buf2[i], buf[i]);
 			}
 		}
 

test/ICSharpCode.SharpZipLib.Tests/Base/InflaterDeflaterTests.cs

@@ -60,20 +60,10 @@ private MemoryStream Deflate(byte[] data, int level, bool zlib)
 			return memoryStream;
 		}
 
-		private static byte[] GetRandomTestData(int size)
-		{
-			byte[] buffer = new byte[size];
-			var rnd = new Random(RandomSeed);
-			rnd.NextBytes(buffer);
-
-			return buffer;
-		}
-
 		private void RandomDeflateInflate(int size, int level, bool zlib)
 		{
-			byte[] buffer = GetRandomTestData(size);
-
-			MemoryStream ms = Deflate(buffer, level, zlib);
+			var buffer =  Utils.GetDummyBytes(size, RandomSeed);
+			var ms = Deflate(buffer, level, zlib);
 			Inflate(ms, buffer, level, zlib);
 		}
 
@@ -130,9 +120,8 @@ private async Task<MemoryStream> DeflateAsync(byte[] data, int level, bool zlib)
 
 		private async Task RandomDeflateInflateAsync(int size, int level, bool zlib)
 		{
-			byte[] buffer = GetRandomTestData(size);
-
-			MemoryStream ms = await DeflateAsync(buffer, level, zlib);
+			var buffer = Utils.GetDummyBytes(size, RandomSeed);
+			var ms = await DeflateAsync(buffer, level, zlib);
 			await InflateAsync(ms, buffer, level, zlib);
 		}
 
@@ -179,58 +168,56 @@ public void InflateDeflateZlib([Range(0, 9)] int level)
 		[Category("Async")]
 		public async Task InflateDeflateZlibAsync([Range(0, 9)] int level)
 		{
-			await RandomDeflateInflateAsync(100000, level, true);
+			await RandomDeflateInflateAsync(size: 100000, level, zlib: true);
 		}
 
 		private delegate void RunCompress(byte[] buffer);
 
-		private int runLevel;
-		private bool runZlib;
-		private long runCount;
-		private readonly Random runRandom = new Random(RandomSeed);
+		private int _runLevel;
+		private bool _runZlib;
 
 		private void DeflateAndInflate(byte[] buffer)
 		{
-			++runCount;
-			MemoryStream ms = Deflate(buffer, runLevel, runZlib);
-			Inflate(ms, buffer, runLevel, runZlib);
+			var ms = Deflate(buffer, _runLevel, _runZlib);
+			Inflate(ms, buffer, _runLevel, _runZlib);
 		}
 
-		private void TryVariants(RunCompress test, byte[] buffer, int index)
+		private void TryVariants(RunCompress test, byte[] buffer, Random random, int index)
 		{
 			int worker = 0;
 			while (worker <= 255)
 			{
 				buffer[index] = (byte)worker;
 				if (index < buffer.Length - 1)
 				{
-					TryVariants(test, buffer, index + 1);
+					TryVariants(test, buffer, random, index + 1);
 				}
 				else
 				{
 					test(buffer);
 				}
 
-				worker += runRandom.Next(256);
+				worker += random.Next(maxValue: 256);
 			}
 		}
 
 		private void TryManyVariants(int level, bool zlib, RunCompress test, byte[] buffer)
 		{
-			runLevel = level;
-			runZlib = zlib;
-			TryVariants(test, buffer, 0);
+			var random = new Random(RandomSeed);
+			_runLevel = level;
+			_runZlib = zlib;
+			TryVariants(test, buffer, random, 0);
 		}
 
 		// TODO: Fix this
-		//[Test]
-		//[Category("Base")]
-		//public void SmallBlocks()
-		//{
-		//	byte[] buffer = new byte[10];
-		//	Array.Clear(buffer, 0, buffer.Length);
-		//	TryManyVariants(0, false, new RunCompress(DeflateAndInflate), buffer);
-		//}
+		[Test]
+		[Category("Base")]
+		[Explicit("Long-running")]
+		public void SmallBlocks()
+		{
+			var buffer = new byte[10];
+			TryManyVariants(level: 0, zlib: false, DeflateAndInflate, buffer);
+		}
 
 		/// <summary>
 		/// Basic inflate/deflate test