Coverage

OpenMcdf.Tests/DirectoryEntryTests.cs

@@ -0,0 +1,28 @@
+namespace OpenMcdf.Tests;
+
+[TestClass]
+public sealed class DirectoryEntryTests
+{
+    [TestMethod]
+    [DataRow("", "", 0)]
+    [DataRow("", "longer", -1)]
+    [DataRow("longer", "", 1)]
+    [DataRow("a", "a", 0)]
+    [DataRow("a", "b", -1)]
+    [DataRow("b", "a", 1)]
+    public void EnumerateEntryInfos(string nameX, string nameY, int expectedCompare)
+    {
+        DirectoryEntry entryX = new()
+        {
+            NameString = nameX,
+        };
+
+        DirectoryEntry entryY = new()
+        {
+            NameString = nameY,
+        };
+
+        int actualCompare = DirectoryEntryComparer.Default.Compare(entryX, entryY);
+        Assert.AreEqual(expectedCompare, actualCompare);
+    }
+}

OpenMcdf.Tests/StorageTests.cs

@@ -41,14 +41,14 @@ public void OpenStorage(string fileName)
     public void CreateStorage(Version version, int subStorageCount)
     {
         using MemoryStream memoryStream = new();
+
+        // Test adding right sibling
         using (var rootStorage = RootStorage.Create(memoryStream, version, StorageModeFlags.LeaveOpen))
         {
             for (int i = 0; i < subStorageCount; i++)
                 rootStorage.CreateStorage($"Test{i}");
-            rootStorage.TraceDirectoryEntries(DebugWriter.Default);
         }
 
-        memoryStream.Position = 0;
         using (var rootStorage = RootStorage.Open(memoryStream, StorageModeFlags.LeaveOpen))
         {
             IEnumerable<EntryInfo> entries = rootStorage.EnumerateEntries();
@@ -58,6 +58,22 @@ public void CreateStorage(Version version, int subStorageCount)
                 rootStorage.OpenStorage($"Test{i}");
         }
 
+        // Test adding left sibling
+        using (var rootStorage = RootStorage.Create(memoryStream, version, StorageModeFlags.LeaveOpen))
+        {
+            for (int i = 0; i < subStorageCount; i++)
+                rootStorage.CreateStorage($"Test{subStorageCount - i}");
+        }
+
+        using (var rootStorage = RootStorage.Open(memoryStream, StorageModeFlags.LeaveOpen))
+        {
+            IEnumerable<EntryInfo> entries = rootStorage.EnumerateEntries();
+            Assert.AreEqual(subStorageCount, entries.Count());
+
+            for (int i = 0; i < subStorageCount; i++)
+                rootStorage.OpenStorage($"Test{subStorageCount - i}");
+        }
+
 #if WINDOWS
         using (var rootStorage = StructuredStorage.Storage.Open(memoryStream))
         {
@@ -66,12 +82,55 @@ public void CreateStorage(Version version, int subStorageCount)
 
             for (int i = 0; i < subStorageCount; i++)
             {
-                using StructuredStorage.Storage storage = rootStorage.OpenStorage($"Test{i}");
+                using StructuredStorage.Storage storage = rootStorage.OpenStorage($"Test{subStorageCount - i}");
             }
         }
 #endif
     }
 
+    [TestMethod]
+    public void CreateInvalidStorageName()
+    {
+        using MemoryStream memoryStream = new();
+        using var rootStorage = RootStorage.Create(memoryStream);
+        Assert.ThrowsException<ArgumentException>(() => rootStorage.CreateStorage("!"));
+        Assert.ThrowsException<ArgumentException>(() => rootStorage.CreateStorage("/"));
+        Assert.ThrowsException<ArgumentException>(() => rootStorage.CreateStorage(":"));
+        Assert.ThrowsException<ArgumentException>(() => rootStorage.CreateStorage("\\"));
+    }
+
+    [TestMethod]
+    [DataRow(Version.V3, 0)]
+    [DataRow(Version.V3, 1)]
+    [DataRow(Version.V4, 0)]
+    [DataRow(Version.V4, 1)]
+    public void CreateStorageFile(Version version, int subStorageCount)
+    {
+        string fileName = Path.GetTempFileName();
+
+        try
+        {
+            using (var rootStorage = RootStorage.Create(fileName, version))
+            {
+                for (int i = 0; i < subStorageCount; i++)
+                    rootStorage.CreateStorage($"Test{i}");
+            }
+
+            using (var rootStorage = RootStorage.OpenRead(fileName))
+            {
+                IEnumerable<EntryInfo> entries = rootStorage.EnumerateEntries();
+                Assert.AreEqual(subStorageCount, entries.Count());
+
+                for (int i = 0; i < subStorageCount; i++)
+                    rootStorage.OpenStorage($"Test{i}");
+            }
+        }
+        finally
+        {
+            File.Delete(fileName);
+        }
+    }
+
     [TestMethod]
     [DataRow(Version.V3)]
     [DataRow(Version.V4)]
