diff --git a/.github/dependabot.yml b/.github/dependabot.yml index 0979b29..b724c9b 100644 --- a/.github/dependabot.yml +++ b/.github/dependabot.yml @@ -21,7 +21,7 @@ updates: microsoft: patterns: ["Microsoft.Extensions.*", "System.*"] tests: - patterns: ["xunit*", "Microsoft.Testing.*", "BenchmarkDotNet*", "dotnet-coverage"] + patterns: ["xunit*", "Microsoft.Testing.*", "BenchmarkDotNet*", "dotnet-coverage", "FsCheck*"] # vpk packs the releases that the Velopack library in the app installs: keep both on the same version. velopack: patterns: ["Velopack", "vpk"] diff --git a/Directory.Packages.props b/Directory.Packages.props index 2ded224..9f006c7 100644 --- a/Directory.Packages.props +++ b/Directory.Packages.props @@ -38,5 +38,7 @@ + + diff --git a/tests/HashTool.Core.Tests/HashTool.Core.Tests.csproj b/tests/HashTool.Core.Tests/HashTool.Core.Tests.csproj index 66c82bf..f27c600 100644 --- a/tests/HashTool.Core.Tests/HashTool.Core.Tests.csproj +++ b/tests/HashTool.Core.Tests/HashTool.Core.Tests.csproj @@ -8,6 +8,7 @@ + diff --git a/tests/HashTool.Core.Tests/PropertyTests.cs b/tests/HashTool.Core.Tests/PropertyTests.cs new file mode 100644 index 0000000..493d24d --- /dev/null +++ b/tests/HashTool.Core.Tests/PropertyTests.cs @@ -0,0 +1,183 @@ +using System; +using System.Buffers.Binary; +using System.Globalization; +using System.IO; +using System.Linq; +using FsCheck; +using FsCheck.Fluent; +using HashTool.Core.Checksums; +using HashTool.Core.Hashing; +using Xunit; + +namespace HashTool.Core.Tests; + +/// +/// Property-based tests (FsCheck): every property runs on hundreds of random inputs, including text nobody would write by +/// hand, and a failure reports the smallest input that breaks it. +/// +public sealed class PropertyTests +{ + private static readonly Config Runs = Config.QuickThrowOnFailure.WithMaxTest(500); + + private static readonly char[] Noise = "abcXYZ019 _-.,;:*=()[]{}#'\"/\\\t\r\néßЖ漢".ToCharArray(); + private static readonly char[] HexDigits = "0123456789abcdef".ToCharArray(); + + private static Gen StringOf(char[] chars, int maxLength) => + Gen.Choose(0, maxLength).SelectMany(n => Gen.ArrayOf(Gen.Elements(chars), n)).Select(a => new string(a)); + + private static Gen Hex(int length) => Gen.ArrayOf(Gen.Elements(HexDigits), length).Select(a => new string(a)); + + /// A name with no leading or trailing space that does not start with ';' (a comment in SFV files). + private static Gen FileName(string extra) + { + var inner = ("abcXYZ019 _-.()[]#=*é漢" + extra).ToCharArray(); + var edge = "abcXYZ019_-.()[]é漢".ToCharArray(); + return Gen.Elements(edge).SelectMany(first => StringOf(inner, 20), (first, middle) => (first, middle)) + .SelectMany(fm => Gen.Elements(edge), (fm, last) => fm.middle.Length == 0 ? fm.first.ToString() : fm.first + fm.middle + last); + } + + private static Gen<(string Name, string Hash)[]> Lines(HashType algorithm, string extraNameChars) => + Gen.Choose(1, 6).SelectMany(n => Gen.ArrayOf(FileName(extraNameChars).Zip(Hex(HashAlgorithms.HexLength(algorithm))), n)); + + private static void AssertSameEntries(ChecksumDocument document, (string Name, string Hash)[] lines, HashType algorithm) + { + Assert.Empty(document.InvalidLines); + Assert.Equal(lines.Length, document.Entries.Count); + for (var i = 0; i < lines.Length; i++) + { + Assert.Equal(lines[i].Name, document.Entries[i].FileName); + Assert.Equal(lines[i].Hash, document.Entries[i].Hash, ignoreCase: true); + Assert.Equal(algorithm, document.Entries[i].Algorithm); + } + } + + [Fact] + public void Parser_AcceptsAnyText() + { + // Random text, and random lines shaped like checksum lines, never make the parser throw; whatever it accepts is a + // hexadecimal digest of the algorithm's length. + var lineLike = Gen.OneOf( + StringOf(Noise, 60), + Gen.Elements(HashAlgorithms.All.ToArray()).SelectMany(a => Hex(HashAlgorithms.HexLength(a))) + .SelectMany(h => StringOf(Noise, 20), (h, name) => h + " " + name), + Gen.Elements(HashAlgorithms.All.ToArray()).SelectMany(a => Hex(HashAlgorithms.HexLength(a)), (a, h) => (a, h)) + .SelectMany(x => StringOf(Noise, 20), (x, name) => $"{HashAlgorithms.BsdTag(x.a)} ({name}) = {x.h}")); + var text = Gen.ListOf(lineLike).Select(l => string.Join("\n", l)); + + Check.One(Runs, Prop.ForAll(text.ToArbitrary(), input => + { + foreach (var preferSfv in new[] { false, true }) + { + var document = ChecksumParser.Parse(input, preferSfv: preferSfv); + Assert.All(document.Entries, e => + { + Assert.True(HashMatcher.IsHex(e.Hash)); + if (e.Algorithm is { } algorithm) Assert.Equal(HashAlgorithms.HexLength(algorithm), e.Hash.Length); + }); + } + })); + } + + [Fact] + public void GnuFiles_ReadBackWhatWasWritten_IncludingBackslashesAndLineBreaksInNames() + { + var input = Gen.Elements(HashAlgorithms.All.ToArray()).SelectMany(a => Lines(a, "\\\n"), (a, lines) => (a, lines)); + + Check.One(Runs, Prop.ForAll(input.ToArbitrary(), x => + { + var text = ChecksumWriter.Write(x.lines.Select(l => new ChecksumLine(l.Name, x.a, l.Hash)), ExportFormat.Gnu); + AssertSameEntries(ChecksumParser.Parse(text, fileNameHint: x.a), x.lines, x.a); + })); + } + + [Fact] + public void BsdFiles_ReadBackWhatWasWritten() + { + var input = Gen.Elements(HashAlgorithms.All.ToArray()).SelectMany(a => Lines(a, ""), (a, lines) => (a, lines)); + + Check.One(Runs, Prop.ForAll(input.ToArbitrary(), x => + { + var text = ChecksumWriter.Write(x.lines.Select(l => new ChecksumLine(l.Name, x.a, l.Hash)), ExportFormat.Bsd); + AssertSameEntries(ChecksumParser.Parse(text), x.lines, x.a); + })); + } + + [Fact] + public void SfvFiles_ReadBackWhatWasWritten() + { + Check.One(Runs, Prop.ForAll(Lines(HashType.CRC32, "").ToArbitrary(), lines => + { + var text = ChecksumWriter.Write(lines.Select(l => new ChecksumLine(l.Name, HashType.CRC32, l.Hash)), ExportFormat.Sfv, + HexCase.Upper); + AssertSameEntries(ChecksumParser.Parse(text, preferSfv: true), lines, HashType.CRC32); + })); + } + + [Fact] + public void ResolvePath_NeverReturnsANetworkOrDevicePath() + { + var prefixes = new[] { "", "//", "\\\\", "\\\\?\\", "/dev/", "/proc/", "C:", "../", "./", "a/../../" }; + var name = Gen.Elements(prefixes).SelectMany(_ => StringOf(Noise.Append((char)0).ToArray(), 30), (prefix, rest) => prefix + rest); + var baseDirectory = Path.GetTempPath(); + + Check.One(Runs, Prop.ForAll(name.ToArbitrary(), fileName => + { + var resolved = new ChecksumEntry("00000000", fileName, HashType.CRC32, false, 1).ResolvePath(baseDirectory); + if (fileName.StartsWith("//", StringComparison.Ordinal) || fileName.StartsWith("\\\\", StringComparison.Ordinal) || + fileName.Contains((char)0, StringComparison.Ordinal)) + Assert.Null(resolved); + if (resolved is not null) + { + Assert.True(ChecksumEntry.IsSafePath(resolved), resolved); + Assert.True(Path.IsPathFullyQualified(resolved), resolved); + } + })); + } + + [Fact] + public void Matcher_IgnoresCaseSpacesAndPrefix() + { + var digest = Gen.ArrayOf(Gen.Choose(0, 255).Select(b => (byte)b), 32); + + Check.One(Runs, Prop.ForAll(digest.ToArbitrary(), bytes => + { + var actual = new HashResult(HashType.SHA256, bytes); + var hex = actual.ToHex(HexCase.Lower); + foreach (var expected in new[] { hex, hex.ToUpperInvariant(), "0x" + hex, $" {hex[..32]} {hex[32..]}\t" }) + Assert.Equal(HashMatch.Match, HashMatcher.Compare(expected, actual)); + Assert.Equal(HashMatch.LengthMismatch, HashMatcher.Compare(hex[..^2], actual)); + Assert.Equal(HashMatch.InvalidExpected, HashMatcher.Compare("g" + hex[1..], actual)); + })); + } + + [Fact] + public void Matcher_AcceptsTheReversedCrc32OfHashTool11() + { + var value = Gen.Choose(0, int.MaxValue).Zip(Gen.Choose(0, 1), (low, high) => (uint)low | ((uint)high << 31)); + + Check.One(Runs, Prop.ForAll(value.ToArbitrary(), crc => + { + var digest = new byte[4]; + BinaryPrimitives.WriteUInt32BigEndian(digest, crc); + var reversed = BinaryPrimitives.ReverseEndianness(crc).ToString("x8", CultureInfo.InvariantCulture); + var expected = BinaryPrimitives.ReverseEndianness(crc) == crc ? HashMatch.Match : HashMatch.LegacyByteOrderMatch; + Assert.Equal(expected, HashMatcher.Compare(reversed, new HashResult(HashType.CRC32, digest))); + })); + } + + [Fact] + public void LineBreaks_AreAllWrittenTheChosenWay() + { + var input = StringOf(Noise, 80).Zip(Gen.Elements(LineBreak.Lf, LineBreak.CrLf)); + + Check.One(Runs, Prop.ForAll(input.ToArbitrary(), x => + { + var (text, lineBreak) = x; + var normalized = TextHashing.NormalizeLineBreaks(text, lineBreak); + Assert.Equal(normalized, TextHashing.NormalizeLineBreaks(normalized, lineBreak)); + if (lineBreak == LineBreak.Lf) Assert.DoesNotContain('\r', normalized); + else Assert.Equal(normalized.Count(c => c == '\r'), normalized.Split("\r\n").Length - 1); + Assert.Equal(2 * normalized.Length, TextHashing.GetBytes(text, TextEncodingKind.Utf16LittleEndian, lineBreak).Length); + })); + } +}