Add and use FileFormatException

jeremy-visionaid · jeremy-visionaid · commit 5390c30283a2 · 2024-11-19T19:57:47.000+13:00
diff --git a/OpenMcdf.Tests/BinaryReaderTests.cs b/OpenMcdf.Tests/BinaryReaderTests.cs
@@ -39,31 +39,26 @@ public void ReadHeader(string fileName)
 
         stream.CopyAllTo(memoryStream);
         memoryStream.WriteByte(1); // Corrupt signature
-        Assert.ThrowsException<FormatException>(() => reader.ReadHeader());
+        Assert.ThrowsException<FileFormatException>(() => reader.ReadHeader());
 
         stream.CopyAllTo(memoryStream);
         memoryStream.Position = 24;
         memoryStream.WriteByte(1); // Corrupt CLSID
-        Assert.ThrowsException<FormatException>(() => reader.ReadHeader());
+        Assert.ThrowsException<FileFormatException>(() => reader.ReadHeader());
 
         stream.CopyAllTo(memoryStream);
         memoryStream.Position = 26;
         memoryStream.WriteByte(1); // Corrupt Major version
-        Assert.ThrowsException<FormatException>(() => reader.ReadHeader());
+        Assert.ThrowsException<FileFormatException>(() => reader.ReadHeader());
 
         stream.CopyAllTo(memoryStream);
         memoryStream.Position = 28;
         memoryStream.WriteByte(1); // Corrupt byte order
-        Assert.ThrowsException<FormatException>(() => reader.ReadHeader());
+        Assert.ThrowsException<FileFormatException>(() => reader.ReadHeader());
 
         stream.CopyAllTo(memoryStream);
         memoryStream.Position = 32;
         memoryStream.WriteByte(1); // Corrupt mini sector shift
-        Assert.ThrowsException<FormatException>(() => reader.ReadHeader());
-
-        stream.CopyAllTo(memoryStream);
-        memoryStream.Position = 32;
-        memoryStream.WriteByte(1); // Corrupt mini sector shift
-        Assert.ThrowsException<FormatException>(() => reader.ReadHeader());
+        Assert.ThrowsException<FileFormatException>(() => reader.ReadHeader());
     }
 }
diff --git a/OpenMcdf/CfbBinaryReader.cs b/OpenMcdf/CfbBinaryReader.cs
@@ -73,19 +73,19 @@ public Header ReadHeader()
         ReadExactly(buffer, 0, Header.Signature.Length);
         Span<byte> signature = buffer.AsSpan(0, Header.Signature.Length);
         if (!signature.SequenceEqual(Header.Signature))
-            throw new FormatException("Invalid header signature.");
+            throw new FileFormatException("Invalid header signature.");
         header.CLSID = ReadGuid();
         if (header.CLSID != Guid.Empty)
-            throw new FormatException($"Invalid header CLSID: {header.CLSID}.");
+            throw new FileFormatException($"Invalid header CLSID: {header.CLSID}.");
         header.MinorVersion = ReadUInt16();
         header.MajorVersion = ReadUInt16();
         if (header.MajorVersion is not (ushort)Version.V3 and not (ushort)Version.V4)
-            throw new FormatException($"Unsupported major version: {header.MajorVersion}.");
+            throw new FileFormatException($"Unsupported major version: {header.MajorVersion}.");
         else if (header.MinorVersion is not Header.ExpectedMinorVersion)
             Trace.WriteLine($"Unexpected minor version: {header.MinorVersion}.");
         ushort byteOrder = ReadUInt16();
         if (byteOrder != Header.LittleEndian)
-            throw new FormatException($"Unsupported byte order: {byteOrder:X4}. Only little-endian is supported ({Header.LittleEndian:X4}).");
+            throw new FileFormatException($"Unsupported byte order: {byteOrder:X4}. Only little-endian is supported ({Header.LittleEndian:X4}).");
         header.SectorShift = ReadUInt16();
         header.MiniSectorShift = ReadUInt16();
         FillBuffer(6);
@@ -95,7 +95,7 @@ public Header ReadHeader()
         FillBuffer(4);
         uint miniStreamCutoffSize = ReadUInt32();
         if (miniStreamCutoffSize != Header.MiniStreamCutoffSize)
-            throw new FormatException($"Mini stream cutoff size must be {Header.MiniStreamCutoffSize} bytes.");
+            throw new FileFormatException($"Mini stream cutoff size must be {Header.MiniStreamCutoffSize} bytes.");
         header.FirstMiniFatSectorId = ReadUInt32();
         header.MiniFatSectorCount = ReadUInt32();
         header.FirstDifatSectorId = ReadUInt32();
