Merge branch '3.0-poc' into 3.0-poc-draft

Author: jeremy-visionaid

OpenMcdf3.Benchmarks/InMemory.cs

@@ -18,80 +18,78 @@ public class InMemory : IDisposable
     private const string storageName = "MyStorage";
     private const string streamName = "MyStream";
 
-    private byte[] _readBuffer;
+    private byte[] readBuffer;
 
-    private MemoryStream _stream;
+    private readonly MemoryStream readStream = new();
+    private readonly MemoryStream writeStream = new();
 
-    [Params(Kb / 2, Kb, 4 * Kb, 128 * Kb, 256 * Kb, 512 * Kb, Kb * Kb)]
+    [Params(512, Mb /*Kb, 4 * Kb, 128 * Kb, 256 * Kb, 512 * Kb,*/)]
     public int BufferSize { get; set; }
 
     [Params(Mb /*, 8 * Mb, 64 * Mb, 128 * Mb*/)]
     public int TotalStreamSize { get; set; }
 
     public void Dispose()
     {
-        _stream?.Dispose();
+        readStream?.Dispose();
+        writeStream?.Dispose();
     }
 
     [GlobalSetup]
     public void GlobalSetup()
     {
-        _stream = new MemoryStream();
-        //_stream = File.Create("D:\\test.cfb");
-        _readBuffer = new byte[BufferSize];
+        readBuffer = new byte[BufferSize];
         CreateFile(1);
     }
 
-    [GlobalCleanup]
-    public void GlobalCleanup()
-    {
-        _stream.Dispose();
-        _stream = null;
-        _readBuffer = null;
-    }
-
     [Benchmark]
-    public void Test()
+    public void Read()
     {
-        //
-        _stream.Seek(0L, SeekOrigin.Begin);
-        //
-        using var compoundFile = RootStorage.Open(_stream);
-        using Stream cfStream = compoundFile.OpenStream(streamName + 0);
+        using var compoundFile = RootStorage.Open(readStream);
+        using CfbStream cfStream = compoundFile.OpenStream(streamName + 0);
         long streamSize = cfStream.Length;
         long position = 0L;
         while (true)
         {
             if (position >= streamSize)
                 break;
-            int read = cfStream.Read(_readBuffer, 0, _readBuffer.Length);
+            int read = cfStream.Read(readBuffer, 0, readBuffer.Length);
             position += read;
             if (read <= 0) break;
         }
+    }
+
+    [Benchmark]
+    public void Write()
+    {
+        MemoryStream memoryStream = writeStream;
+        using var storage = RootStorage.Create(memoryStream);
+        Storage subStorage = storage.CreateStorage(storageName);
+        CfbStream stream = subStorage.CreateStream(streamName + 0);
 
-        //compoundFile.Close();
+        while (stream.Length < TotalStreamSize)
+        {
+            stream.Write(readBuffer, 0, readBuffer.Length);
+        }
     }
 
     private void CreateFile(int streamCount)
     {
-        var iterationCount = TotalStreamSize / BufferSize;
+        int iterationCount = TotalStreamSize / BufferSize;
 
-        var buffer = new byte[BufferSize];
-        Array.Fill(buffer, byte.MaxValue);
+        byte[] buffer = new byte[BufferSize];
+        buffer.AsSpan().Fill(byte.MaxValue);
         const CFSConfiguration flags = CFSConfiguration.Default | CFSConfiguration.LeaveOpen;
-        using (var compoundFile = new CompoundFile(CFSVersion.Ver_3, flags))
+        using var compoundFile = new CompoundFile(CFSVersion.Ver_3, flags);
+        CFStorage st = compoundFile.RootStorage;
+        for (int streamId = 0; streamId < streamCount; ++streamId)
         {
-            //var st = compoundFile.RootStorage.AddStorage(storageName);
-            var st = compoundFile.RootStorage;
-            for (var streamId = 0; streamId < streamCount; ++streamId)
-            {
-                var sm = st.AddStream(streamName + streamId);
-
-                for (var iteration = 0; iteration < iterationCount; ++iteration) sm.Append(buffer);
-            }
-
-            compoundFile.Save(_stream);
-            compoundFile.Close();
+            CFStream sm = st.AddStream(streamName + streamId);
+            for (int iteration = 0; iteration < iterationCount; ++iteration)
+                sm.Append(buffer);
         }
+
+        compoundFile.Save(readStream);
+        compoundFile.Close();
     }
 }

