PowerShell-master/test/powershell/Modules/Microsoft.PowerShell.Management/Get-ComputerInfo.Tests.ps1

# Copyright (c) Microsoft Corporation.
# Licensed under the MIT License.
#
# TEST SPECIFIC HELPER METHODS FOR TESTING Get-ComputerInfo cmdlet
#

$computerInfoAll = $null
$testStartTime = Get-Date

$excludedProperties = @(
    "CsPhysicallyInstalledMemory",
    "OsServerLevel"
)

function Get-ComputerInfoForTest
{
    # NOTE: $forceRefresh only applies to the case where $properties is null
    param([string[]] $properties = $null, [switch] $forceRefresh)

    # non-windows systems show all tests as skipped so we can just return null
    # here because we won't ever look at it
    if ( ! $IsWindows )
    {
        return $null
    }

    $computerInfo = $null
    if ( $properties )
    {
        return Get-ComputerInfo -Property $properties
    }
    else
    {
        # run once unless we really need to run again
        if ( $forceRefresh -or $null -eq $script:computerInfoAll)
        {
            $script:computerInfoAll = Get-ComputerInfo
        }
        return $script:computerInfoAll
    }
}

function Get-StringValuesFromValueMap
{
    param([string[]] $values, [hashtable] $valuemap)

    [string] $stringValues = [string]::Empty

    foreach ($value in $values)
    {
        if ($stringValues -ne [string]::Empty)
        {
            $stringValues += ","
        }
        $stringValues += $valuemap[$value]
    }
    $stringValues
}

function Get-PropertyNamesForComputerInfoTest
{
    $propertyNames = @()

    $propertyNames += @("BiosBIOSVersion",
        "BiosBuildNumber",
        "BiosCaption",
        "BiosCharacteristics",
        "BiosCodeSet",
        "BiosCurrentLanguage",
        "BiosDescription",
        "BiosEmbeddedControllerMajorVersion",
        "BiosEmbeddedControllerMinorVersion",
        "BiosFirmwareType",
        "BiosIdentificationCode",
        "BiosInstallableLanguages",
        "BiosInstallDate",
        "BiosLanguageEdition",
        "BiosListOfLanguages",
        "BiosManufacturer",
        "BiosName",
        "BiosOtherTargetOS",
        "BiosPrimaryBIOS",
        "BiosReleaseDate",
        "BiosSerialNumber",
        "BiosSMBIOSBIOSVersion",
        "BiosSMBIOSPresent",
        "BiosSMBIOSMajorVersion",
        "BiosSMBIOSMinorVersion",
        "BiosSoftwareElementState",
        "BiosStatus",
        "BiosTargetOperatingSystem",
        "BiosVersion")

    $propertyNames += @("CsAdminPasswordStatus",
        "CsAutomaticManagedPagefile",
        "CsAutomaticResetBootOption",
        "CsAutomaticResetCapability",
        "CsBootOptionOnLimit",
        "CsBootOptionOnWatchDog",
        "CsBootROMSupported",
        "CsBootStatus",
        "CsBootupState",
        "CsCaption",
        "CsChassisBootupState",
        "CsChassisSKUNumber",
        "CsCurrentTimeZone",
        "CsDaylightInEffect",
        "CsDescription",
        "CsDNSHostName",
        "CsDomain",
        "CsDomainRole",
        "CsEnableDaylightSavingsTime",
        "CsFrontPanelResetStatus",
        "CsHypervisorPresent",
        "CsInfraredSupported",
        "CsInitialLoadInfo",
        "CsInstallDate",
        "CsKeyboardPasswordStatus",
        "CsLastLoadInfo",
        "CsManufacturer",
        "CsModel",
        "CsName",
        "CsNetworkAdapters",
        "CsNetworkServerModeEnabled",
        "CsNumberOfLogicalProcessors",
        "CsNumberOfProcessors",
        "CsOEMStringArray",
        "CsPartOfDomain",
        "CsPauseAfterReset",
        "CsPCSystemType",
        "CsPCSystemTypeEx",
        "CsPhysicallyInstalledMemory",
        "CsPowerManagementCapabilities",
        "CsPowerManagementSupported",
        "CsPowerOnPasswordStatus",
        "CsPowerState",
        "CsPowerSupplyState",
        "CsPrimaryOwnerContact",
        "CsPrimaryOwnerName",
        "CsProcessors",
        "CsResetCapability",
        "CsResetCount",
        "CsResetLimit",
        "CsRoles",
        "CsStatus",
        "CsSupportContactDescription",
        "CsSystemFamily",
        "CsSystemSKUNumber",
        "CsSystemType",
        "CsThermalState",
        "CsTotalPhysicalMemory",
        "CsUserName",
        "CsWakeUpType",
        "CsWorkgroup")

    $propertyNames += @("HyperVisorPresent",
        "HyperVRequirementDataExecutionPreventionAvailable",
        "HyperVRequirementSecondLevelAddressTranslation",
        "HyperVRequirementVirtualizationFirmwareEnabled",
        "HyperVRequirementVMMonitorModeExtensions")

    $propertyNames += @("OsArchitecture",
        "OsBootDevice",
        "OsBuildNumber",
        "OsBuildType",
        "OsCodeSet",
        "OsCountryCode",
        "OsCSDVersion",
        "OsCurrentTimeZone",
        "OsDataExecutionPrevention32BitApplications",
        "OsDataExecutionPreventionAvailable",
        "OsDataExecutionPreventionDrivers",
        "OsDataExecutionPreventionSupportPolicy",
        "OsDebug",
        "OsDistributed",
        "OsEncryptionLevel",
        "OsForegroundApplicationBoost",
        "OsHardwareAbstractionLayer",
        "OsHotFixes",
        "OsInstallDate",
        "OsLanguage",
        "OsLastBootUpTime",
        "OsLocale",
        "OsLocaleID",
        "OsManufacturer",
        "OsMaxProcessMemorySize",
        "OsMuiLanguages",
        "OsName",
        "OsNumberOfLicensedUsers",
        "OsNumberOfUsers",
        "OsOperatingSystemSKU",
        "OsOrganization",
        "OsOtherTypeDescription",
        "OsPAEEnabled",
        "OsPagingFiles",
        "OsPortableOperatingSystem",
        "OsPrimary",
        "OsProductSuites",
        "OsProductType",
        "OsRegisteredUser",
        "OsSerialNumber",
        "OsServerLevel",
        "OsServicePackMajorVersion",
        "OsServicePackMinorVersion",
        "OsSizeStoredInPagingFiles",
        "OsStatus",
        "OsSuites",
        "OsSystemDevice",
        "OsSystemDirectory",
        "OsSystemDrive",
        "OsTotalSwapSpaceSize",
        "OsTotalVirtualMemorySize",
        "OsTotalVisibleMemorySize",
        "OsType",
        "OsVersion",
        "OsWindowsDirectory")

    $propertyNames += @("KeyboardLayout",
        "LogonServer",
        "PowerPlatformRole",
        "TimeZone")

    $WindowsPropertyArray = @("WindowsBuildLabEx",
        "WindowsCurrentVersion",
        "WindowsEditionId",
        "WindowsInstallationType",
        "WindowsProductId",
        "WindowsProductName",
        "WindowsRegisteredOrganization",
        "WindowsRegisteredOwner",
        "WindowsSystemRoot",
        "WindowsVersion",
        "WindowsUBR")

    if ([System.Management.Automation.Platform]::IsIoT -or (Test-IsWinWow64))
    {
        Write-Verbose -Verbose -Message "WindowsInstallDateFromRegistry is not supported on current platform."
    }
    else
    {
        $WindowsPropertyArray += "WindowsInstallDateFromRegistry"
    }

    $propertyNames += $WindowsPropertyArray

    return $propertyNames
}