@@ -113,15 +113,15 @@ public StorageType ReadStorageType()
     {
         var type = (StorageType)ReadByte();
         if (type is not StorageType.Storage and not StorageType.Stream and not StorageType.Root and not StorageType.Unallocated)
-            throw new FormatException($"Invalid storage type: {type}.");
+            throw new FileFormatException($"Invalid storage type: {type}.");
         return type;
     }
 
     public NodeColor ReadColor()
     {
         var color = (NodeColor)ReadByte();
         if (color is not NodeColor.Black and not NodeColor.Red)
-            throw new FormatException($"Invalid node color: {color}.");
+            throw new FileFormatException($"Invalid node color: {color}.");
         return color;
     }
 
@@ -154,7 +154,7 @@ public DirectoryEntry ReadDirectoryEntry(Version version, uint sid)
         {
             entry.StreamLength = ReadUInt32();
             if (entry.StreamLength > DirectoryEntry.MaxV3StreamLength)
-                throw new FormatException($"Stream length {entry.StreamLength} exceeds maximum value {DirectoryEntry.MaxV3StreamLength}.");
+                throw new FileFormatException($"Stream length {entry.StreamLength} exceeds maximum value {DirectoryEntry.MaxV3StreamLength}.");
             ReadUInt32(); // Skip unused 4 bytes
         }
         else if (version == Version.V4)
diff --git a/OpenMcdf/DifatSectorEnumerator.cs b/OpenMcdf/DifatSectorEnumerator.cs
@@ -105,7 +105,7 @@ public void Add()
         {
             bool ok = MoveTo(header.DifatSectorCount - 1);
             if (!ok)
-                throw new InvalidOperationException("Failed to move to last DIFAT sector.");
+                throw new FileFormatException("The DIFAT sector count is invalid.");
 
             writer.Position = current.EndPosition - sizeof(uint);
             writer.Write(newDifatSector.Id);
diff --git a/OpenMcdf/DirectoryEntries.cs b/OpenMcdf/DirectoryEntries.cs
@@ -40,7 +40,7 @@ public bool TryGetDictionaryEntry(uint streamId, out DirectoryEntry? entry)
         }
 
         if (streamId > StreamId.Maximum)
-            throw new ArgumentException($"Invalid directory entry stream ID: ${streamId:X8}.", nameof(streamId));
+            throw new FileFormatException($"Invalid directory entry stream ID: ${streamId:X8}.");
 
         uint chainIndex = GetChainIndexAndEntryIndex(streamId, out long entryIndex);
         if (!fatChainEnumerator.MoveTo(chainIndex))
diff --git a/OpenMcdf/DirectoryEntry.cs b/OpenMcdf/DirectoryEntry.cs
@@ -224,7 +224,7 @@ public void Recycle(StorageType storageType, string name)
         StorageType.Stream => EntryType.Stream,
         StorageType.Storage => EntryType.Storage,
         StorageType.Root => EntryType.Storage,
-        _ => throw new InvalidOperationException("Invalid storage type.")
+        _ => throw new FileFormatException($"Invalid storage type: {Type}.")
     };
 
     public EntryInfo ToEntryInfo(string path) => new(EntryType, path, NameString, StreamLength, CLSID, CreationTime, ModifiedTime);
diff --git a/OpenMcdf/DirectoryTree.cs b/OpenMcdf/DirectoryTree.cs
@@ -43,7 +43,7 @@ public bool TryGetDirectoryEntry(string name, out DirectoryEntry? entry)
                 {
                     compare = DirectoryEntryComparer.Compare(leftChild.NameCharSpan, child.NameCharSpan);
                     if (compare >= 0)
-                        throw new FormatException("Directory tree is not sorted.");
+                        throw new FileFormatException("Directory tree is not sorted.");
                 }
 
                 child = leftChild;
@@ -55,7 +55,7 @@ public bool TryGetDirectoryEntry(string name, out DirectoryEntry? entry)
                 {
                     compare = DirectoryEntryComparer.Compare(rightChild.NameCharSpan, child.NameCharSpan);
                     if (compare <= 0)
-                        throw new FormatException("Directory tree is not sorted.");
+                        throw new FileFormatException("Directory tree is not sorted.");
                 }
 
                 child = rightChild;
