Supply of SMBIOS parsing code for SMBIOS types 0, 1, and 3 (the useful ones).

Author: mjr4077au

src/PSADT/PSADT.Tests/SMBIOS/BaseboardTypeTests.cs

@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2025 Devicie Pty Ltd. All rights reserved.
+ * 
+ * This file is part of PSAppDeployToolkit. 
+ * 
+ * PSAppDeployToolkit is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation, either version 3
+ * of the License, or (at your option) any later version.
+ * 
+ * PSAppDeployToolkit is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * 
+ * See the GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with PSAppDeployToolkit. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+using PSADT.SMBIOS;
+
+namespace PSADT.Tests.SMBIOS
+{
+    /// <summary>
+    /// Contains unit tests that verify the values of the BaseboardType enumeration against their expected byte
+    /// representations.
+    /// </summary>
+    /// <remarks>Use this test class to ensure that changes to the BaseboardType enumeration do not introduce
+    /// breaking changes to its underlying values. Failing tests may indicate that the enumeration no longer conforms to
+    /// its intended specification.</remarks>
+    public sealed class BaseboardTypeTests
+    {
+        /// <summary>
+        /// Verifies that each value of the BaseboardType enumeration matches its expected byte representation.
+        /// </summary>
+        /// <remarks>This test ensures that the underlying byte values assigned to each BaseboardType
+        /// enumeration member conform to the specification. Changes to the enumeration values may cause this test to
+        /// fail, indicating a breaking change in the enum's definition.</remarks>
+        [Fact]
+        public void EnumValues_MatchSpecification()
+        {
+            Assert.Equal<byte>(0x01, (byte)BaseboardType.Unknown);
+            Assert.Equal<byte>(0x02, (byte)BaseboardType.Other);
+            Assert.Equal<byte>(0x03, (byte)BaseboardType.ServerBlade);
+            Assert.Equal<byte>(0x04, (byte)BaseboardType.ConnectivitySwitch);
+            Assert.Equal<byte>(0x05, (byte)BaseboardType.SystemManagementModule);
+            Assert.Equal<byte>(0x06, (byte)BaseboardType.ProcessorModule);
+            Assert.Equal<byte>(0x07, (byte)BaseboardType.IoModule);
+            Assert.Equal<byte>(0x08, (byte)BaseboardType.MemoryModule);
+            Assert.Equal<byte>(0x09, (byte)BaseboardType.DaughterBoard);
+            Assert.Equal<byte>(0x0A, (byte)BaseboardType.Motherboard);
+            Assert.Equal<byte>(0x0B, (byte)BaseboardType.ProcessorMemoryModule);
+            Assert.Equal<byte>(0x0C, (byte)BaseboardType.ProcessorIoModule);
+            Assert.Equal<byte>(0x0D, (byte)BaseboardType.InterconnectBoard);
+        }
+    }
+}

src/PSADT/PSADT.Tests/SMBIOS/BiosExtendedRomSizeTests.cs