function New-ExpectedComputerInfo
{
    param([string[]]$propertyNames)

    # create a spoofed object for non-windows to be used
    if ( ! $IsWindows )
    {
        $expected = New-Object -TypeName PSObject
        foreach ($propertyName in [string[]]$propertyNames)
        {
            Add-Member -MemberType NoteProperty -Name $propertyName -Value $null -InputObject $expected
        }
        return $expected
    }

    # P-INVOKE TYPE DEF START ******************************************
    function Get-FirmwareType
    {
$signature = @"
[DllImport("kernel32.dll")]
public static extern bool GetFirmwareType(ref uint firmwareType);
"@
        Add-Type -MemberDefinition $signature -Name "Win32BiosFirmwareType" -Namespace Win32Functions -PassThru
    }

    function Get-PhysicallyInstalledSystemMemory
    {
$signature = @"
[DllImport("kernel32.dll")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool GetPhysicallyInstalledSystemMemory(out ulong MemoryInKilobytes);
"@
        Add-Type -MemberDefinition $signature -Name "Win32PhyicallyInstalledMemory" -Namespace Win32Functions -PassThru
    }

    function Get-PhysicallyInstalledSystemMemoryCore
    {
$signature = @"
[DllImport("api-ms-win-core-sysinfo-l1-2-1.dll")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool GetPhysicallyInstalledSystemMemory(out ulong MemoryInKilobytes);
"@
        Add-Type -MemberDefinition $signature -Name "Win32PhyicallyInstalledMemory" -Namespace Win32Functions -PassThru
    }

    function Get-PowerDeterminePlatformRole
    {
$signature = @"
[DllImport("Powrprof", EntryPoint = "PowerDeterminePlatformRoleEx", CharSet = CharSet.Ansi)]
public static extern uint PowerDeterminePlatformRoleEx(uint version);
"@
        Add-Type -MemberDefinition $signature -Name "Win32PowerDeterminePlatformRole" -Namespace Win32Functions -PassThru
    }

    function Get-LCIDToLocaleName
    {
$signature = @"
[DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
public static extern int LCIDToLocaleName(uint localeID, System.Text.StringBuilder localeName, int localeNameSize, int flags);
"@
        Add-Type -MemberDefinition $signature -Name "Win32LCIDToLocaleNameDllName" -Namespace Win32Functions -PassThru
    }

    # P-INVOKE TYPE DEF END ******************************************

    # HELPER METHODS RELYING ON P-INVOKE BEGIN ******************************************
    function Get-BiosFirmwareType
    {
        [int]$firmwareType = 0
        $null = (Get-FirmwareType)::GetFirmwareType([ref]$firmwareType)
        return $firmwareType
    }

    function Get-CsPhysicallyInstalledSystemMemory
    {
        param([bool]$isCore = $false)

        # TODO: we need to add support for tests running on core
        #   but for now, test is for non-core
        [int] $memoryInKilobytes = 0
        if ($isCore)
        {
            $null = (Get-PhysicallyInstalledSystemMemoryCore)::GetPhysicallyInstalledSystemMemory([ref]$memoryInKilobytes)
        }
        else
        {
            $null = (Get-PhysicallyInstalledSystemMemory)::GetPhysicallyInstalledSystemMemory([ref]$memoryInKilobytes)
        }

        return $memoryInKilobytes
    }

    function Get-PowerPlatformRole
    {
        $version = 0x2
        $powerRole = (Get-PowerDeterminePlatformRole)::PowerDeterminePlatformRoleEx($version)
        if ($powerRole -gt 9)
        {
            $powerRole = 0
        }
        return $powerRole
    }
    # HELPER METHODS RELYING ON P-INVOKE END ******************************************

    $cimClassList = @{}
    function Get-CimClass
    {
        param([string]$className, [string] $namespace = "root\cimv2")

        if (-not $cimClassList.ContainsKey($className))
        {
            $cimClassInstance = Get-CimInstance -ClassName $className -Namespace $namespace
            $cimClassList.Add($className, $cimClassInstance)
        }

        return $cimClassList.Get_Item($className)
    }

    function Get-CimClassPropVal
    {
        param([string]$className, [string]$propertyName, [string] $namespace = "root\cimv2")

        $cimClassInstance = Get-CimClass $className $namespace
        $cimClassInstance.$propertyName
    }

    function Get-CsNetworkAdapters
    {
        $networkAdapters = @()

        $adapters = Get-CimClass Win32_NetworkAdapter
        $configs = Get-CimClass Win32_NetworkAdapterConfiguration
        # easy-out: no adapters or configs
        if (!$adapters -or !$configs) { return $null }

        # build config hashtable
        $configHash = @{}
        foreach ($config in $configs)
        {
            if ($null -ne $config.Index)
            {
                $configHash.Add([string]$config.Index,$config)
            }
        }
        # easy-out: no config hash items
        if ($configHash.Count -eq 0)  { return $null }

        foreach ($adapter in $adapters)
        {
            # Easy skip: adapters that have a null connection status or null index
            if (!$adapter.NetConnectionStatus) { continue }

            # Easy skip: configHash does not contain adapter
            if (!$configHash.ContainsKey([string]$adapter.Index))  { continue }

            $connectionStatus = 13 # default NetConnectionStatus.Other
            if ($adapter.NetConnectionStatus) { $connectionStatus = $adapter.NetConnectionStatus}

            $config =$configHash.Item([string]$adapter.Index)

            $dHCPEnabled = $null
            $dHCPServer = $null
            $ipAddresses = $null
            if ($connectionStatus -eq 2) # 2 = NetConnectionStatus.Connected
            {
                $dHCPEnabled = $config.DHCPEnabled
                $dHCPServer = $config.DHCPServer;
                $ipAddresses = $config.IPAddress;
            }

            # new-up one adapter object
            $properties =
                @{
                    'Description'=$adapter.Description;
                    'ConnectionID'=$adapter.NetConnectionID;
                    'ConnectionStatus' = $connectionStatus;
                    'DHCPEnabled' = $dHCPEnabled;
                    'DHCPServer' = $dHCPServer;
                    'IPAddresses' = $ipAddresses;

                }
            $networkAdapter = New-Object -TypeName PSObject -Prop $properties

            # add adapter to list
            $networkAdapters += $networkAdapter
        }
        return $networkAdapters
    }

    function Get-CsProcessors
    {
        $processors = Get-CimClass Win32_Processor
        if (!$processors) {return $null }
        $csProcessors = @()
        foreach ($processor in $processors)
        {
            # new-up one adapter object
            $properties =
                @{
                    'Name'=$processor.Name;
                    'Manufacturer'=$processor.Manufacturer;
                    'Description'=$processor.Description;
                    'Architecture'=$processor.Architecture;
                    'AddressWidth'=$processor.AddressWidth;

                    'Availability'=$processor.Availability;
                    'CpuStatus'=$processor.CpuStatus;
                    'CurrentClockSpeed'=$processor.CurrentClockSpeed;
                    'DataWidth'=$processor.DataWidth;

                    'MaxClockSpeed'=$processor.MaxClockSpeed;
                    'NumberOfCores'=$processor.NumberOfCores;
                    'NumberOfLogicalProcessors'=$processor.NumberOfLogicalProcessors;
                    'ProcessorID'=$processor.ProcessorID;
                    'ProcessorType'=$processor.ProcessorType;
                    'Role'=$processor.Role;
                    'SocketDesignation'=$processor.SocketDesignation;
                    'Status'=$processor.Status;
                }
            $csProcessor = New-Object -TypeName PSObject -Prop $properties

            # add adapter to list
            $csProcessors += $csProcessor
        }
        $csProcessors
    }

    function Get-OsHardwareAbstractionLayer
    {
        $hal = $null
        $systemDirectory =  Get-CimClassPropVal Win32_OperatingSystem SystemDirectory
        $halPath = Join-Path -Path $systemDirectory -ChildPath "hal.dll"
        $query = 'SELECT * FROM CIM_DataFile Where Name="C:\WINDOWS\system32\hal.dll"'
        $query = $query -replace '\\','\\'
        $instance = Get-CimInstance -Query $query
        if ($instance)
        {
            $hal = [string]$instance[0].CimInstanceProperties["Version"].Value
        }
        return $hal
    }

    function Get-OsHotFixes
    {
        $hotfixes = Get-CimClass Win32_QuickFixEngineering | Select-Object -Property HotFixID,Description,InstalledOn,FixComments
        if (!$hotfixes) {return $null }

        $osHotFixes = @()

        foreach ($hotfix in $hotfixes)
        {
            $installedOn = $null
            if ($hotfix.InstalledOn)
            {
                $installedOn = $hotfix.InstalledOn.ToString("M/d/yyyy")
            }
            # new-up one adapter object
            $properties =
                @{
                    'HotFixID'=$hotfix.HotFixID;
                    'Description'=$hotfix.Description;
                    'InstalledOn'=$installedOn;
                    'FixComments'=$hotfix.FixComments;
                }
            $osHotFix = New-Object -TypeName PSObject -Prop $properties

            # add adapter to list
            $osHotFixes += $osHotFix
        }
        $osHotFixes
    }

    function Get-OsInUseVirtualMemory
    {
        $osInUseVirtualMemory  = $null
        $os = Get-CimClass Win32_OperatingSystem
        $totalVirtualMemorySize = $os.TotalVirtualMemorySize
        $freeVirtualMemory = $os.FreeVirtualMemory

        if (($totalVirtualMemorySize) -and ($freeVirtualMemory))
        {
            $osInUseVirtualMemory = $totalVirtualMemorySize - $freeVirtualMemory
        }
        return $osInUseVirtualMemory
    }

    function Get-OsServerLevel
    {
        # translated from cmldet logic (1) RegistryInfo.GetServerLevels; and (2) os.GetOtherInfo()
        $subkey = 'Software\Microsoft\Windows NT\CurrentVersion\Server\ServerLevels'
        $regKey = [Microsoft.Win32.Registry]::LocalMachine.OpenSubKey($subkey)
        $serverLevels = @{}
        try
        {
            if ($null -ne $regKey)
            {
                $serverLevelNames = $regKey.GetValueNames()

                foreach ($serverLevelName in $serverLevelNames)
                {
                    if ($regKey.GetValueKind($serverLevelName) -eq 4) # RegistryValueKind.DWord == 4
                    {
                        $val = $regKey.GetValue($serverLevelName)
                        $serverLevels.Add($serverLevelName, [System.Convert]::ToUInt32($val))
                    }
                }
            }
        }
        finally
        {
            if ($null -ne $regKey) { $regKey.Dispose()}
        }

        if ($null -eq $serverLevels -or $serverLevels.Count -eq 0)
        {
            return $null
        }

        [uint32]$rv
        # computerinfo enum ServerLevel
        #    0 = Unknown
        #    1 = NanoServer
        #    2 = ServerCore
        #    3 = ServerCoreWithManagementTools
        #    4 = FullServer
        if ($serverLevels.ContainsKey("NanoServer") -and $serverLevels["NanoServer"] -eq 1)
        {
            $rv = 1 # NanoServer
        }
        elseif ($serverLevels.ContainsKey("ServerCore") -and $serverLevels["ServerCore"] -eq 1)
        {
            $rv = 2 # ServerCore
            if ($serverLevels.ContainsKey("Server-Gui-Mgmt") -and $serverLevels["Server-Gui-Mgmt"] -eq 1)
            {
                $rv = 3 # ServerCoreWithManagementTools
                if ($serverLevels.ContainsKey("Server-Gui-Shell") -and $serverLevels["Server-Gui-Shell"] -eq 1)
                {
                    $rv = 4 # FullServer
                }
            }
        }

        return $rv
    }

    function Get-OsSuites
    {
        param($propertyName)

        $osProductSuites = @()
        $suiteMask = Get-CimClassPropVal Win32_OperatingSystem $propertyName
        if ($suiteMask)
        {
            foreach($suite in [System.Enum]::GetValues('Microsoft.PowerShell.Commands.OSProductSuite'))
            {
                if (($suiteMask -band $suite) -ne 0)
                {
                    $osProductSuites += $suite
                }
            }

        }
        return $osProductSuites
    }

    function Get-HyperVProperty
    {
        param([string]$propertyName)

        $hypervisorPresent = Get-CimClassPropVal Win32_ComputerSystem HypervisorPresent

        $dataExecutionPrevention_Available = $null
        $secondLevelAddressTranslationExtensions  = $null
        $virtualizationFirmwareEnabled  = $null
        $vMMonitorModeExtensions  = $null

        if (($null -ne $hypervisorPresent) -and ($hypervisorPresent -ne $true))
        {
            $dataExecutionPrevention_Available = Get-CimClassPropVal Win32_OperatingSystem DataExecutionPrevention_Available

            $secondLevelAddressTranslationExtensions = Get-CimClassPropVal Win32_Processor SecondLevelAddressTranslationExtensions
            $virtualizationFirmwareEnabled = Get-CimClassPropVal Win32_Processor VirtualizationFirmwareEnabled
            $vMMonitorModeExtensions = Get-CimClassPropVal Win32_Processor VMMonitorModeExtensions
        }
        switch ($propertyName)
        {
            "HyperVisorPresent" { return $hypervisorPresent }
            "HyperVRequirementDataExecutionPreventionAvailable" { return $dataExecutionPrevention_Available }
            "HyperVRequirementSecondLevelAddressTranslation"{ return $secondLevelAddressTranslationExtensions }
            "HyperVRequirementVirtualizationFirmwareEnabled"{ return $virtualizationFirmwareEnabled }
            "HyperVRequirementVMMonitorModeExtensions" { return $vMMonitorModeExtensions }
        }
    }

    function Get-KeyboardLayout
    {
        $keyboards = Get-CimClass Win32_Keyboard
        $result = $null
        if ($keyboards)
        {
            # cmdlet code comment TODO: handle multiple keyboards?
            #   there might be several keyboards found. For the moment
            #   we display info for only one
            $layout = $keyboards[0].Layout
            try
            {
                $layoutAsHex = [System.Convert]::ToUInt32($layout, 16)
                if ($null -ne $layoutAsHex)
                {
                    $result = Convert-LocaleIdToLocaleName $layoutAsHex
                }
            }
            catch
            {
              #swallow
            }
        }
        return $result
    }

    function Get-OsLanguageName
    {
        # updated 21May 2016 to follow updated logic from cmdlet
        $localeID = Get-CimClassPropVal Win32_OperatingSystem OSLanguage
        return Convert-LocaleIdToLocaleName $localeID
    }

    function Convert-LocaleIdToLocaleName
    {
        # This is a migrated/translated version of the cmdlet method = LocaleIdToLocaleName()
        # THIS is the comment from the cmdlet
        #    CoreCLR's System.Globalization.Culture does not appear to have a constructor
        #    that accepts an integer LocalID (LCID) value, so we'll PInvoke native code
        #    to get a locale name from an LCID value
        param($localeID)

        $sb = (New-Object System.Text.StringBuilder([int]85)) # 85 = Native.LOCALE_NAME_MAX_LENGTH
        $len = (Get-LCIDToLocaleName)::LCIDToLocaleName($localeID, $sb, $sb.Capacity, 0)
        if (($len -gt 0) -and ($sb.Length -gt 0))
        {
            return $sb.ToString()
        }
        return $null
    }

    function Get-Locale
    {
        # This is a migrated/translated version of the cmdlet method = Conversion.MakeLocale()
        # This method first tries to convert the string to a hex value
        #  and get the CultureInfo object from that value.
        #  Failing that it attempts to retrieve the CultureInfo object
        #  using the locale string as passed.

        $localeName = $null

        $locale =  Get-CimClassPropVal Win32_OperatingSystem Locale

        if ($null -ne $locale)
        {
            #$localeAsHex = $locale -as [hex]
            $localeAsHex = [System.Convert]::ToUInt32($locale, 16)
            if ($null -ne $localeAsHex)
            {

                try
                {
                    $localeName = Convert-LocaleIdToLocaleName $localeAsHex
                }
                catch
                {
                    # swallow this
                        # DEBUGGING
                        #return $_.Exception.Message
                }
            }

            if ($null -eq $localeName)
            {
                try
                {
                    $cultureInfo = (New-Object System.Globalization.CultureInfo($locale))
                    $localeName = $cultureInfo.Name
                }
                catch
                {
                    # swallow this
                }
            }
        }
        return $localeName
    }

    function Get-OsPagingFiles
    {
        $osPagingFiles = @()
        $pageFileUsage =  Get-CimClass Win32_PageFileUsage
        if ($null -ne $pageFileUsage)
        {
            foreach ($pageFileItem in $pageFileUsage)
            {
                $osPagingFiles += $pageFileItem.Caption
            }
        }

        return [string[]]$osPagingFiles
    }

    function Get-UnixSecondsToDateTime
    {
        param([string]$seconds)

        $origin = New-Object -Type DateTime -ArgumentList 1970, 1, 1, 0, 0, 0, 0
        $origin.AddSeconds($seconds)
    }

    function Get-WinNtCurrentVersion
    {
        # This method was translated/converted from cmdlet impl method = RegistryInfo.GetWinNtCurrentVersion();
        param([string]$propertyName)

        $key = 'HKLM:\Software\Microsoft\Windows NT\CurrentVersion\'
        $regValue = (Get-ItemProperty -Path $key -Name $propertyName -ErrorAction SilentlyContinue).$propertyName

        if ($propertyName -eq "InstallDate")
        {
            # more complicated case: InstallDate
            if ($regValue)
            {
                return Get-UnixSecondsToDateTime $regValue
            }
        }
        else
        {
            return $regValue
        }

        return $null
    }

    function Get-ExpectedComputerInfoValue
    {
        param([string]$propertyName)

        switch ($propertyName)
        {
            "BiosBIOSVersion" {return Get-CimClassPropVal Win32_bios BiosVersion}
            "BiosBuildNumber" {return Get-CimClassPropVal Win32_bios BuildNumber}
            "BiosCaption" {return Get-CimClassPropVal Win32_bios Caption}
            "BiosCharacteristics" {return Get-CimClassPropVal Win32_bios BiosCharacteristics}
            "BiosCodeSet" {return Get-CimClassPropVal Win32_bios CodeSet}
            "BiosCurrentLanguage" {return Get-CimClassPropVal Win32_bios CurrentLanguage}
            "BiosDescription" {return Get-CimClassPropVal Win32_bios Description}
            "BiosEmbeddedControllerMajorVersion" {return Get-CimClassPropVal Win32_bios EmbeddedControllerMajorVersion}
            "BiosEmbeddedControllerMinorVersion" {return Get-CimClassPropVal Win32_bios EmbeddedControllerMinorVersion}
            "BiosFirmwareType" {return Get-BiosFirmwareType}
            "BiosIdentificationCode" {return Get-CimClassPropVal Win32_bios IdentificationCode}
            "BiosInstallableLanguages" {return Get-CimClassPropVal Win32_bios InstallableLanguages}
            "BiosInstallDate" {return Get-CimClassPropVal Win32_bios InstallDate}
            "BiosLanguageEdition" {return Get-CimClassPropVal Win32_bios LanguageEdition}
            "BiosListOfLanguages" {return Get-CimClassPropVal Win32_bios ListOfLanguages}
            "BiosManufacturer" {return Get-CimClassPropVal Win32_bios Manufacturer}
            "BiosName" {return Get-CimClassPropVal Win32_bios Name}
            "BiosOtherTargetOS" {return Get-CimClassPropVal Win32_bios OtherTargetOS}
            "BiosPrimaryBIOS" {return Get-CimClassPropVal Win32_bios PrimaryBIOS}
            "BiosReleaseDate" {return Get-CimClassPropVal Win32_bios ReleaseDate}
            "BiosSerialNumber" {return Get-CimClassPropVal Win32_bios SerialNumber}
            "BiosSMBIOSBIOSVersion" {return Get-CimClassPropVal Win32_bios SMBIOSBIOSVersion}
            "BiosSMBIOSPresent" {return Get-CimClassPropVal Win32_bios SMBIOSPresent}
            "BiosSMBIOSMajorVersion" {return Get-CimClassPropVal Win32_bios SMBIOSMajorVersion}
            "BiosSMBIOSMinorVersion" {return Get-CimClassPropVal Win32_bios SMBIOSMinorVersion}
            "BiosSoftwareElementState" {return Get-CimClassPropVal Win32_bios SoftwareElementState}
            "BiosStatus" {return Get-CimClassPropVal Win32_bios Status}
            "BiosSystemBiosMajorVersion" {return Get-CimClassPropVal Win32_bios SystemBiosMajorVersion}
            "BiosSystemBiosMinorVersion" {return Get-CimClassPropVal Win32_bios SystemBiosMinorVersion}
            "BiosTargetOperatingSystem" {return Get-CimClassPropVal Win32_bios TargetOperatingSystem}
            "BiosVersion" {return Get-CimClassPropVal Win32_bios Version}

            "CsAdminPasswordStatus" {return Get-CimClassPropVal Win32_ComputerSystem AdminPasswordStatus}
            "CsAutomaticManagedPagefile" {return Get-CimClassPropVal Win32_ComputerSystem AutomaticManagedPagefile}
            "CsAutomaticResetBootOption" {return Get-CimClassPropVal Win32_ComputerSystem AutomaticResetBootOption}
            "CsAutomaticResetCapability" {return Get-CimClassPropVal Win32_ComputerSystem AutomaticResetCapability}
            "CsBootOptionOnLimit" {return Get-CimClassPropVal Win32_ComputerSystem BootOptionOnLimit}
            "CsBootOptionOnWatchDog" {return Get-CimClassPropVal Win32_ComputerSystem BootOptionOnWatchDog}
            "CsBootROMSupported" {return Get-CimClassPropVal Win32_ComputerSystem BootROMSupported}
            "CsBootStatus" {return Get-CimClassPropVal Win32_ComputerSystem BootStatus}
            "CsBootupState" {return Get-CimClassPropVal Win32_ComputerSystem BootupState}
            "CsCaption" {return Get-CimClassPropVal Win32_ComputerSystem Caption}
            "CsChassisBootupState" {return Get-CimClassPropVal Win32_ComputerSystem ChassisBootupState}
            "CsChassisSKUNumber" {return Get-CimClassPropVal Win32_ComputerSystem ChassisSKUNumber}
            "CsCurrentTimeZone" {return Get-CimClassPropVal Win32_ComputerSystem CurrentTimeZone}
            "CsDaylightInEffect" {return Get-CimClassPropVal Win32_ComputerSystem DaylightInEffect}
            "CsDescription" {return Get-CimClassPropVal Win32_ComputerSystem Description}
            "CsDNSHostName" {return Get-CimClassPropVal Win32_ComputerSystem DNSHostName}
            "CsDomain" {return Get-CimClassPropVal Win32_ComputerSystem Domain}
            "CsDomainRole" {return Get-CimClassPropVal Win32_ComputerSystem DomainRole}
            "CsEnableDaylightSavingsTime" {return Get-CimClassPropVal Win32_ComputerSystem EnableDaylightSavingsTime}
            "CsFrontPanelResetStatus" {return Get-CimClassPropVal Win32_ComputerSystem FrontPanelResetStatus}
            "CsHypervisorPresent" {return Get-CimClassPropVal Win32_ComputerSystem HypervisorPresent}
            "CsInfraredSupported" {return Get-CimClassPropVal Win32_ComputerSystem InfraredSupported}
            "CsInitialLoadInfo" {return Get-CimClassPropVal Win32_ComputerSystem InitialLoadInfo}
            "CsInstallDate" {return Get-CimClassPropVal Win32_ComputerSystem InstallDate}
            "CsKeyboardPasswordStatus" {return Get-CimClassPropVal Win32_ComputerSystem KeyboardPasswordStatus}
            "CsLastLoadInfo" {return Get-CimClassPropVal Win32_ComputerSystem LastLoadInfo}
            "CsManufacturer" {return Get-CimClassPropVal Win32_ComputerSystem Manufacturer}
            "CsModel" {return Get-CimClassPropVal Win32_ComputerSystem Model}
            "CsName" {return Get-CimClassPropVal Win32_ComputerSystem Name}
            "CsNetworkAdapters" { return Get-CsNetworkAdapters }
            "CsNetworkServerModeEnabled" {return Get-CimClassPropVal Win32_ComputerSystem NetworkServerModeEnabled}
            "CsNumberOfLogicalProcessors" {return [System.Environment]::GetEnvironmentVariable("NUMBER_OF_PROCESSORS")}
            "CsNumberOfProcessors" {return Get-CimClassPropVal Win32_ComputerSystem NumberOfProcessors }
            "CsOEMStringArray" {return Get-CimClassPropVal Win32_ComputerSystem OEMStringArray}
            "CsPartOfDomain" {return Get-CimClassPropVal Win32_ComputerSystem PartOfDomain}
            "CsPauseAfterReset" {return Get-CimClassPropVal Win32_ComputerSystem PauseAfterReset}
            "CsPCSystemType" {return Get-CimClassPropVal Win32_ComputerSystem PCSystemType}
            "CsPCSystemTypeEx" {return Get-CimClassPropVal Win32_ComputerSystem PCSystemTypeEx}
            "CsPhysicallyInstalledMemory" {return Get-CsPhysicallyInstalledSystemMemory}
            "CsPowerManagementCapabilities" {return Get-CimClassPropVal Win32_ComputerSystem PowerManagementCapabilities}
            "CsPowerManagementSupported" {return Get-CimClassPropVal Win32_ComputerSystem PowerManagementSupported}
            "CsPowerOnPasswordStatus" {return Get-CimClassPropVal Win32_ComputerSystem PowerOnPasswordStatus}
            "CsPowerState" {return Get-CimClassPropVal Win32_ComputerSystem PowerState}
            "CsPowerSupplyState" {return Get-CimClassPropVal Win32_ComputerSystem PowerSupplyState}
            "CsPrimaryOwnerContact" {return Get-CimClassPropVal Win32_ComputerSystem PrimaryOwnerContact}
            "CsPrimaryOwnerName" {return Get-CimClassPropVal Win32_ComputerSystem PrimaryOwnerName}
            "CsProcessors" { return Get-CsProcessors }
            "CsResetCapability" {return Get-CimClassPropVal Win32_ComputerSystem ResetCapability}
            "CsResetCount" {return Get-CimClassPropVal Win32_ComputerSystem ResetCount}
            "CsResetLimit" {return Get-CimClassPropVal Win32_ComputerSystem ResetLimit}
            "CsRoles" {return Get-CimClassPropVal Win32_ComputerSystem Roles}
            "CsStatus" {return Get-CimClassPropVal Win32_ComputerSystem Status}
            "CsSupportContactDescription" {return Get-CimClassPropVal Win32_ComputerSystem SupportContactDescription}
            "CsSystemFamily" {return Get-CimClassPropVal Win32_ComputerSystem SystemFamily}
            "CsSystemSKUNumber" {return Get-CimClassPropVal Win32_ComputerSystem SystemSKUNumber}
            "CsSystemType" {return Get-CimClassPropVal Win32_ComputerSystem SystemType}
            "CsThermalState" {return Get-CimClassPropVal Win32_ComputerSystem ThermalState}
            "CsTotalPhysicalMemory" {return Get-CimClassPropVal Win32_ComputerSystem TotalPhysicalMemory}
            "CsUserName" {return Get-CimClassPropVal Win32_ComputerSystem UserName}
            "CsWakeUpType" {return Get-CimClassPropVal Win32_ComputerSystem WakeUpType}
            "CsWorkgroup" {return Get-CimClassPropVal Win32_ComputerSystem Workgroup}

            "HyperVisorPresent" {return Get-HyperVProperty $propertyName}
            "HyperVRequirementDataExecutionPreventionAvailable" {return Get-HyperVProperty $propertyName}
            "HyperVRequirementSecondLevelAddressTranslation" {return Get-HyperVProperty $propertyName}
            "HyperVRequirementVirtualizationFirmwareEnabled" {return Get-HyperVProperty $propertyName}
            "HyperVRequirementVMMonitorModeExtensions" {return Get-HyperVProperty $propertyName}
            "KeyboardLayout" {return Get-KeyboardLayout}
            "LogonServer" {return [Microsoft.Win32.Registry]::GetValue("HKEY_Current_User\Volatile Environment", "LOGONSERVER", "")}

            "OsArchitecture" {return Get-CimClassPropVal Win32_OperatingSystem OsArchitecture}
            "OsBootDevice" {return Get-CimClassPropVal Win32_OperatingSystem BootDevice}
            "OsBuildNumber" {return Get-CimClassPropVal Win32_OperatingSystem BuildNumber}
            "OsBuildType" {return Get-CimClassPropVal Win32_OperatingSystem BuildType}
            "OsCodeSet" {return Get-CimClassPropVal Win32_OperatingSystem CodeSet}
            "OsCountryCode" {return Get-CimClassPropVal Win32_OperatingSystem CountryCode}
            "OsCSDVersion" {return Get-CimClassPropVal Win32_OperatingSystem CSDVersion}
            "OsCurrentTimeZone" {return Get-CimClassPropVal Win32_OperatingSystem CurrentTimeZone}
            "OsDataExecutionPrevention32BitApplications" {return Get-CimClassPropVal Win32_OperatingSystem DataExecutionPrevention_32BitApplications}
            "OsDataExecutionPreventionAvailable" {return Get-CimClassPropVal Win32_OperatingSystem DataExecutionPrevention_Available}
            "OsDataExecutionPreventionDrivers" {return Get-CimClassPropVal Win32_OperatingSystem DataExecutionPrevention_Drivers}
            "OsDataExecutionPreventionSupportPolicy" {return Get-CimClassPropVal Win32_OperatingSystem DataExecutionPrevention_SupportPolicy}
            "OsDebug" {return Get-CimClassPropVal Win32_OperatingSystem Debug}
            "OsDistributed" {return Get-CimClassPropVal Win32_OperatingSystem Distributed}
            "OsEncryptionLevel" {return Get-CimClassPropVal Win32_OperatingSystem EncryptionLevel}
            "OsForegroundApplicationBoost" {return Get-CimClassPropVal Win32_OperatingSystem ForegroundApplicationBoost}

            # OsFreePhysicalMemory => fragile test: fluid/dynamic (see special cases)
            #"OsFreeSpaceInPagingFiles" {return Get-CimClassPropVal Win32_OperatingSystem FreePhysicalMemory}
            # OsFreeSpaceInPagingFiles => fragile test: fluid/dynamic (see special cases)
            #"OsFreeSpaceInPagingFiles" {return Get-CimClassPropVal Win32_OperatingSystem FreeSpaceInPagingFiles}
            # OsFreeVirtualMemory => fragile test: fluid/dynamic (see special cases)
            #"OsFreeVirtualMemory" {return Get-CimClassPropVal Win32_OperatingSystem FreeVirtualMemory}

            "OsHardwareAbstractionLayer" {return Get-OsHardwareAbstractionLayer}
            "OsHotFixes" {return Get-OsHotFixes }
            "OsInstallDate" {return Get-CimClassPropVal Win32_OperatingSystem InstallDate}
            "OsInUseVirtualMemory"  { return Get-OsInUseVirtualMemory }
            "OsLanguage" {return Get-OsLanguageName}
            "OsLastBootUpTime" {return Get-CimClassPropVal Win32_OperatingSystem LastBootUpTime}

            # OsLocalDateTime => fragile test: fluid/dynamic  (see special cases)
            #"OsLocalDateTime" {return Get-CimClassPropVal Win32_OperatingSystem LocalDateTime}

            "OsLocale" {return Get-Locale}
            "OsLocaleID" {return Get-CimClassPropVal Win32_OperatingSystem Locale}
            "OsManufacturer" {return Get-CimClassPropVal Win32_OperatingSystem Manufacturer}
            "OsMaxNumberOfProcesses" {return Get-CimClassPropVal Win32_OperatingSystem MaxNumberOfProcesses}
            "OsMaxProcessMemorySize" {return Get-CimClassPropVal Win32_OperatingSystem MaxProcessMemorySize}
            "OsMuiLanguages" {return Get-CimClassPropVal Win32_OperatingSystem MuiLanguages}
            "OsName" {return Get-CimClassPropVal Win32_OperatingSystem Caption}
            "OsNumberOfLicensedUsers" {return Get-CimClassPropVal Win32_OperatingSystem NumberOfLicensedUsers}

            # OsNumberOfProcesses => fragile test: fluid/dynamic
            #"OsNumberOfProcesses" {return Get-CimClassPropVal Win32_OperatingSystem NumberOfProcesses}

            "OsNumberOfUsers" {return Get-CimClassPropVal Win32_OperatingSystem NumberOfUsers}
            "OsOperatingSystemSKU" {return Get-CimClassPropVal Win32_OperatingSystem OperatingSystemSKU}
            "OsOrganization" {return Get-CimClassPropVal Win32_OperatingSystem Organization}
            "OsOtherTypeDescription" {return Get-CimClassPropVal Win32_OperatingSystem OtherTypeDescription}
            "OsPAEEnabled" {return Get-CimClassPropVal Win32_OperatingSystem PAEEnabled}
            "OsPagingFiles" {return Get-OsPagingFiles}
            "OsPortableOperatingSystem" {return Get-CimClassPropVal Win32_OperatingSystem PortableOperatingSystem}
            "OsPrimary" {return Get-CimClassPropVal Win32_OperatingSystem Primary}
            "OsProductSuites" {return Get-OsSuites OSProductSuite }
            "OsProductType" {return Get-CimClassPropVal Win32_OperatingSystem ProductType}

            "OsRegisteredUser" {return Get-CimClassPropVal Win32_OperatingSystem RegisteredUser}
            "OsSerialNumber" {return Get-CimClassPropVal Win32_OperatingSystem SerialNumber}

            "OsServerLevel" {return Get-OsServerLevel}

            "OsServicePackMajorVersion" {return Get-CimClassPropVal Win32_OperatingSystem ServicePackMajorVersion}
            "OsServicePackMinorVersion" {return Get-CimClassPropVal Win32_OperatingSystem ServicePackMinorVersion}

            "OsSizeStoredInPagingFiles" {return Get-CimClassPropVal Win32_OperatingSystem SizeStoredInPagingFiles}
            "OsStatus" {return Get-CimClassPropVal Win32_OperatingSystem Status}
            "OsSuites" {return Get-OsSuites SuiteMask }
            "OsSystemDevice" {return Get-CimClassPropVal Win32_OperatingSystem SystemDevice}
            "OsSystemDirectory" {return Get-CimClassPropVal Win32_OperatingSystem SystemDirectory}
            "OsSystemDrive" {return Get-CimClassPropVal Win32_OperatingSystem SystemDrive}
            "OsTotalSwapSpaceSize" {return Get-CimClassPropVal Win32_OperatingSystem TotalSwapSpaceSize}
            "OsTotalVirtualMemorySize" {return Get-CimClassPropVal Win32_OperatingSystem TotalVirtualMemorySize}
            "OsTotalVisibleMemorySize" {return Get-CimClassPropVal Win32_OperatingSystem TotalVisibleMemorySize}
            "OsType" {return Get-CimClassPropVal Win32_OperatingSystem OSType }

            # OsUptime => fragile test: fluid/dynamic
            #"OsUptime" {return Get-CimClassPropVal Win32_OperatingSystem Uptime}

            "OsVersion" {return Get-CimClassPropVal Win32_OperatingSystem Version}
            "OsWindowsDirectory" {return [System.Environment]::GetEnvironmentVariable("windir")}

            "PowerPlatformRole" { return Get-PowerPlatformRole }
            "TimeZone" {return ([System.TimeZoneInfo]::Local).DisplayName}

            "WindowsBuildLabEx" { return Get-WinNtCurrentVersion BuildLabEx }
            "WindowsCurrentVersion" { return Get-WinNtCurrentVersion CurrentVersion}
            "WindowsEditionId" { return Get-WinNtCurrentVersion EditionID}
            "WindowsInstallationType" { return Get-WinNtCurrentVersion InstallationType}
            "WindowsInstallDateFromRegistry" { return Get-WinNtCurrentVersion InstallDate}
            "WindowsProductId" { return Get-WinNtCurrentVersion ProductId}
            "WindowsProductName" { return Get-WinNtCurrentVersion ProductName}
            "WindowsRegisteredOrganization" {return Get-WinNtCurrentVersion RegisteredOrganization}
            "WindowsRegisteredOwner" {return Get-WinNtCurrentVersion RegisteredOwner}
            "WindowsVersion" {return Get-WinNtCurrentVersion ReleaseId}
            "WindowsUBR" {return Get-WinNtCurrentVersion UBR}

            "WindowsSystemRoot" {return [System.Environment]::GetEnvironmentVariable("SystemRoot")}

            default {return "Unknown/unsupported propertyName = $propertyName"}
        }
    }

    $expected = New-Object -TypeName PSObject
    foreach ($propertyName in [string[]]$propertyNames)
    {
        $expected | Add-Member -MemberType NoteProperty -Name $propertyName -Value (Get-ExpectedComputerInfoValue $propertyName)
    }
    return $expected
}

try {
    #skip all tests on non-windows platform
    $originalDefaultParameterValues = $PSDefaultParameterValues.Clone()
    $PSDefaultParameterValues["it:skip"] = !$IsWindows

    Describe "Tests for Get-ComputerInfo: Ensure Type returned" -tags "CI", "RequireAdminOnWindows" {

        It "Verify type returned by Get-ComputerInfo" {
            $computerInfo = Get-ComputerInfo
            $computerInfo | Should -BeOfType Microsoft.PowerShell.Commands.ComputerInfo
        }

        It "Verify progress records in Get-ComputerInfo" {
            try {
                $j = Start-Job { Get-ComputerInfo }
                $j | Wait-Job
                $j.ChildJobs[0].Progress | Should -HaveCount 9
                $j.ChildJobs[0].Progress[-1].RecordType | Should -Be ([System.Management.Automation.ProgressRecordType]::Completed)
            }
            finally {
                $j | Remove-Job
            }
        }
    }

    Describe "Tests for Get-ComputerInfo" -tags "Feature", "RequireAdminOnWindows" {
        Context "Validate All Properties" {
            BeforeAll {
                # do this once here rather than multiple times in Test 01
                $computerInformation = Get-ComputerInfoForTest
                $propertyNames = Get-PropertyNamesForComputerInfoTest
                $Expected = New-ExpectedComputerInfo $propertyNames
                $testCases = $propertyNames | ForEach-Object { @{ "Property" = $_ } }
            }

            #
            # Test 01. Standard Property test - No property filter applied
            # This is done with a set of test cases to improve failure investigation
            # since the data we get back comes from a number of sources, it will be
            # easier to debug the problem if we know *all* the failures
            # issue: https://github.com/PowerShell/PowerShell/issues/4762
            #    CsPhysicallyInstalledMemory not available when run in nightly builds
            It "Test 01. Standard Property test - all properties (<property>)" -testcase $testCases {
                param ( $property )

                if ($excludedProperties -contains $property) {
                    Set-ItResult -Pending -Because "'$property' is not available in nightly builds"
                }

                $specialProperties = "CsNetworkAdapters","CsProcessors","OsHotFixes"
                if ( $specialProperties -contains $property )
                {
                    $ObservedList = $ComputerInformation.$property
                    $ExpectedList = $Expected.$property
                    $SpecialPropertyList = ($ObservedList)[0].psobject.properties.name
                    Compare-Object $ObservedList $ExpectedList -Property $SpecialPropertyList | Should -BeNullOrEmpty
                }
                else
                {
                    $left = $computerInformation.$property
                    $right = $Expected.$Property
                    # if we have a list, we need to compare it appropriately
                    if ( $left -is [Collections.IList] )
                    {
                        $left = $left -join ":"
                        $right = $right -join ":"
                    }
                    $left | Should -Be $right
                }
            }
        }

        Context "Filter Variations" {
            #
            # Test 02.001 Filter Property - Property filter with one valid item
            #
            It "Test 02.001 Filter Property - Property filter with one valid item" {
                $propertyNames =  @("BiosBIOSVersion")
                $expectedProperties = @("BiosBIOSVersion")
                $propertyFilter = "BiosBIOSVersion"
                $computerInfoWithProp = Get-ComputerInfoForTest -properties $propertyFilter
                $computerInfoWithProp | Should -BeOfType pscustomobject
                @($computerInfoWithProp.psobject.properties).count | Should -Be 1
                $computerInfoWithProp.$propertyFilter | Should -Be $expected.$propertyFilter
            }

            #
            # Test 02.002 Filter Property - Property filter with three valid items
            #
            It "Test 02.002 Filter Property - Property filter with three valid items" {
                $propertyNames =  @("BiosBIOSVersion","BiosBuildNumber","BiosCaption")
                $expectedProperties = @("BiosBIOSVersion","BiosBuildNumber","BiosCaption")
                $propertyFilter = @("BiosBIOSVersion","BiosBuildNumber","BiosCaption")
                $computerInfoWithProp = Get-ComputerInfoForTest -properties $propertyFilter
                $computerInfoWithProp | Should -BeOfType pscustomobject
                @($computerInfoWithProp.psobject.properties).count | Should -Be 3
                foreach($property in $propertyFilter) {
                    $ComputerInfoWithProp.$property | Should -Be $Expected.$property
                }
            }

            #
            # Test 02.003 Filter Property - Property filter with one invalid item
            #
            It "Test 02.003 Filter Property - Property filter with one invalid item" {
                $propertyNames =  $null
                $expectedProperties = $null
                $propertyFilter = @("BiosBIOSVersionXXX")
                $computerInfoWithProp = Get-ComputerInfoForTest -properties $propertyFilter
                $computerInfoWithProp | Should -BeOfType pscustomobject
                @($computerInfoWithProp.psobject.properties).count | Should -Be 0
            }

            #
            # Test 02.004 Filter Property - Property filter with four invalid items
            #
            It "Test 02.004 Filter Property - Property filter with four invalid items" {
                $propertyNames =  $null
                $expectedProperties = $null
                $propertyFilter = @("BiosBIOSVersionXXX","InvalidProperty1","InvalidProperty2","InvalidProperty3")
                $computerInfoWithProp = Get-ComputerInfoForTest -properties $propertyFilter
                $computerInfoWithProp | Should -BeOfType pscustomobject
                @($computerInfoWithProp.psobject.properties).count | Should -Be 0
            }

            #
            # Test 02.005 Filter Property - Property filter with valid and invalid items: ver #1
            #
            It "Test 02.005 Filter Property - Property filter with valid and invalid items: ver #1" {
                $propertyNames =  @("BiosCodeSet","BiosCurrentLanguage","BiosDescription")
                $expectedProperties = @("BiosCodeSet","BiosCurrentLanguage","BiosDescription")
                $propertyFilter = @("InvalidProperty1","BiosCodeSet","BiosCurrentLanguage","BiosDescription")
                $computerInfoWithProp = Get-ComputerInfoForTest -properties $propertyFilter
                $computerInfoWithProp | Should -BeOfType pscustomobject
                $realProperties  = $propertyFilter | Where-Object { $_ -notmatch "^InvalidProperty[0-9]+" }
                @($computerInfoWithProp.psobject.properties).count | Should -Be $realProperties.Count
                foreach ( $property in $realProperties )
                {
                    $computerInfoWithProp.$property | Should -Be $expected.$property
                }
            }

            #
            # Test 02.006 Filter Property - Property filter with valid and invalid items: ver #2
            #
            It "Test 02.006 Filter Property - Property filter with valid and invalid items: ver #2" {
                $propertyNames =  @("BiosCodeSet","BiosCurrentLanguage","BiosDescription")
                $expectedProperties = @("BiosCodeSet","BiosCurrentLanguage","BiosDescription")
                $propertyFilter = @("BiosCodeSet","InvalidProperty1","BiosCurrentLanguage","BiosDescription","InvalidProperty2")
                $computerInfoWithProp = Get-ComputerInfoForTest -properties $propertyFilter
                $computerInfoWithProp | Should -BeOfType pscustomobject
                $realProperties  = $propertyFilter | Where-Object { $_ -notmatch "^InvalidProperty[0-9]+" }
                @($computerInfoWithProp.psobject.properties).count | Should -Be $realProperties.Count
                foreach ( $property in $realProperties )
                {
                    $computerInfoWithProp.$property | Should -Be $expected.$property
                }
            }

            #
            # Test 02.007 Filter Property - Property filter with wild card: ver #1
            #
            It "Test 02.007 Filter Property - Property filter with wild card: ver #1" {
                $propertyNames =  @("BiosCaption","BiosCharacteristics","BiosCodeSet","BiosCurrentLanguage")
                $expectedProperties = @("BiosCaption","BiosCharacteristics","BiosCodeSet","BiosCurrentLanguage")
                $propertyFilter = @("BiosC*")
                $computerInfoWithProp = Get-ComputerInfoForTest -properties $propertyFilter
                $computerInfoWithProp | Should -BeOfType pscustomobject
                @($computerInfoWithProp.psobject.properties).count | Should -Be $expectedProperties.Count
                foreach ( $property in $expectedProperties )
                {
                    $computerInfoWithProp.$property | Should -Be $expected.$property
                }
            }

            #
            # Test 02.008 Filter Property - Property filter with wild card and fixed
            #
            It "Test 02.008 Filter Property - Property filter with wild card and fixed" {
                $propertyNames =  @("BiosCaption","BiosCharacteristics","BiosCodeSet","BiosCurrentLanguage","CsCaption")
                $expectedProperties = @("BiosCaption","BiosCharacteristics","BiosCodeSet","BiosCurrentLanguage","CsCaption")
                $propertyFilter = @("BiosC*","CsCaption")
                $computerInfoWithProp = Get-ComputerInfoForTest -properties $propertyFilter
                $computerInfoWithProp | Should -BeOfType pscustomobject
                @($computerInfoWithProp.psobject.properties).count | Should -Be $expectedProperties.Count
                foreach ( $property in $expectedProperties )
                {
                    $computerInfoWithProp.$property | Should -Be $expected.$property
                }
            }

            #
            # Test 02.009 Filter Property - Property filter with wild card, fixed and invalid
            #
            It "Test 02.009 Filter Property - Property filter with wild card, fixed and invalid" {
                $propertyNames =  @("BiosCaption","BiosCharacteristics","BiosCodeSet","BiosCurrentLanguage","CsCaption")
                $expectedProperties = @("BiosCaption","BiosCharacteristics","BiosCodeSet","BiosCurrentLanguage","CsCaption")
                $propertyFilter = @("CsCaption","InvalidProperty1","BiosC*")
                $computerInfoWithProp = Get-ComputerInfoForTest -properties $propertyFilter
                $computerInfoWithProp | Should -BeOfType pscustomobject
                @($computerInfoWithProp.psobject.properties).count | Should -Be $expectedProperties.Count
                foreach ( $property in $expectedProperties )
                {
                    $computerInfoWithProp.$property | Should -Be $expected.$property
                }
            }

            #
            # Test 02.010 Filter Property - Property filter with wild card invalid
            #
            It "Test 02.010 Filter Property - Property filter with wild card invalid" {
                $propertyNames =  $null
                $expectedProperties = $null
                $propertyFilter = @("BiosBIOSVersionX*")
                $computerInfoWithProp = Get-ComputerInfoForTest -properties $propertyFilter
                $computerInfoWithProp | Should -BeOfType pscustomobject
                @($computerInfoWithProp.psobject.properties).count | Should -Be 0
            }
        }

    }

    Describe "Special Case Tests for Get-ComputerInfo" -tags "Feature", "RequireAdminOnWindows" {

        BeforeAll {
            if ($IsWindows)
            {
                Add-Type -Name 'slc' -Namespace Win32Functions -MemberDefinition @'
                    [DllImport("slc.dll", CharSet = CharSet.Unicode)]
                    public static extern int SLGetWindowsInformationDWORD(string licenseProperty, out int propertyValue);
'@
                # Determine if the Software Licensing for CodeIntegrity is enabled
                function HasDeviceGuardLicense
                {
                    try
                    {
                        $policy = $null
                        if ([Win32Functions.slc]::SLGetWindowsInformationDWORD("CodeIntegrity-AllowConfigurablePolicy", [Ref]$policy) -eq 0 -and $policy -eq 1)
                        {
                            return $true
                        }
                    }
                    catch
                    {
                        # fall through
                    }

                    return $false
                }

                function Get-DeviceGuard
                {
                    $returnValue = @{
                        SmartStatus = 0     # Off
                        AvailableSecurityProperties = $null
                        CodeIntegrityPolicyEnforcementStatus = $null
                        RequiredSecurityProperties = $null
                        SecurityServicesConfigured = $null
                        SecurityServicesRunning = $null
                        UserModeCodeIntegrityPolicyEnforcementStatus = $null
                    }
                    try
                    {
                        $instance = Get-CimInstance Win32_DeviceGuard -Namespace 'root\Microsoft\Windows\DeviceGuard' -ErrorAction Stop
                        $ss = $instance.VirtualizationBasedSecurityStatus;
                        if ($null -ne $ss)
                        {
                            $returnValue.SmartStatus = $ss;
                        }
                        $returnValue.AvailableSecurityProperties = $instance.AvailableSecurityProperties
                        $returnValue.CodeIntegrityPolicyEnforcementStatus = $instance.CodeIntegrityPolicyEnforcementStatus
                        $returnValue.RequiredSecurityProperties = $instance.RequiredSecurityProperties
                        $returnValue.SecurityServicesConfigured = $instance.SecurityServicesConfigured
                        $returnValue.SecurityServicesRunning = $instance.SecurityServicesRunning
                        $returnValue.UserModeCodeIntegrityPolicyEnforcementStatus = $instance.UserModeCodeIntegrityPolicyEnforcementStatus
                    }
                    catch
                    {
                        # Swallow any errors and keep the deviceGuardInfo properties empty
                        # This is what the cmdlet is expected to do
                    }

                    return $returnValue
                }

                $observed = Get-ComputerInfoForTest
            }
        }

        It "Test for DeviceGuard properties" -Pending {
            if (-not (HasDeviceGuardLicense))
            {
                $observed.DeviceGuardSmartStatus | Should -Be 0
                $observed.DeviceGuardRequiredSecurityProperties | Should -BeNullOrEmpty
                $observed.DeviceGuardAvailableSecurityProperties | Should -BeNullOrEmpty
                $observed.DeviceGuardSecurityServicesConfigured | Should -BeNullOrEmpty
                $observed.DeviceGuardSecurityServicesRunning | Should -BeNullOrEmpty
                $observed.DeviceGuardCodeIntegrityPolicyEnforcementStatus | Should -BeNullOrEmpty
                $observed.DeviceGuardUserModeCodeIntegrityPolicyEnforcementStatus | Should -BeNullOrEmpty
            }
            else
            {
                $deviceGuard = Get-DeviceGuard
                # can't get amended qualifiers using cim cmdlets so we define them here
                $requiredSecurityPropertiesValues = @{
                    "1" = "BaseVirtualizationSupport"
                    "2" = "SecureBoot"
                    "3" = "DMAProtection"
                    "4" = "SecureMemoryOverwrite"
                    "5" = "UEFICodeReadonly"
                    "6" = "SMMSecurityMitigations"
                    "7" = "ModeBasedExecutionControl"
                }
                $smartStatusValues = @{
                    "0" = "Off"
                    "1" = "Enabled"
                    "2" = "Running"
                }
                $securityServicesRunningValues = @{
                    "0" = "0"
                    "1" = "CredentialGuard"
                    "2" = "HypervisorEnforcedCodeIntegrity"
                }
                $observed.DeviceGuardSmartStatus | Should -Be (Get-StringValuesFromValueMap -valuemap $smartStatusValues -values $deviceGuard.SmartStatus)
                if ($deviceGuard.RequiredSecurityProperties -eq $null)
                {
                    $observed.DeviceGuardRequiredSecurityProperties | Should -BeNullOrEmpty
                }
                else
                {
                    $observed.DeviceGuardRequiredSecurityProperties | Should -Not -BeNullOrEmpty
                    [string]::Join(",", $observed.DeviceGuardRequiredSecurityProperties) | Should -Be (Get-StringValuesFromValueMap -valuemap $requiredSecurityPropertiesValues -values $deviceGuard.RequiredSecurityProperties)
                }
                $observed.DeviceGuardAvailableSecurityProperties | Should -Be $deviceGuard.AvailableSecurityProperties
                $observed.DeviceGuardSecurityServicesConfigured | Should -Be $deviceGuard.SecurityServicesConfigured
                if ($deviceGuard.SecurityServicesRunning -eq $null)
                {
                    $observed.DeviceGuardSecurityServicesRunning | Should -BeNullOrEmpty
                }
                else
                {
                    $observed.DeviceGuardSecurityServicesRunning | Should -Not -BeNullOrEmpty
                    [string]::Join(",", $observed.DeviceGuardSecurityServicesRunning) | Should -Be (Get-StringValuesFromValueMap -valuemap $securityServicesRunningValues -values $deviceGuard.SecurityServicesRunning)
                }
                $observed.DeviceGuardCodeIntegrityPolicyEnforcementStatus | Should -Be $deviceGuard.CodeIntegrityPolicyEnforcementStatus
                $observed.DeviceGuardUserModeCodeIntegrityPolicyEnforcementStatus | Should -Be $deviceGuard.UserModeCodeIntegrityPolicyEnforcementStatus
            }
        }

        #
        # TESTS FOR SPECIAL CASE PROPERTIES (i.e. those that are fluid/changing
        #

        It "(special case) Test for property = OsFreePhysicalMemory" {
            ($observed.OsFreePhysicalMemory -gt 0) | Should -BeTrue
        }

        It "(special case) Test for property = OsFreeSpaceInPagingFiles" -Skip:([System.Management.Automation.Platform]::IsIoT -or !$IsWindows) {
            ($observed.OsFreeSpaceInPagingFiles -gt 0) | Should -BeTrue
        }

        It "(special case) Test for property = OsFreeVirtualMemory" {
            ($observed.OsFreeVirtualMemory -gt 0) | Should -BeTrue
        }


        It "(special case) Test for property = OsLocalDateTime" {
            $computerInfo = Get-ComputerInfoForTest
            $testEndTime = Get-Date
            $computerInfo.OsLocalDateTime | Should -BeGreaterThan $testStartTime
            $computerInfo.OsLocalDateTime | Should -BeLessThan $testEndTime
        }

        It "(special case) Test for property = OsMaxNumberOfProcesses" {
            ($observed.OsMaxNumberOfProcesses -gt 0) | Should -BeTrue
        }

        It "(special case) Test for property = OsNumberOfProcesses" {
            ($observed.OsNumberOfProcesses -gt 0) | Should -BeTrue
        }

        It "(special case) Test for property = OsUptime" {
            ($observed.OsUptime.Ticks -gt 0) | Should -BeTrue
        }

        It "(special case) Test for property = OsInUseVirtualMemory" {
            ($observed.OsInUseVirtualMemory -gt 0) | Should -BeTrue
        }

        It "(special case) Test for Filter Property - Property filter with special wild card * and fixed" {
            $propertyFilter = @("BiosC*","*")
            $computerInfo = Get-ComputerInfo -Property $propertyFilter
            $computerInfo | Should -BeOfType Microsoft.PowerShell.Commands.ComputerInfo
        }
    }
}
finally
{
    $global:PSDefaultParameterValues = $originalDefaultParameterValues
}