OpenMcdf3.Benchmarks/OpenMcdf3.Benchmarks.csproj

@@ -1,8 +1,9 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
+    <TargetFrameworks>net8.0</TargetFrameworks>
+    <LangVersion>11.0</LangVersion>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net8.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
   </PropertyGroup>

OpenMcdf3.Benchmarks/Program.cs

@@ -2,7 +2,7 @@
 
 namespace OpenMcdf3.Benchmarks;
 
-internal class Program
+internal static class Program
 {
     private static void Main(string[] args)
     {

OpenMcdf3.Perf/OpenMcdf3.Perf.csproj

@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\OpenMcdf3\OpenMcdf3.csproj" />
+  </ItemGroup>
+
+</Project>

OpenMcdf3.Perf/Program.cs

@@ -0,0 +1,32 @@
+using System.Diagnostics;
+
+namespace OpenMcdf3.Perf;
+
+internal sealed class Program
+{
+    static void Main(string[] args)
+    {
+        var stopwatch = Stopwatch.StartNew();
+        Write(Version.V3, 512, 1024);
+        Console.WriteLine($"Elapsed: {stopwatch.Elapsed}");
+    }
+
+    static void Write(Version version, int length, int iterations)
+    {
+        // Fill with bytes equal to their position modulo 256
+        byte[] expectedBuffer = new byte[length];
+        for (int i = 0; i < length; i++)
+            expectedBuffer[i] = (byte)i;
+
+        //byte[] actualBuffer = new byte[length];
+
+        using MemoryStream memoryStream = new(2 * length);
+        using var rootStorage = RootStorage.Create(memoryStream, version);
+        using Stream stream = rootStorage.CreateStream("TestStream");
+
+        for (int i = 0; i < iterations; i++)
+        {
+            stream.Write(expectedBuffer, 0, expectedBuffer.Length);
+        }
+    }
+}

OpenMcdf3.Tests/AssemblyInfo.cs

@@ -0,0 +1,19 @@
+using System.Runtime.InteropServices;
+
+// In SDK-style projects such as this one, several assembly attributes that were historically
+// defined in this file are now automatically added during build and populated with
+// values defined in project properties. For details of which attributes are included
+// and how to customise this process see: https://aka.ms/assembly-info-properties
+
+
+// Setting ComVisible to false makes the types in this assembly not visible to COM
+// components.  If you need to access a type in this assembly from COM, set the ComVisible
+// attribute to true on that type.
+
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM.
+
+[assembly: Guid("38e3c8a7-44c7-4d13-9c30-7aa75b038c83")]
+
+[assembly: Parallelize(Scope = ExecutionScope.MethodLevel)]

OpenMcdf3.Tests/BinaryWriterTests.cs

@@ -0,0 +1,71 @@
+namespace OpenMcdf3.Tests;
+
+[TestClass]
+public sealed class BinaryWriterTests
+{
+    [TestMethod]
+    public void WriteGuid()
+    {
+        byte[] bytes = new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10 };
+        Guid expectedGuid = new(bytes);
+        using MemoryStream stream = new(bytes);
+        using (CfbBinaryWriter writer = new(stream))
+            writer.Write(expectedGuid);
+
+        stream.Position = 0;
+        using CfbBinaryReader reader = new(stream);
+        Guid actualGuid = reader.ReadGuid();
+
+        Assert.AreEqual(expectedGuid, actualGuid);
+    }
+
+    [TestMethod]
+    [DataRow("TestStream_v3_0.cfs")]
+    [DataRow("TestStream_v4_0.cfs")]
+    public void WriteHeader(string fileName)
+    {
+        using FileStream stream = File.OpenRead(fileName);
+        using CfbBinaryReader reader = new(stream);
+        Header header = reader.ReadHeader();
+
+        using MemoryStream memoryStream = new();
+        using CfbBinaryWriter writer = new(memoryStream);
+        writer.Write(header);
+
+        memoryStream.Position = 0;
+        using CfbBinaryReader reader2 = new(memoryStream);
+        Header actualHeader = reader2.ReadHeader();
+
+        Assert.AreEqual(header, actualHeader);
+    }
+
+    [TestMethod]
+    public void WriteDirectoryEntry()
+    {
+        DirectoryEntry expected = new()
+        {
+            Name = "Root Entry",
+            Type = StorageType.Storage,
+            Color = NodeColor.Red,
+            LeftSiblingId = 2,
+            RightSiblingId = 3,
+            ChildId = 4,
+            CLSID = Guid.NewGuid(),
+            StateBits = 5,
+            CreationTime = DateTime.UtcNow,
+            ModifiedTime = DateTime.UtcNow,
+            StartSectorId = 6,
+            StreamLength = 7
+        };
+
+        using MemoryStream stream = new();
+        using CfbBinaryWriter writer = new(stream);
+        writer.Write(expected);
+
+        stream.Position = 0;
+        using CfbBinaryReader reader = new(stream);
+        DirectoryEntry actual = reader.ReadDirectoryEntry(Version.V4, 0);
+
+        Assert.AreEqual(expected, actual);
+    }
+}

OpenMcdf3.Tests/DebugWriter.cs

@@ -0,0 +1,15 @@
+using System.Diagnostics;
+using System.Text;
+
+namespace OpenMcdf3.Tests;
+
+internal sealed class DebugWriter : TextWriter
+{
+    public override Encoding Encoding => Encoding.Unicode;
+
+    public override void Write(char value) => Debug.Write(value);
+
+    public override void Write(string? value) => Debug.Write(value);
+
+    public override void WriteLine(string? value) => Debug.WriteLine(value);
+}

OpenMcdf3.Tests/OpenMcdf3.Tests.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFrameworks>net48;net8.0</TargetFrameworks>
     <OutputType>Exe</OutputType>
     <LangVersion>11.0</LangVersion>
     <ImplicitUsings>enable</ImplicitUsings>
@@ -14,7 +14,7 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
-    <PackageReference Include="MSTest" Version="3.6.1" />
+    <PackageReference Include="MSTest" Version="3.6.2" />
   </ItemGroup>
 
   <ItemGroup>
@@ -68,6 +68,9 @@
     <None Update="TestStream_v3_65.cfs">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
+    <None Update="TestStream_v3_65536.cfs">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
     <None Update="TestStream_v4_0.cfs">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>

OpenMcdf3.Tests/StorageTests.cs

@@ -14,4 +14,41 @@ public void Read(string fileName, long storageCount)
         IEnumerable<EntryInfo> storageEntries = rootStorage.EnumerateEntries(StorageType.Storage);
         Assert.AreEqual(storageCount, storageEntries.Count());
     }