diff --git a/OpenMcdf/Fat.cs b/OpenMcdf/Fat.cs
@@ -190,17 +190,17 @@ internal void Validate()
         {
             Sector sector = new(entry.Index, Context.SectorSize);
             if (entry.Value <= SectorType.Maximum && sector.EndPosition > Context.Length)
-                throw new FormatException($"FAT entry {entry} is beyond the end of the stream.");
+                throw new FileFormatException($"FAT entry {entry} is beyond the end of the stream.");
             if (entry.Value == SectorType.Fat)
                 fatSectorCount++;
             if (entry.Value == SectorType.Difat)
                 difatSectorCount++;
         }
 
         if (Context.Header.FatSectorCount != fatSectorCount)
-            throw new FormatException($"FAT sector count mismatch. Expected: {Context.Header.FatSectorCount} Actual: {fatSectorCount}.");
+            throw new FileFormatException($"FAT sector count mismatch. Expected: {Context.Header.FatSectorCount} Actual: {fatSectorCount}.");
         if (Context.Header.DifatSectorCount != difatSectorCount)
-            throw new FormatException($"DIFAT sector count mismatch: Expected: {Context.Header.DifatSectorCount} Actual: {difatSectorCount}.");
+            throw new FileFormatException($"DIFAT sector count mismatch: Expected: {Context.Header.DifatSectorCount} Actual: {difatSectorCount}.");
     }
 
     [ExcludeFromCodeCoverage]
diff --git a/OpenMcdf/FatStream.cs b/OpenMcdf/FatStream.cs
@@ -89,7 +89,7 @@ public override int Read(byte[] buffer, int offset, int count)
 
         uint chainIndex = GetFatChainIndexAndSectorOffset(position, out long sectorOffset);
         if (!chain.MoveTo(chainIndex))
-            throw new FormatException($"The FAT chain was shorter than the stream length.");
+            throw new FileFormatException($"The FAT chain was shorter than the stream length.");
 
         int realCount = Math.Min(count, maxCount);
         int readCount = 0;
@@ -109,7 +109,7 @@ public override int Read(byte[] buffer, int offset, int count)
             if (readCount >= realCount)
                 return readCount;
             if (!chain.MoveNext())
-                throw new FormatException($"The FAT chain was shorter than the stream length.");
+                throw new FileFormatException($"The FAT chain was shorter than the stream length.");
         };
     }
 
@@ -215,7 +215,7 @@ public override int Read(Span<byte> buffer)
 
         uint chainIndex = GetFatChainIndexAndSectorOffset(position, out long sectorOffset);
         if (!chain.MoveTo(chainIndex))
-            throw new FormatException($"The FAT chain was shorter than the stream length.");
+            throw new FileFormatException($"The FAT chain was shorter than the stream length.");
 
         int realCount = Math.Min(buffer.Length, maxCount);
         int readCount = 0;
@@ -236,7 +236,7 @@ public override int Read(Span<byte> buffer)
             if (readCount >= realCount)
                 return readCount;
             if (!chain.MoveNext())
-                throw new FormatException($"The FAT chain was shorter than the stream length.");
+                throw new FileFormatException($"The FAT chain was shorter than the stream length.");
         }
     }
 
diff --git a/OpenMcdf/FileFormatException.cs b/OpenMcdf/FileFormatException.cs
@@ -0,0 +1,19 @@
+﻿namespace OpenMcdf;
+
+/// <summary>
+/// The exception that is thrown when an compound file data stream contains invalid data.
+/// </summary>
+public class FileFormatException : FormatException
+{
+    public FileFormatException()
+    {
+    }
+
+    public FileFormatException(string message) : base(message)
+    {
+    }
+
+    public FileFormatException(string message, Exception innerException) : base(message, innerException)
+    {
+    }
+}
diff --git a/OpenMcdf/Header.cs b/OpenMcdf/Header.cs
@@ -44,7 +44,7 @@ public ushort MajorVersion
         get => majorVersion; set
         {
             if (value is not 3 and not 4)
-                throw new FormatException($"Unsupported major version: {value}. Only 3 and 4 are supported");
+                throw new FileFormatException($"Unsupported major version: {value}. Only 3 and 4 are supported");
             majorVersion = value;
         }
     }
