Add more tests

Author: xPaw

ValvePak/ValvePak.Test/MemoryMapTest.cs

@@ -84,5 +84,28 @@ public void ReturnsCorrectStreamsWhenUsingMemoryStream()
 			Assert.That(stream2, Is.InstanceOf<MemoryStream>());
 			VerifyProto(stream2);
 		}
+
+		[Test]
+		public void GetMemoryMappedStreamIfPossibleThrowsOnNullEntry()
+		{
+			using var package = new Package();
+			Assert.Throws<ArgumentNullException>(() => package.GetMemoryMappedStreamIfPossible(null!));
+		}
+
+		[Test]
+		public void GetMemoryMappedStreamIfPossibleWithPreloadedBytesReturnsMemoryStream()
+		{
+			var path = Path.Combine(TestContext.CurrentContext.TestDirectory, "Files", "preload.vpk");
+
+			using var package = new Package();
+			package.Read(path);
+
+			var entry = package.FindEntry("lorem.txt");
+			Assert.That(entry, Is.Not.Null);
+			Assert.That(entry.SmallData, Has.Length.GreaterThan(0));
+
+			using var stream = package.GetMemoryMappedStreamIfPossible(entry);
+			Assert.That(stream, Is.InstanceOf<MemoryStream>());
+		}
 	}
 }

ValvePak/ValvePak.Test/PackageTest.cs

@@ -534,6 +534,95 @@ public void TestVerifyChunkHashesBlake3()
 			Assert.DoesNotThrow(() => package.VerifyChunkHashes(null));
 		}
 
+		[Test]
+		public void SetFileNameStripsVpkExtensionAndDirSuffix()
+		{
+			using var package1 = new Package();
+			package1.SetFileName("foo_dir.vpk");
+
+			using (Assert.EnterMultipleScope())
+			{
+				Assert.That(package1.FileName, Is.EqualTo("foo"));
+				Assert.That(package1.IsDirVPK, Is.True);
+			}
+
+			using var package2 = new Package();
+			package2.SetFileName("bar.vpk");
+
+			using (Assert.EnterMultipleScope())
+			{
+				Assert.That(package2.FileName, Is.EqualTo("bar"));
+				Assert.That(package2.IsDirVPK, Is.False);
+			}
+		}
+
+		[Test]
+		public void VerifyHashesThrowsOnVersion1()
+		{
+			using var package = new Package();
+			package.SetFileName("a.vpk");
+
+			// VPK v1 header: correct magic, version 1, tree size 1
+			using var ms = new MemoryStream([0x34, 0x12, 0xAA, 0x55, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00]);
+			package.Read(ms);
+
+			var ex = Assert.Throws<InvalidDataException>(() => package.VerifyHashes());
+			Assert.That(ex.Message, Is.EqualTo("Only version 2 is supported."));
+		}
+
+		[Test]
+		public void VerifyFileChecksumsDoesNothingOnNullEntries()
+		{
+			using var package = new Package();
+			Assert.DoesNotThrow(() => package.VerifyFileChecksums());
+		}
+
+		[Test]
+		public void VerifyFileChecksumsWithProgressReporter()
+		{
+			var path = Path.Combine(TestContext.CurrentContext.TestDirectory, "Files", "broken_dir.vpk");
+
+			using var package = new Package();
+			package.Read(path);
+
+			var reports = new List<string>();
+			var progress = new Progress<string>(report => reports.Add(report));
+			package.VerifyFileChecksums(progress);
+
+			Assert.That(reports, Is.Not.Empty);
+		}
+
+		[Test]
+		public void DisposeCanBeCalledMultipleTimes()
+		{
+			var package = new Package();
+			package.Dispose();
+			Assert.DoesNotThrow(() => package.Dispose());
+		}
+
+		[Test]
+		public void IsSignatureValidReturnsTrueWhenNoSignature()
+		{
+			using var package = new Package();
+			Assert.That(package.IsSignatureValid(), Is.True);
+		}
+
+		[Test]
+		public void IsSignatureValidReturnsFalseAfterDispose()
+		{
+			var path = Path.Combine(TestContext.CurrentContext.TestDirectory, "Files", "platform_misc_dir.vpk");
+
+			var package = new Package();
+			package.Read(path);
+
+			Assert.That(package.Signature, Is.Not.Null);
+			Assert.That(package.PublicKey, Is.Not.Null);
+
+			package.Dispose();
+
+			Assert.That(package.IsSignatureValid(), Is.False);
+		}
+
 		private static void TestVPKExtraction(string path)
 		{
 			using var package = new Package();

ValvePak/ValvePak.Test/WriteTest.cs

@@ -1,3 +1,4 @@
+using System;
 using System.IO;
 using System.Text;
 using NUnit.Framework;
@@ -164,5 +165,145 @@ public void NormalizesSlashes()
 				Assert.That(file.FileName, Is.EqualTo("d"));
 			}
 		}
