to new descriptors

Author: AnakinRaW

src/ModVerify/Reporting/Baseline/BaselineCollection.cs

@@ -105,7 +105,13 @@ public VerificationErrors Categorize(IEnumerable<VerificationError> errors)
         return new VerificationErrors(newErrors, readOnlyExisting, resolvedErrors);
     }
 
-    public IEnumerator<IdentifiedBaseline> GetEnumerator() => _baselines.GetEnumerator();
+    public IEnumerator<IdentifiedBaseline> GetEnumerator()
+    {
+        return _baselines.GetEnumerator();
+    }
 
-    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+    IEnumerator IEnumerable.GetEnumerator()
+    {
+        return GetEnumerator();
+    }
 }

src/ModVerify/Reporting/Diagnostics/Diagnostics.Audio.cs

@@ -0,0 +1,43 @@
+using System.Collections.Generic;
+using AET.ModVerify.Verifiers;
+
+namespace AET.ModVerify.Reporting.Diagnostics;
+
+/// <summary>Provides factories for findings produced while verifying audio sample files.</summary>
+public static class Audio
+{
+    private static readonly ErrorDescriptor _fileNotFound = new(
+        VerifierErrorCodes.FileNotFound, "AudioFileNotFound", VerificationSeverity.Error, "Audio");
+
+    private static readonly ErrorDescriptor _notPcm = new(
+        VerifierErrorCodes.SampleNotPCM, "SampleNotPcm", VerificationSeverity.Error, "Audio");
+
+    private static readonly ErrorDescriptor _notMono = new(
+        VerifierErrorCodes.SampleNotMono, "SampleNotMono", VerificationSeverity.Information, "Audio");
+
+    private static readonly ErrorDescriptor _invalidSampleRate = new(
+        VerifierErrorCodes.InvalidSampleRate, "InvalidSampleRate", VerificationSeverity.Error, "Audio");
+
+    private static readonly ErrorDescriptor _invalidBitsPerSecond = new(
+        VerifierErrorCodes.InvalidBitsPerSeconds, "InvalidBitsPerSecond", VerificationSeverity.Error, "Audio");
+
+    /// <summary>Creates an error for an audio sample file that could not be found.</summary>
+    public static VerificationError FileNotFound(IGameVerifierInfo verifier, string sampleName, IEnumerable<string> context)
+        => _fileNotFound.Create(verifier, $"Audio file '{sampleName}' could not be found.", sampleName, context);
+
+    /// <summary>Creates an error for an audio file that is not PCM-encoded.</summary>
+    public static VerificationError NotPcm(IGameVerifierInfo verifier, string sampleName, string actualFormat, IEnumerable<string> context)
+        => _notPcm.Create(verifier, $"Audio file '{sampleName}' has an invalid format '{actualFormat}'. Supported is PCM.", sampleName, context);
+
+    /// <summary>Creates an error for a non-ambient audio file that is not mono.</summary>
+    public static VerificationError NotMono(IGameVerifierInfo verifier, string sampleName, IEnumerable<string> context)
+        => _notMono.Create(verifier, $"Audio file '{sampleName}' is not mono audio.", sampleName, context);
+
+    /// <summary>Creates an error for an audio file whose sample rate exceeds the supported maximum.</summary>
+    public static VerificationError InvalidSampleRate(IGameVerifierInfo verifier, string sampleName, int sampleRate, IEnumerable<string> context)
+        => _invalidSampleRate.Create(verifier, $"Audio file '{sampleName}' has a too high sample rate of {sampleRate}. Maximum is 48.000Hz.", sampleName, context);
+
+    /// <summary>Creates an error for an audio file whose bit depth exceeds the supported maximum.</summary>
+    public static VerificationError InvalidBitsPerSecond(IGameVerifierInfo verifier, string sampleName, int bitsPerSecond, IEnumerable<string> context)
+        => _invalidBitsPerSecond.Create(verifier, $"Audio file '{sampleName}' has an invalid bit size of {bitsPerSecond}. Supported are 16bit.", sampleName, context);
+}

