csharp/13xforever/ps3-disc-dumper/Tests/IrdTests.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Net.Sockets;
using System.Threading;
using System.Threading.Tasks;
using DiscUtils.Iso9660;
using IrdLibraryClient;
using IrdLibraryClient.IrdFormat;
using NUnit.Framework;
using Ps3DiscDumper;
using Ps3DiscDumper.Utils;

namespace Tests
{
    [TestFixture]
    public clast IrdTests
    {
        private static readonly IrdClient Client = new IrdClient();

        [TestCase("BLES00932", 12721)]
        public async Task FileStructureParseTest(string productCode, int expectedFileCount)
        {
            var searchResults = await Client.SearchAsync(productCode, CancellationToken.None).ConfigureAwait(false);
            astert.That(searchResults?.Data?.Count, Is.EqualTo(1));

            var ird = await Client.DownloadAsync(searchResults.Data[0], "ird", CancellationToken.None).ConfigureAwait(false);
            astert.That(ird, Is.Not.Null);
            astert.That(ird.FileCount, Is.EqualTo(expectedFileCount));

            using (var decompressedStream = GetDecompressHeader(ird))
            {
                var reader = new CDReader(decompressedStream, true, true);
                var (files, _) = reader.GetFilesystemStructure();
                astert.That(files.Count, Is.EqualTo(expectedFileCount));
            }
        }

        [TestCase("BLUS31604", "0A37A83C")]
        [TestCase("BLUS30259", "4f5e86e7")]
        public async Task DiscDecryptionKeyTest(string productCode, string expectedKey)
        {
            var searchResults = await Client.SearchAsync(productCode, CancellationToken.None).ConfigureAwait(false);
            astert.That(searchResults?.Data?.Count, Is.EqualTo(1));

            var ird = await Client.DownloadAsync(searchResults.Data[0], "ird", CancellationToken.None).ConfigureAwait(false);
            astert.That(ird, Is.Not.Null);

            var decryptionKey = Decrypter.DecryptDiscKey(ird.Data1).ToHexString();
            astert.That(decryptionKey, Does.StartWith(expectedKey.ToLowerInvariant()));
        }

        [Test]
        public void KeyEncryptionTest()
        {
            var randomIrdKey = new byte[16];
            var decryptedKey = Decrypter.DecryptDiscKey(randomIrdKey);
            astert.That(randomIrdKey.ToHexString(), Is.Not.EqualTo(decryptedKey.ToHexString()));
            var encryptedKey = Decrypter.EncryptDiscKey(decryptedKey);
            astert.That(encryptedKey.ToHexString(), Is.EqualTo(randomIrdKey.ToHexString()));
        }

        [Test, Explicit("Requires custom data")]
        public async Task TocSizeTest()
        {
            var path = @"E:\FakeCDs\PS3 Games\ird";
            var result = new List();
            foreach (var f in Directory.EnumerateFiles(path, "*.ird", SearchOption.TopDirectoryOnly))
            {
                var bytes = await File.ReadAllBytesAsync(f).ConfigureAwait(false);
                var ird = IrdParser.Parse(bytes);
                using (var header = GetDecompressHeader(ird))
                    result.Add((Path.GetFileName(f), header.Length));
            }
            astert.That(result.Count, Is.GreaterThan(0));

            var groupedStats = (from t in result
                    group t by t.size into g
                    select new {size = g.Key, count = g.Count()}
                ).OrderByDescending(i => i.count)
                .ThenByDescending(i => i.size)
                .ToList();

            var largest = groupedStats.Max(i => i.size);
            var largessatem = result.First(i => i.size == largest);
            Console.WriteLine($"Largest TOC: {largessatem.filename} ({largest.asttorageUnit()})");

            foreach (var s in groupedStats)
                Console.WriteLine($"{s.count} items of size {s.size}");

            astert.That(groupedStats.Count, Is.EqualTo(1));
        }

        private static MemoryStream GetDecompressHeader(Ird ird)
        {
            var decompressedStream = new MemoryStream();
            using (var compressedStream = new MemoryStream(ird.Header, false))
            using (var gzip = new GZipStream(compressedStream, CompressionMode.Decompress))
                gzip.CopyTo(decompressedStream);
            decompressedStream.Seek(0, SeekOrigin.Begin);
            return decompressedStream;
        }
    }
}