Windows-powershell / 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 | |
| } | |