+
+		[Test]
+		public void WriteThrowsWhenIsDirVPK()
+		{
+			var path = Path.Combine(TestContext.CurrentContext.TestDirectory, "Files", "steamdb_test_dir.vpk");
+
+			using var package = new Package();
+			package.Read(path);
+
+			using var output = new MemoryStream();
+			var ex = Assert.Throws<InvalidOperationException>(() => package.Write(output));
+			Assert.That(ex.Message, Is.EqualTo("This package was opened from a _dir.vpk, writing back is currently unsupported."));
+		}
+
+		[Test]
+		public void WriteThrowsOnNonSeekableStream()
+		{
+			using var package = new Package();
+			package.AddFile("test.txt", Encoding.UTF8.GetBytes("hello"));
+
+			using var nonSeekable = new NonSeekableStream();
+			var ex = Assert.Throws<InvalidOperationException>(() => package.Write(nonSeekable));
+			Assert.That(ex.Message, Is.EqualTo("Stream must be seekable and readable."));
+		}
+
+		[Test]
+		public void AddFileThrowsOnNullFilePath()
+		{
+			using var package = new Package();
+			Assert.Throws<ArgumentNullException>(() => package.AddFile(null!, []));
+		}
+
+		[Test]
+		public void RemoveFileThrowsOnNullEntry()
+		{
+			using var package = new Package();
+			Assert.Throws<ArgumentNullException>(() => package.RemoveFile(null!));
+		}
+
+		[Test]
+		public void RemoveFileReturnsFalseOnEmptyPackage()
+		{
+			using var package = new Package();
+			var result = package.RemoveFile(new PackageEntry
+			{
+				FileName = "test",
+				TypeName = "txt",
+				DirectoryName = " ",
+			});
+			Assert.That(result, Is.False);
+		}
+
+		[Test]
+		public void WriteAndVerifyRoundTrip()
+		{
+			using var output = new MemoryStream();
+
+			using (var package = new Package())
+			{
+				package.AddFile("hello.txt", Encoding.UTF8.GetBytes("world"));
+				package.AddFile("folder/image.jpg", Encoding.UTF8.GetBytes("not really a jpg"));
+				package.Write(output);
+			}
+
+			output.Position = 0;
+
+			using var readBack = new Package();
+			readBack.SetFileName("test.vpk");
+			readBack.Read(output);
+
+			using (Assert.EnterMultipleScope())
+			{
+				Assert.That(readBack.Version, Is.EqualTo(2));
+				Assert.That(readBack.HeaderSize, Is.GreaterThan(0u));
+				Assert.That(readBack.TreeSize, Is.GreaterThan(0u));
+				Assert.That(readBack.FileDataSectionSize, Is.GreaterThan(0u));
+				Assert.That(readBack.OtherMD5SectionSize, Is.EqualTo(48u));
+			}
+
+			Assert.DoesNotThrow(() => readBack.VerifyHashes());
+		}
+
+		[Test]
+		public void WriteToFile()
+		{
+			var tempFile = Path.GetTempFileName();
+
+			try
+			{
+				using (var package = new Package())
+				{
+					package.AddFile("test.txt", Encoding.UTF8.GetBytes("hello from file"));
+					package.Write(tempFile);
+				}
+
+				using var readBack = new Package();
+				readBack.Read(tempFile);
+				readBack.VerifyHashes();
+
+				var entry = readBack.FindEntry("test.txt");
+				Assert.That(entry, Is.Not.Null);
+
+				readBack.ReadEntry(entry, out var data);
+				Assert.That(Encoding.UTF8.GetString(data), Is.EqualTo("hello from file"));
+			}
+			finally
+			{
+				File.Delete(tempFile);
+			}
+		}
+
+		[Test]
+		public void RemoveFileReturnsFalseForWrongType()
+		{
+			using var package = new Package();
+			package.AddFile("test.txt", []);
+
+			var result = package.RemoveFile(new PackageEntry
+			{
+				FileName = "test",
+				TypeName = "jpg",
+				DirectoryName = " ",
+			});
+
+			Assert.That(result, Is.False);
+		}
+
+		private sealed class NonSeekableStream : Stream
+		{
+			public override bool CanRead => true;
+			public override bool CanSeek => false;
+			public override bool CanWrite => true;
+			public override long Length => 0;
+			public override long Position { get => 0; set { } }
+			public override void Flush() { }
+			public override int Read(byte[] buffer, int offset, int count) => 0;
+			public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException();
+			public override void SetLength(long value) { }
+			public override void Write(byte[] buffer, int offset, int count) { }
+		}
 	}
 }

ValvePak/ValvePak/Package.Verify.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Linq;
 using System.Security.Cryptography;
@@ -11,6 +12,7 @@ namespace SteamDatabase.ValvePak
 	/// </summary>
 	public partial class Package : IDisposable
 	{
+		[ExcludeFromCodeCoverage]
 		sealed class SubStream : Stream, IDisposable
 		{
 #pragma warning disable CA2213 // Disposable fields should be disposed