@@ -57,9 +57,9 @@ public ushort SectorShift
         get => sectorShift; set
         {
             if (MajorVersion == 3 && value != SectorShiftV3)
-                throw new FormatException($"Unsupported sector shift {value:X4}. Only {SectorShiftV3:X4} is supported for Major Version 3.");
+                throw new FileFormatException($"Unsupported sector shift {value:X4}. Only {SectorShiftV3:X4} is supported for Major Version 3.");
             if (MajorVersion == 4 && value != SectorShiftV4)
-                throw new FormatException($"Unsupported sector shift {value:X4}. Only {SectorShiftV4:X4} is supported for Major Version 4.");
+                throw new FileFormatException($"Unsupported sector shift {value:X4}. Only {SectorShiftV4:X4} is supported for Major Version 4.");
 
             sectorShift = value;
         }
@@ -71,7 +71,7 @@ public ushort MiniSectorShift
         set
         {
             if (value != ExpectedMiniSectorShift)
-                throw new FormatException($"Unsupported sector shift {value:X4}. Only {ExpectedMiniSectorShift:X4} is supported.");
+                throw new FileFormatException($"Unsupported sector shift {value:X4}. Only {ExpectedMiniSectorShift:X4} is supported.");
 
             miniSectorShift = value;
         }
@@ -130,7 +130,7 @@ public Header(Version version = Version.V3)
         {
             Version.V3 => SectorShiftV3,
             Version.V4 => SectorShiftV4,
-            _ => throw new FormatException($"Unsupported version: {version}.")
+            _ => throw new FileFormatException($"Unsupported version: {version}.")
         };
         FirstDirectorySectorId = SectorType.EndOfChain;
         DirectorySectorCount = 0; // Not used in v3
diff --git a/OpenMcdf/MiniFat.cs b/OpenMcdf/MiniFat.cs
@@ -162,7 +162,7 @@ internal void Validate()
             FatEntry current = miniFatEnumerator.Current;
             if (current.Value <= SectorType.Maximum && miniFatEnumerator.CurrentSector.EndPosition > Context.MiniStream.Length)
             {
-                throw new FormatException($"Mini FAT entry {current} is beyond the end of the mini stream.");
+                throw new FileFormatException($"Mini FAT entry {current} is beyond the end of the mini stream.");
             }
         }
     }
diff --git a/OpenMcdf/MiniFatChainEnumerator.cs b/OpenMcdf/MiniFatChainEnumerator.cs
@@ -70,7 +70,7 @@ public bool MoveNext()
 
             uint nextIndex = index + 1;
             if (nextIndex > SectorType.Maximum)
-                throw new FormatException("Mini FAT chain is corrupt.");
+                throw new FileFormatException("Mini FAT chain is corrupt.");
 
             index = nextIndex;
             current = sectorId;
diff --git a/OpenMcdf/MiniFatStream.cs b/OpenMcdf/MiniFatStream.cs
@@ -79,7 +79,7 @@ public override int Read(byte[] buffer, int offset, int count)
 
         uint chainIndex = GetMiniFatChainIndexAndSectorOffset(position, out long sectorOffset);
         if (!miniChain.MoveTo(chainIndex))
-            throw new FormatException($"The mini FAT chain was shorter than the stream length.");
+            throw new FileFormatException($"The mini FAT chain was shorter than the stream length.");
 
         FatStream miniStream = Context.MiniStream;
         int realCount = Math.Min(count, maxCount);
@@ -100,7 +100,7 @@ public override int Read(byte[] buffer, int offset, int count)
             if (readCount >= realCount)
                 return readCount;
             if (!miniChain.MoveNext())
-                throw new FormatException($"The mini FAT chain was shorter than the stream length.");
+                throw new FileFormatException($"The mini FAT chain was shorter than the stream length.");
         }
     }
 
@@ -165,7 +165,7 @@ public override void Write(byte[] buffer, int offset, int count)
 
         uint chainIndex = GetMiniFatChainIndexAndSectorOffset(position, out long sectorOffset);
         if (!miniChain.MoveTo(chainIndex))
-            throw new InvalidOperationException($"Failed to move to mini FAT chain index: {chainIndex}.");
+            throw new FileFormatException($"Failed to move to mini FAT chain index: {chainIndex}.");
 
         FatStream miniStream = Context.MiniStream;
         int writeCount = 0;
@@ -211,7 +211,7 @@ public override int Read(Span<byte> buffer)
 
         uint chainIndex = GetMiniFatChainIndexAndSectorOffset(position, out long sectorOffset);
         if (!miniChain.MoveTo(chainIndex))