src/ModVerify/Reporting/Diagnostics/Diagnostics.CommandBar.cs

@@ -0,0 +1,80 @@
+using System.Collections.Generic;
+using AET.ModVerify.Verifiers;
+
+namespace AET.ModVerify.Reporting.Diagnostics;
+
+/// <summary>Provides factories for findings produced while verifying the command bar.</summary>
+public static class CommandBar
+{
+    private const string GameCommandBarAsset = "GameCommandBar";
+
+    private static readonly ErrorDescriptor _unsupportedComponent = new(
+        VerifierErrorCodes.CommandBarUnsupportedComponent, "CommandBarUnsupportedComponent", VerificationSeverity.Information, "CommandBar");
+
+    private static readonly ErrorDescriptor _duplicateComponent = new(
+        VerifierErrorCodes.Duplicate, "CommandBarDuplicateComponent", VerificationSeverity.Warning, "CommandBar");
+
+    private static readonly ErrorDescriptor _componentNameTooLong = new(
+        VerifierErrorCodes.NameTooLong, "CommandBarComponentNameTooLong", VerificationSeverity.Critical, "CommandBar");
+
+    private static readonly ErrorDescriptor _shellNoModel = new(
+        VerifierErrorCodes.CommandBarShellNoModel, "CommandBarShellNoModel", VerificationSeverity.Error, "CommandBar");
+
+    private static readonly ErrorDescriptor _componentNotConnected = new(
+        VerifierErrorCodes.CommandBarComponentNotConnected, "CommandBarComponentNotConnected", VerificationSeverity.Warning, "CommandBar");
+
+    private static readonly ErrorDescriptor _noShellsGroup = new(
+        VerifierErrorCodes.CommandBarNoShellsGroup, "CommandBarNoShellsGroup", VerificationSeverity.Error, "CommandBar");
+
+    private static readonly ErrorDescriptor _manyShellsGroups = new(
+        VerifierErrorCodes.CommandBarManyShellsGroup, "CommandBarManyShellsGroups", VerificationSeverity.Warning, "CommandBar");
+
+    private static readonly ErrorDescriptor _nonShellInShellGroup = new(
+        VerifierErrorCodes.CommandBarNoShellsComponentInShellGroup, "CommandBarNonShellInShellGroup", VerificationSeverity.Warning, "CommandBar");
+
+    private static readonly ErrorDescriptor _megaTextureDirectoryNotFound = new(
+        VerifierErrorCodes.FileNotFound, "CommandBarMegaTextureDirectoryNotFound", VerificationSeverity.Critical, "CommandBar");
+
+    private static readonly ErrorDescriptor _megaTextureNotFound = new(
+        VerifierErrorCodes.FileNotFound, "CommandBarMegaTextureNotFound", VerificationSeverity.Critical, "CommandBar");
+
+    /// <summary>Creates an error for a command bar component the game does not support.</summary>
+    public static VerificationError UnsupportedComponent(IGameVerifierInfo verifier, string componentName, IEnumerable<string> context)
+        => _unsupportedComponent.Create(verifier, $"The CommandBar component '{componentName}' is not supported by the game.", componentName, context);
+
+    /// <summary>Creates an error for two command bar components that share the same identifier.</summary>
+    public static VerificationError DuplicateComponent(IGameVerifierInfo verifier, string componentName, object componentId, IEnumerable<string> context)
+        => _duplicateComponent.Create(verifier, $"The CommandBar component '{componentName}' with ID '{componentId}' already exists.", componentName, context);
+
+    /// <summary>Creates an error for a command bar shell component name that exceeds the maximum length.</summary>
+    public static VerificationError ComponentNameTooLong(IGameVerifierInfo verifier, string componentName, int maxLength, IEnumerable<string> context)
+        => _componentNameTooLong.Create(verifier, $"The CommandBarShellComponent name '{componentName}' is too long. Maximum length is {maxLength}.", componentName, context);
+
+    /// <summary>Creates an error for a command bar shell component that has no model specified.</summary>
+    public static VerificationError ShellNoModel(IGameVerifierInfo verifier, string componentName, IEnumerable<string> context)
+        => _shellNoModel.Create(verifier, $"The CommandBarShellComponent '{componentName}' has no model specified.", componentName, context);
+
+    /// <summary>Creates an error for a command bar component that is not connected to a shell component.</summary>
+    public static VerificationError ComponentNotConnected(IGameVerifierInfo verifier, string componentName, IEnumerable<string> context)
+        => _componentNotConnected.Create(verifier, $"The CommandBar component '{componentName}' is not connected to a shell component.", componentName, context);
+
+    /// <summary>Creates an error for the missing required shells command bar group.</summary>
+    public static VerificationError NoShellsGroup(IGameVerifierInfo verifier, string groupName, IEnumerable<string> context)
+        => _noShellsGroup.Create(verifier, $"No CommandBarGroup '{groupName}' found.", GameCommandBarAsset, context);
+
+    /// <summary>Creates an error for more than one shells command bar group being defined.</summary>
+    public static VerificationError ManyShellsGroups(IGameVerifierInfo verifier, string groupName, IEnumerable<string> context)
+        => _manyShellsGroups.Create(verifier, $"Found more than one Shells CommandBarGroup. Mind that group names are case-sensitive. Correct name is '{groupName}'.", GameCommandBarAsset, context);
+
+    /// <summary>Creates an error for a non-shell component that is a member of the shells command bar group.</summary>
+    public static VerificationError NonShellInShellGroup(IGameVerifierInfo verifier, string componentName, string groupName, IEnumerable<string> context)
+        => _nonShellInShellGroup.Create(verifier, $"The CommandBar component '{componentName}' is not a shell component, but part of the '{groupName}' group.", componentName, context);
+
+    /// <summary>Creates an error for the command bar mega-texture directory that could not be found.</summary>
+    public static VerificationError MegaTextureDirectoryNotFound(IGameVerifierInfo verifier, string baseName, IEnumerable<string> context)
+        => _megaTextureDirectoryNotFound.Create(verifier, $"Cannot find CommandBar MegaTextureDirectory '{baseName}.mtd'.", $"{baseName}.mtd", context);
+
+    /// <summary>Creates an error for the command bar mega-texture that could not be found.</summary>
+    public static VerificationError MegaTextureNotFound(IGameVerifierInfo verifier, string baseName, IEnumerable<string> context)
+        => _megaTextureNotFound.Create(verifier, $"Cannot find CommandBar MegaTexture '{baseName}.tga'.", $"{baseName}.tga", context);
+}