@@ -99,6 +158,8 @@ public void DeleteSingleStorage(Version version)
         {
             rootStorage.Delete("Test");
             Assert.AreEqual(0, rootStorage.EnumerateEntries().Count());
+
+            rootStorage.Delete("NonExistentEntry");
         }
 
         using (var rootStorage = RootStorage.Open(memoryStream))
@@ -191,15 +252,17 @@ public void DeleteStorageRecursively(Version version)
         using MemoryStream memoryStream = new();
         using (var rootStorage = RootStorage.Create(memoryStream, version, StorageModeFlags.LeaveOpen))
         {
-            Storage storage = rootStorage.CreateStorage("Test");
+            Storage storage = rootStorage.CreateStorage("Storage");
             Assert.AreEqual(1, rootStorage.EnumerateEntries().Count());
 
-            using CfbStream stream = storage.CreateStream("Test");
+            Storage subStorage = storage.CreateStorage("SubStorage");
+            using CfbStream subStream = subStorage.CreateStream("SubStream");
+            Assert.AreEqual(1, storage.EnumerateEntries().Count());
         }
 
         using (var rootStorage = RootStorage.Open(memoryStream, StorageModeFlags.LeaveOpen))
         {
-            rootStorage.Delete("Test");
+            rootStorage.Delete("Storage");
             Assert.AreEqual(0, rootStorage.EnumerateEntries().Count());
         }
 
@@ -235,20 +298,66 @@ public void Consolidate(Version version)
     {
         byte[] buffer = new byte[4096];
 
+        string fileName = Path.GetTempFileName();
+
+        try
+        {
+            using MemoryStream memoryStream = new();
+            using var rootStorage = RootStorage.Create(memoryStream, version, StorageModeFlags.LeaveOpen);
+            using (CfbStream stream = rootStorage.CreateStream("Test"))
+                stream.Write(buffer, 0, buffer.Length);
+
+            Assert.AreEqual(1, rootStorage.EnumerateEntries().Count());
+
+            rootStorage.Flush(true);
+
+            int originalMemoryStreamLength = (int)memoryStream.Length;
+
+            rootStorage.Delete("Test");
+
+            rootStorage.Flush(true);
+
+            Assert.IsTrue(originalMemoryStreamLength > memoryStream.Length);
+        }
+        finally
+        {
+            File.Delete(fileName);
+        }
+    }
+
+    [TestMethod]
+    [DataRow(Version.V3)]
+    [DataRow(Version.V4)]
+    public void GetAndSetMetadata(Version version)
+    {
         using MemoryStream memoryStream = new();
-        using var rootStorage = RootStorage.Create(memoryStream, version, StorageModeFlags.LeaveOpen);
-        CfbStream stream = rootStorage.CreateStream("Test");
-        Assert.AreEqual(1, rootStorage.EnumerateEntries().Count());
 
-        stream.Write(buffer, 0, buffer.Length);
-        rootStorage.Flush();
+        Guid guid = Guid.NewGuid();
+        DateTime now = DateTime.UtcNow;
+
+        using (var rootStorage = RootStorage.Create(memoryStream, version, StorageModeFlags.LeaveOpen))
+        {
+            Storage storage = rootStorage.CreateStorage("Storage");
 
-        int originalMemoryStreamLength = (int)memoryStream.Length;
+            Assert.AreEqual(Guid.Empty, storage.CLISD);
+            Assert.AreNotEqual(DirectoryEntry.ZeroFileTime, storage.CreationTime);
+            Assert.AreNotEqual(DirectoryEntry.ZeroFileTime, storage.ModifiedTime);
+            Assert.AreEqual(0U, storage.StateBits);
 
-        rootStorage.Delete("Test");
+            storage.CLISD = guid;
+            storage.CreationTime = now;
+            storage.ModifiedTime = now;
+            storage.StateBits = 1U;
+        }
 
-        rootStorage.Flush(true);
+        using (var rootStorage = RootStorage.Open(memoryStream))
+        {
+            Storage storage = rootStorage.OpenStorage("Storage");
 
-        Assert.IsTrue(originalMemoryStreamLength > memoryStream.Length);
+            Assert.AreEqual(guid, storage.CLISD);
+            Assert.AreEqual(now, storage.CreationTime);
+            Assert.AreEqual(now, storage.ModifiedTime);
+            Assert.AreEqual(1U, storage.StateBits);
+        }
     }
 }

OpenMcdf.Tests/StreamExtensions.cs

@@ -0,0 +1,27 @@
+namespace OpenMcdf.Tests;
+
+internal static class StreamExtensions
+{
+    public static void Write(this Stream stream, byte[] buffer, WriteMode mode)
+    {
+#if (!NETSTANDARD2_0 && !NETFRAMEWORK)
+        switch (mode)
+        {
+            case WriteMode.Array:
+                stream.Write(buffer, 0, buffer.Length);
+                break;
+            case WriteMode.Span:
+                stream.Write(buffer);
+                break;
+            case WriteMode.SingleByte:
+                {
+                    for (int i = 0; i < buffer.Length; i++)
+                        stream.WriteByte(buffer[i]);
+                    break;
+                }
+        }
+#else
+        stream.Write(buffer, 0, buffer.Length);
+#endif
+    }
+}