-            throw new FormatException($"The mini FAT chain was shorter than the stream length.");
+            throw new FileFormatException($"The mini FAT chain was shorter than the stream length.");
 
         FatStream miniStream = Context.MiniStream;
         int realCount = Math.Min(buffer.Length, maxCount);
@@ -233,7 +233,7 @@ public override int Read(Span<byte> buffer)
             if (readCount >= realCount)
                 return readCount;
             if (!miniChain.MoveNext())
-                throw new FormatException($"The mini FAT chain was shorter than the stream length.");
+                throw new FileFormatException($"The mini FAT chain was shorter than the stream length.");
         }
     }
 
@@ -251,7 +251,7 @@ public override void Write(ReadOnlySpan<byte> buffer)
 
         uint chainIndex = GetMiniFatChainIndexAndSectorOffset(position, out long sectorOffset);
         if (!miniChain.MoveTo(chainIndex))
-            throw new InvalidOperationException($"Failed to move to mini FAT chain index: {chainIndex}.");
+            throw new FileFormatException($"Failed to move to mini FAT chain index: {chainIndex}.");
 
         FatStream miniStream = Context.MiniStream;
         int writeCount = 0;
diff --git a/StructuredStorageExplorer/MainForm.cs b/StructuredStorageExplorer/MainForm.cs
@@ -7,6 +7,7 @@
 using System.ComponentModel;
 using System.Data;
 using System.Globalization;
+using FileFormatException = OpenMcdf.FileFormatException;
 
 // Author Federico Blaseotto
 
@@ -110,7 +111,7 @@ private void CreateNewFile()
 
             RefreshTree();
         }
-        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or FormatException)
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or FileFormatException)
         {
             CloseCurrentFile();
 
@@ -149,7 +150,7 @@ private void LoadFile(string fileName)
 
             RefreshTree();
         }
-        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or FormatException)
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or FileFormatException)
         {
             CloseCurrentFile();
 
@@ -372,7 +373,7 @@ private void TreeView1_MouseUp(object sender, MouseEventArgs e)
 
             propertyGrid1.SelectedObject = nodeSelection.EntryInfo;
         }