src/ModVerify/Reporting/Diagnostics/Diagnostics.Common.cs

@@ -0,0 +1,15 @@
+using System.Collections.Generic;
+using AET.ModVerify.Verifiers;
+
+namespace AET.ModVerify.Reporting.Diagnostics;
+
+/// <summary>Provides factories for findings that are not specific to a single verifier family.</summary>
+public static class Common
+{
+    private static readonly ErrorDescriptor _duplicate = new(
+        VerifierErrorCodes.Duplicate, "DuplicateEntry", VerificationSeverity.Error, "Common");
+
+    /// <summary>Creates an error for a duplicate entry, using a caller-supplied message.</summary>
+    public static VerificationError Duplicate(IGameVerifierInfo verifier, string asset, string message, IEnumerable<string> context)
+        => _duplicate.Create(verifier, message, asset, context);
+}

src/ModVerify/Reporting/Diagnostics/Diagnostics.Engine.cs

@@ -0,0 +1,123 @@
+using System.Collections.Generic;
+using AET.ModVerify.Verifiers;
+
+namespace AET.ModVerify.Reporting.Diagnostics;
+
+/// <summary>Provides the engine-initialization descriptor read by the engine reporter.</summary>
+public static class Engine
+{
+    /// <summary>The game engine reported an error during initialization. The message is supplied by the engine.</summary>
+    public static readonly ErrorDescriptor InitializationError = new(
+        VerifierErrorCodes.InitializationError, "EngineInitializationError", VerificationSeverity.Critical, "Engine");
+}
+
+/// <summary>Provides factories for hard-coded engine assets that are loaded at startup.</summary>
+public static class HardcodedAssets
+{
+    private static readonly ErrorDescriptor _shaderNotFound = new(
+        VerifierErrorCodes.FileNotFound, "HardcodedShaderNotFound", VerificationSeverity.Error, "HardcodedAssets");
+
+    private static readonly ErrorDescriptor _terrainShaderNotFound = new(
+        VerifierErrorCodes.FileNotFound, "HardcodedTerrainShaderNotFound", VerificationSeverity.Error, "HardcodedAssets");
+
+    /// <summary>Creates an error for a shader the engine loads at startup that could not be found.</summary>
+    /// <returns>A new error for the finding.</returns>
+    public static VerificationError ShaderNotFound(IGameVerifierInfo verifier, string shaderName, IEnumerable<string> context)
+        => _shaderNotFound.Create(verifier, $"Unable to find shader '{shaderName}'.", shaderName, context);
+
+    /// <summary>Creates an error for a terrain shader the engine loads on terrain load that could not be found.</summary>
+    /// <returns>A new error for the finding.</returns>
+    public static VerificationError TerrainShaderNotFound(IGameVerifierInfo verifier, string shaderName, IEnumerable<string> context)
+        => _terrainShaderNotFound.Create(verifier, $"Unable to find terrain shader '{shaderName}'.", shaderName, context);
+}
+
+// Descriptors for findings produced by the engine-side reporters. Their messages are supplied by the engine
+// (XML parser, asserts), so the reporters read only Id and Severity.
+
+/// <summary>Provides descriptors for findings reported by the engine's XML parser.</summary>
+public static class Xml
+{
+    /// <summary>The XML parser reported an error that does not map to a more specific kind.</summary>
+    public static readonly ErrorDescriptor Generic = new(
+        VerifierErrorCodes.GenericXmlError, "XmlGenericError", VerificationSeverity.Warning, "Xml");
+
+    /// <summary>An XML file has an empty root element.</summary>
+    public static readonly ErrorDescriptor EmptyRoot = new(
+        VerifierErrorCodes.EmptyXmlRoot, "XmlEmptyRoot", VerificationSeverity.Critical, "Xml");
+
+    /// <summary>An XML file referenced by the parser could not be found.</summary>
+    public static readonly ErrorDescriptor MissingFile = new(
+        VerifierErrorCodes.FileNotFound, "XmlMissingFile", VerificationSeverity.Error, "Xml");
+
+    /// <summary>An XML element has an invalid value.</summary>
+    public static readonly ErrorDescriptor InvalidValue = new(
+        VerifierErrorCodes.InvalidXmlValue, "XmlInvalidValue", VerificationSeverity.Information, "Xml");
+
+    /// <summary>An XML element has a malformed value.</summary>
+    public static readonly ErrorDescriptor MalformedValue = new(
+        VerifierErrorCodes.MalformedXmlValue, "XmlMalformedValue", VerificationSeverity.Warning, "Xml");
+
+    /// <summary>An XML element is missing a required attribute.</summary>
+    public static readonly ErrorDescriptor MissingAttribute = new(
+        VerifierErrorCodes.MissingXmlAttribute, "XmlMissingAttribute", VerificationSeverity.Error, "Xml");
+
+    /// <summary>An XML element references an entry that does not exist.</summary>
+    public static readonly ErrorDescriptor MissingReference = new(
+        VerifierErrorCodes.MissingXmlReference, "XmlMissingReference", VerificationSeverity.Error, "Xml");
+
+    /// <summary>An XML value exceeds the maximum allowed length.</summary>
+    public static readonly ErrorDescriptor ValueTooLong = new(
+        VerifierErrorCodes.XmlValueTooLong, "XmlValueTooLong", VerificationSeverity.Warning, "Xml");
+
+    /// <summary>An XML file contains data before its header.</summary>
+    public static readonly ErrorDescriptor DataBeforeHeader = new(
+        VerifierErrorCodes.XmlDataBeforeHeader, "XmlDataBeforeHeader", VerificationSeverity.Information, "Xml");
+
+    /// <summary>A required XML node is missing.</summary>
+    public static readonly ErrorDescriptor MissingNode = new(
+        VerifierErrorCodes.XmlMissingNode, "XmlMissingNode", VerificationSeverity.Critical, "Xml");
+
+    /// <summary>An XML file contains a node the parser does not support.</summary>
+    public static readonly ErrorDescriptor UnknownNode = new(
+        VerifierErrorCodes.XmlUnsupportedTag, "XmlUnknownNode", VerificationSeverity.Information, "Xml");
+
+    /// <summary>An XML tag unexpectedly contains child elements.</summary>
+    public static readonly ErrorDescriptor TagHasElements = new(
+        VerifierErrorCodes.XmlElementsInTag, "XmlTagHasElements", VerificationSeverity.Warning, "Xml");
+
+    /// <summary>An XML element has a name the parser did not expect.</summary>
+    public static readonly ErrorDescriptor UnexpectedElementName = new(
+        VerifierErrorCodes.XmlUnexceptedElementName, "XmlUnexpectedElementName", VerificationSeverity.Information, "Xml");
+
+    /// <summary>An XML node has an empty name.</summary>
+    public static readonly ErrorDescriptor EmptyNodeName = new(
+        VerifierErrorCodes.XmlEmptyNodeName, "XmlEmptyNodeName", VerificationSeverity.Warning, "Xml");
+}
+
+/// <summary>Provides descriptors for assertions raised by the engine.</summary>
+public static class Asserts
+{
+    /// <summary>The engine asserted that a value was null or empty.</summary>
+    public static readonly ErrorDescriptor NullOrEmptyValue = new(
+        VerifierErrorCodes.AssertValueNullOrEmpty, "AssertNullOrEmptyValue", VerificationSeverity.Warning, "Asserts");
+
+    /// <summary>The engine asserted that a value was out of range.</summary>
+    public static readonly ErrorDescriptor ValueOutOfRange = new(
+        VerifierErrorCodes.AssertValueOutOfRange, "AssertValueOutOfRange", VerificationSeverity.Warning, "Asserts");
+
+    /// <summary>The engine asserted that a value was invalid.</summary>
+    public static readonly ErrorDescriptor InvalidValue = new(
+        VerifierErrorCodes.AssertValueInvalid, "AssertInvalidValue", VerificationSeverity.Warning, "Asserts");
+
+    /// <summary>The engine asserted that a file was not found.</summary>
+    public static readonly ErrorDescriptor FileNotFound = new(
+        VerifierErrorCodes.FileNotFound, "AssertFileNotFound", VerificationSeverity.Warning, "Asserts");
+
+    /// <summary>The engine asserted that a duplicate entry exists.</summary>
+    public static readonly ErrorDescriptor DuplicateEntry = new(
+        VerifierErrorCodes.Duplicate, "AssertDuplicateEntry", VerificationSeverity.Warning, "Asserts");
+
+    /// <summary>The engine asserted that a binary file is corrupt.</summary>
+    public static readonly ErrorDescriptor CorruptBinary = new(
+        VerifierErrorCodes.BinaryFileCorrupt, "AssertCorruptBinary", VerificationSeverity.Warning, "Asserts");
+}