+
+    [TestMethod]
+    [DataRow(Version.V3, 0)]
+    [DataRow(Version.V3, 1)]
+    [DataRow(Version.V3, 2)]
+    [DataRow(Version.V3, 4)] // Required 2 sectors including root
+    [DataRow(Version.V4, 0)]
+    [DataRow(Version.V4, 1)]
+    [DataRow(Version.V4, 2)]
+    [DataRow(Version.V4, 32)] // Required 2 sectors including root
+    public void CreateStorage(Version version, int subStorageCount)
+    {
+        using MemoryStream memoryStream = new();
+        using (var rootStorage = RootStorage.Create(memoryStream, version))
+        {
+            for (int i = 0; i < subStorageCount; i++)
+                rootStorage.CreateStorage($"Test{i}");
+        }
+
+        memoryStream.Position = 0;
+        using (var rootStorage = RootStorage.Open(memoryStream))
+        {
+            IEnumerable<EntryInfo> entries = rootStorage.EnumerateEntries();
+            Assert.AreEqual(subStorageCount, entries.Count());
+        }
+    }
+
+    [TestMethod]
+    [DataRow(Version.V3)]
+    [DataRow(Version.V4)]
+    public void CreateDuplicateStorageThrowsException(Version version)
+    {
+        using MemoryStream memoryStream = new();
+        using var rootStorage = RootStorage.Create(memoryStream, version);
+        rootStorage.CreateStorage("Test");
+        Assert.ThrowsException<IOException>(() => rootStorage.CreateStorage("Test"));
+    }
 }