-        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or FormatException)
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or FileFormatException)
         {
             CloseCurrentFile();
 

Original file line number	Diff line number	Diff line change
`@@ -105,7 +105,7 @@ public void Add()`
`105`	`105`	`{`
`106`	`106`	`bool ok = MoveTo(header.DifatSectorCount - 1);`
`107`	`107`	`if (!ok)`
`108`		`- throw new InvalidOperationException("Failed to move to last DIFAT sector.");`
	`108`	`+ throw new FileFormatException("The DIFAT sector count is invalid.");`
`109`	`109`
`110`	`110`	`writer.Position = current.EndPosition - sizeof(uint);`
`111`	`111`	`writer.Write(newDifatSector.Id);`
Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ public bool TryGetDictionaryEntry(uint streamId, out DirectoryEntry? entry)`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`if (streamId > StreamId.Maximum)`
`43`		`- throw new ArgumentException($"Invalid directory entry stream ID: ${streamId:X8}.", nameof(streamId));`
	`43`	`+ throw new FileFormatException($"Invalid directory entry stream ID: ${streamId:X8}.");`
`44`	`44`
`45`	`45`	`uint chainIndex = GetChainIndexAndEntryIndex(streamId, out long entryIndex);`
`46`	`46`	`if (!fatChainEnumerator.MoveTo(chainIndex))`
Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ public bool TryGetDirectoryEntry(string name, out DirectoryEntry? entry)`
`43`	`43`	`{`
`44`	`44`	`compare = DirectoryEntryComparer.Compare(leftChild.NameCharSpan, child.NameCharSpan);`
`45`	`45`	`if (compare >= 0)`
`46`		`- throw new FormatException("Directory tree is not sorted.");`
	`46`	`+ throw new FileFormatException("Directory tree is not sorted.");`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`child = leftChild;`
`@@ -55,7 +55,7 @@ public bool TryGetDirectoryEntry(string name, out DirectoryEntry? entry)`
`55`	`55`	`{`
`56`	`56`	`compare = DirectoryEntryComparer.Compare(rightChild.NameCharSpan, child.NameCharSpan);`
`57`	`57`	`if (compare <= 0)`
`58`		`- throw new FormatException("Directory tree is not sorted.");`
	`58`	`+ throw new FileFormatException("Directory tree is not sorted.");`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`child = rightChild;`
Original file line number	Diff line number	Diff line change
`@@ -190,17 +190,17 @@ internal void Validate()`
`190`	`190`	`{`
`191`	`191`	`Sector sector = new(entry.Index, Context.SectorSize);`
`192`	`192`	`if (entry.Value <= SectorType.Maximum && sector.EndPosition > Context.Length)`
`193`		`- throw new FormatException($"FAT entry {entry} is beyond the end of the stream.");`
	`193`	`+ throw new FileFormatException($"FAT entry {entry} is beyond the end of the stream.");`
`194`	`194`	`if (entry.Value == SectorType.Fat)`
`195`	`195`	`fatSectorCount++;`
`196`	`196`	`if (entry.Value == SectorType.Difat)`
`197`	`197`	`difatSectorCount++;`
`198`	`198`	`}`
`199`	`199`
`200`	`200`	`if (Context.Header.FatSectorCount != fatSectorCount)`
`201`		`- throw new FormatException($"FAT sector count mismatch. Expected: {Context.Header.FatSectorCount} Actual: {fatSectorCount}.");`
	`201`	`+ throw new FileFormatException($"FAT sector count mismatch. Expected: {Context.Header.FatSectorCount} Actual: {fatSectorCount}.");`
`202`	`202`	`if (Context.Header.DifatSectorCount != difatSectorCount)`
`203`		`- throw new FormatException($"DIFAT sector count mismatch: Expected: {Context.Header.DifatSectorCount} Actual: {difatSectorCount}.");`
	`203`	`+ throw new FileFormatException($"DIFAT sector count mismatch: Expected: {Context.Header.DifatSectorCount} Actual: {difatSectorCount}.");`
`204`	`204`	`}`
`205`	`205`
`206`	`206`	`[ExcludeFromCodeCoverage]`
Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,7 @@ public ushort MajorVersion`
`44`	`44`	`get => majorVersion; set`
`45`	`45`	`{`
`46`	`46`	`if (value is not 3 and not 4)`
`47`		`- throw new FormatException($"Unsupported major version: {value}. Only 3 and 4 are supported");`
	`47`	`+ throw new FileFormatException($"Unsupported major version: {value}. Only 3 and 4 are supported");`
`48`	`48`	`majorVersion = value;`
`49`	`49`	`}`
`50`	`50`	`}`
`@@ -57,9 +57,9 @@ public ushort SectorShift`
`57`	`57`	`get => sectorShift; set`
`58`	`58`	`{`
`59`	`59`	`if (MajorVersion == 3 && value != SectorShiftV3)`
`60`		`- throw new FormatException($"Unsupported sector shift {value:X4}. Only {SectorShiftV3:X4} is supported for Major Version 3.");`
	`60`	`+ throw new FileFormatException($"Unsupported sector shift {value:X4}. Only {SectorShiftV3:X4} is supported for Major Version 3.");`
`61`	`61`	`if (MajorVersion == 4 && value != SectorShiftV4)`
`62`		`- throw new FormatException($"Unsupported sector shift {value:X4}. Only {SectorShiftV4:X4} is supported for Major Version 4.");`
	`62`	`+ throw new FileFormatException($"Unsupported sector shift {value:X4}. Only {SectorShiftV4:X4} is supported for Major Version 4.");`
`63`	`63`
`64`	`64`	`sectorShift = value;`
`65`	`65`	`}`
`@@ -71,7 +71,7 @@ public ushort MiniSectorShift`
`71`	`71`	`set`
`72`	`72`	`{`
`73`	`73`	`if (value != ExpectedMiniSectorShift)`
`74`		`- throw new FormatException($"Unsupported sector shift {value:X4}. Only {ExpectedMiniSectorShift:X4} is supported.");`
	`74`	`+ throw new FileFormatException($"Unsupported sector shift {value:X4}. Only {ExpectedMiniSectorShift:X4} is supported.");`
`75`	`75`
`76`	`76`	`miniSectorShift = value;`
`77`	`77`	`}`
`@@ -130,7 +130,7 @@ public Header(Version version = Version.V3)`
`130`	`130`	`{`
`131`	`131`	`Version.V3 => SectorShiftV3,`
`132`	`132`	`Version.V4 => SectorShiftV4,`
`133`		`- _ => throw new FormatException($"Unsupported version: {version}.")`
	`133`	`+ _ => throw new FileFormatException($"Unsupported version: {version}.")`
`134`	`134`	`};`
`135`	`135`	`FirstDirectorySectorId = SectorType.EndOfChain;`
`136`	`136`	`DirectorySectorCount = 0; // Not used in v3`