@@ -0,0 +1,83 @@
+/*
+ * Copyright (C) 2025 Devicie Pty Ltd. All rights reserved.
+ * 
+ * This file is part of PSAppDeployToolkit. 
+ * 
+ * PSAppDeployToolkit is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation, either version 3
+ * of the License, or (at your option) any later version.
+ * 
+ * PSAppDeployToolkit is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * 
+ * See the GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with PSAppDeployToolkit. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+using PSADT.SMBIOS;
+
+namespace PSADT.Tests.SMBIOS
+{
+    /// <summary>
+    /// Contains unit tests for the BiosExtendedRomSize struct, verifying the correctness of its properties and
+    /// behavior.
+    /// </summary>
+    /// <remarks>This class includes both individual and parameterized tests to ensure that the
+    /// BiosExtendedRomSize struct correctly interprets raw BIOS ROM size values and exposes accurate property values.
+    /// The tests use representative sample data to validate expected outcomes for various BIOS ROM
+    /// configurations.</remarks>
+    public sealed class BiosExtendedRomSizeTests
+    {
+        /// <summary>
+        /// Verifies that the Size property of the BiosExtendedRomSize struct returns the value of the lower fourteen
+        /// bits of the underlying ushort.
+        /// </summary>
+        /// <remarks>This test ensures that only the least significant fourteen bits are considered when
+        /// retrieving the Size value, regardless of the higher bits in the input.</remarks>
+        [Fact]
+        public void Size_ReturnsLowerFourteenBits()
+        {
+            BiosExtendedRomSize size = new(unchecked((ushort)0b01_0011001100110011));
+            Assert.Equal(0b0011001100110011 & 0x3FFF, size.Size);
+        }
+
+        /// <summary>
+        /// Verifies that the properties of a BiosExtendedRomSize instance return the expected values for the given
+        /// input parameters.
+        /// </summary>
+        /// <remarks>This is a parameterized unit test that uses data from SampleData to validate the
+        /// behavior of the BiosExtendedRomSize properties.</remarks>
+        /// <param name="raw">The raw ushort value used to construct the BiosExtendedRomSize instance.</param>
+        /// <param name="expectedUnitValue">The expected unit value, as a byte, to compare against the Unit property of the instance.</param>
+        /// <param name="expectedRecognized">The expected value indicating whether the unit is recognized, to compare against the IsUnitRecognized
+        /// property.</param>
+        /// <param name="expectedBytes">The expected number of bytes, or null if not applicable, to compare against the Bytes property.</param>
+        [Theory]
+        [MemberData(nameof(SampleData))]
+        public void Properties_ReturnExpectedValues(ushort raw, byte expectedUnitValue, bool expectedRecognized, ulong? expectedBytes)
+        {
+            BiosExtendedRomSize value = new(raw);
+            BiosRomUnit expectedUnit = (BiosRomUnit)expectedUnitValue;
+            Assert.Equal(raw, value.Raw);
+            Assert.Equal(expectedUnit, value.Unit);
+            Assert.Equal(expectedRecognized, value.IsUnitRecognized);
+            Assert.Equal(expectedBytes, value.Bytes);
+        }
+
+        /// <summary>
+        /// Gets a collection of sample BIOS ROM data sets for use in parameterized unit tests.
+        /// </summary>
+        /// <remarks>Each data set consists of a 16-bit identifier, a unit value as a byte, a flag
+        /// indicating validity, and an optional ROM size in bytes. This property is intended to support test scenarios
+        /// that require representative BIOS ROM configurations.</remarks>
+        public static TheoryData<ushort, byte, bool, ulong?> SampleData { get; } = new()
+        {
+            { 0x0002, (byte)BiosRomUnit.MB, true, 2UL * 1024 * 1024 },
+            { 0x4003, (byte)BiosRomUnit.GB, true, 3UL * 1024 * 1024 * 1024 },
+        };
+    }
+}

src/PSADT/PSADT.Tests/SMBIOS/BiosRomUnitTests.cs

@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2025 Devicie Pty Ltd. All rights reserved.
+ * 
+ * This file is part of PSAppDeployToolkit. 
+ * 
+ * PSAppDeployToolkit is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation, either version 3
+ * of the License, or (at your option) any later version.
+ * 
+ * PSAppDeployToolkit is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * 
+ * See the GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with PSAppDeployToolkit. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+using PSADT.SMBIOS;
+
+namespace PSADT.Tests.SMBIOS
+{
+    /// <summary>
+    /// Contains unit tests for verifying the correctness and stability of the BiosRomUnit enumeration values.
+    /// </summary>
+    /// <remarks>Use this test class to ensure that changes to the BiosRomUnit enumeration do not
+    /// inadvertently alter the assigned byte values, which may impact serialization, interoperability, or dependent
+    /// components.</remarks>
+    public sealed class BiosRomUnitTests
+    {
+        /// <summary>
+        /// Verifies that the underlying byte values of the BiosRomUnit enumeration members match the expected
+        /// specification.
+        /// </summary>
+        /// <remarks>This test ensures that the values assigned to BiosRomUnit.MB and BiosRomUnit.GB
+        /// remain consistent with their intended specification. Changes to these values may affect serialization,
+        /// interoperability, or other components that depend on the exact numeric values of the enumeration.</remarks>
+        [Fact]
+        public void EnumValues_MatchSpecification()
+        {
+            Assert.Equal(0, (byte)BiosRomUnit.MB);
+            Assert.Equal(1, (byte)BiosRomUnit.GB);
+        }
+    }
+}

src/PSADT/PSADT.Tests/SMBIOS/ChassisSecurityStatusTests.cs

@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2025 Devicie Pty Ltd. All rights reserved.
+ * 
+ * This file is part of PSAppDeployToolkit. 
+ * 
+ * PSAppDeployToolkit is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation, either version 3
+ * of the License, or (at your option) any later version.
+ * 
+ * PSAppDeployToolkit is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * 
+ * See the GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with PSAppDeployToolkit. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+using PSADT.SMBIOS;
+
+namespace PSADT.Tests.SMBIOS
+{
+    /// <summary>
+    /// Contains unit tests for verifying the values and behavior of the ChassisSecurityStatus enumeration.
+    /// </summary>
+    /// <remarks>This class is intended to ensure that the ChassisSecurityStatus enum remains consistent with
+    /// protocol specifications. It is typically used in automated test suites to detect unintended changes to the
+    /// enum's assigned values.</remarks>
+    public sealed class ChassisSecurityStatusTests
+    {
+        /// <summary>
+        /// Verifies that the byte values of the ChassisSecurityStatus enumeration members match the expected
+        /// specification.
+        /// </summary>
+        /// <remarks>This test ensures that changes to the ChassisSecurityStatus enum do not alter the
+        /// assigned byte values, which may be required for protocol compatibility or serialization.</remarks>
+        [Fact]
+        public void EnumValues_MatchSpecification()
+        {
+            Assert.Equal<byte>(0x01, (byte)ChassisSecurityStatus.Other);
+            Assert.Equal<byte>(0x02, (byte)ChassisSecurityStatus.Unknown);
+            Assert.Equal<byte>(0x03, (byte)ChassisSecurityStatus.None);
+            Assert.Equal<byte>(0x04, (byte)ChassisSecurityStatus.ExternalInterfaceLockedOut);
+            Assert.Equal<byte>(0x05, (byte)ChassisSecurityStatus.ExternalInterfaceEnabled);
+        }
+    }
+}

src/PSADT/PSADT.Tests/SMBIOS/ChassisStateTests.cs

@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2025 Devicie Pty Ltd. All rights reserved.
+ * 
+ * This file is part of PSAppDeployToolkit. 
+ * 
+ * PSAppDeployToolkit is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation, either version 3
+ * of the License, or (at your option) any later version.
+ * 
+ * PSAppDeployToolkit is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * 
+ * See the GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with PSAppDeployToolkit. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+using PSADT.SMBIOS;
+
+namespace PSADT.Tests.SMBIOS
+{
+    /// <summary>
+    /// Contains unit tests for verifying the values and behavior of the ChassisState enumeration.
+    /// </summary>
+    /// <remarks>Use this test class to ensure that changes to the ChassisState enumeration do not break
+    /// protocol compatibility or serialization requirements by altering the defined byte values. Update the tests if
+    /// the specification for ChassisState values changes.</remarks>
+    public sealed class ChassisStateTests
+    {
+        /// <summary>
+        /// Verifies that the underlying byte values of the ChassisState enumeration members match the expected
+        /// specification.
+        /// </summary>
+        /// <remarks>This test ensures that changes to the ChassisState enumeration do not alter the
+        /// defined byte values, which may be required for protocol compatibility or serialization. Update this test if
+        /// the specification for ChassisState values changes.</remarks>
+        [Fact]
+        public void EnumValues_MatchSpecification()
+        {
+            Assert.Equal<byte>(0x01, (byte)ChassisState.Other);
+            Assert.Equal<byte>(0x02, (byte)ChassisState.Unknown);
+            Assert.Equal<byte>(0x03, (byte)ChassisState.Safe);
+            Assert.Equal<byte>(0x04, (byte)ChassisState.Warning);
+            Assert.Equal<byte>(0x05, (byte)ChassisState.Critical);
+            Assert.Equal<byte>(0x06, (byte)ChassisState.NonRecoverable);
+        }
+    }
+}

src/PSADT/PSADT.Tests/SMBIOS/ChassisTypeTests.cs

@@ -0,0 +1,81 @@
+/*
+ * Copyright (C) 2025 Devicie Pty Ltd. All rights reserved.
+ * 
+ * This file is part of PSAppDeployToolkit. 
+ * 
+ * PSAppDeployToolkit is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation, either version 3
+ * of the License, or (at your option) any later version.
+ * 
+ * PSAppDeployToolkit is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * 
+ * See the GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with PSAppDeployToolkit. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+using PSADT.SMBIOS;
+
+namespace PSADT.Tests.SMBIOS
+{
+    /// <summary>
+    /// Contains unit tests that verify the values of the ChassisType enumeration conform to the expected specification.
+    /// </summary>
+    /// <remarks>Use this test class to ensure that any changes to the ChassisType enum do not inadvertently
+    /// alter the assigned byte values. This helps maintain compatibility with external systems or standards that rely
+    /// on specific enumeration values.</remarks>
+    public sealed class ChassisTypeTests
+    {
+        /// <summary>
+        /// Verifies that each value of the ChassisType enumeration matches its expected byte value as specified by the
+        /// standard.
+        /// </summary>
+        /// <remarks>This test ensures that the underlying byte values of all ChassisType enum members
+        /// conform to the documented specification. If the enum definitions are modified or regenerated, this test will
+        /// detect any unintended changes to their assigned values.</remarks>
+        [Fact]
+        public void EnumValues_MatchSpecification()
+        {
+            Assert.Equal<byte>(0x01, (byte)ChassisType.Other);
+            Assert.Equal<byte>(0x02, (byte)ChassisType.Unknown);
+            Assert.Equal<byte>(0x03, (byte)ChassisType.Desktop);
+            Assert.Equal<byte>(0x04, (byte)ChassisType.LowProfileDesktop);
+            Assert.Equal<byte>(0x05, (byte)ChassisType.PizzaBox);
+            Assert.Equal<byte>(0x06, (byte)ChassisType.MiniTower);
+            Assert.Equal<byte>(0x07, (byte)ChassisType.Tower);
+            Assert.Equal<byte>(0x08, (byte)ChassisType.Portable);
+            Assert.Equal<byte>(0x09, (byte)ChassisType.Laptop);
+            Assert.Equal<byte>(0x0A, (byte)ChassisType.Notebook);
+            Assert.Equal<byte>(0x0B, (byte)ChassisType.HandHeld);
+            Assert.Equal<byte>(0x0C, (byte)ChassisType.DockingStation);
+            Assert.Equal<byte>(0x0D, (byte)ChassisType.AllInOne);
+            Assert.Equal<byte>(0x0E, (byte)ChassisType.SubNotebook);
+            Assert.Equal<byte>(0x0F, (byte)ChassisType.SpaceSaving);
+            Assert.Equal<byte>(0x10, (byte)ChassisType.LunchBox);
+            Assert.Equal<byte>(0x11, (byte)ChassisType.MainServerChassis);
+            Assert.Equal<byte>(0x12, (byte)ChassisType.ExpansionChassis);
+            Assert.Equal<byte>(0x13, (byte)ChassisType.SubChassis);
+            Assert.Equal<byte>(0x14, (byte)ChassisType.BusExpansionChassis);
+            Assert.Equal<byte>(0x15, (byte)ChassisType.PeripheralChassis);
+            Assert.Equal<byte>(0x16, (byte)ChassisType.RaidChassis);
+            Assert.Equal<byte>(0x17, (byte)ChassisType.RackMountChassis);
+            Assert.Equal<byte>(0x18, (byte)ChassisType.SealedCasePc);
+            Assert.Equal<byte>(0x19, (byte)ChassisType.MultiSystemChassis);
+            Assert.Equal<byte>(0x1A, (byte)ChassisType.CompactPci);
+            Assert.Equal<byte>(0x1B, (byte)ChassisType.AdvancedTca);
+            Assert.Equal<byte>(0x1C, (byte)ChassisType.Blade);
+            Assert.Equal<byte>(0x1D, (byte)ChassisType.BladeEnclosure);
+            Assert.Equal<byte>(0x1E, (byte)ChassisType.Tablet);
+            Assert.Equal<byte>(0x1F, (byte)ChassisType.Convertible);
+            Assert.Equal<byte>(0x20, (byte)ChassisType.Detachable);
+            Assert.Equal<byte>(0x21, (byte)ChassisType.IoTGateway);
+            Assert.Equal<byte>(0x22, (byte)ChassisType.EmbeddedPc);
+            Assert.Equal<byte>(0x23, (byte)ChassisType.MiniPc);
+            Assert.Equal<byte>(0x24, (byte)ChassisType.StickPc);
+        }
+    }
+}