9ab8c6df4c
* Corrected the opencover option to merge the output file - Delete temporary zip file. - Remove CodeCov uploading through cygwin. - Add code to use Invoke-WebRequest to upload to CodeCov * Codecov settings - Wait for 1 build to start analysis. - Do not wait for CI. - Disable comments in PR. * Addressed code review comments
476 lines
21 KiB
PowerShell
476 lines
21 KiB
PowerShell
#region privateFunctions
|
|
|
|
$script:psRepoPath = [string]::Empty
|
|
if ((Get-Command -Name 'git' -ErrorAction Ignore) -ne $Null) {
|
|
$script:psRepoPath = git rev-parse --show-toplevel
|
|
}
|
|
|
|
function Get-AssemblyCoverageData([xml.xmlelement] $element)
|
|
{
|
|
$coverageSummary = (Get-CoverageSummary -element $element.Summary)
|
|
$AssemblyCoverageData = [PSCustomObject] @{
|
|
AssemblyName = $element.ModuleName
|
|
CoverageSummary = $coverageSummary
|
|
Branch = $coverageSummary.BranchCoverage
|
|
Sequence = $coverageSummary.SequenceCoverage
|
|
}
|
|
|
|
$AssemblyCoverageData | Add-Member -MemberType ScriptMethod -Name ToString -Value { "{0} ({1})" -f $this.AssemblyName,$this.CoverageSummary.BranchCoverage } -Force
|
|
$AssemblyCoverageData.PSTypeNames.Insert(0,"OpenCover.AssemblyCoverageData")
|
|
|
|
return $AssemblyCoverageData
|
|
}
|
|
|
|
function Get-CodeCoverageChange($r1, $r2)
|
|
{
|
|
$h = @{}
|
|
$Deltas = new-object "System.Collections.ArrayList"
|
|
|
|
$r1.assembly | ForEach-Object { $h[$_.assemblyname] = @($_) }
|
|
$r2.assembly | ForEach-Object {
|
|
if($h.ContainsKey($_.assemblyname))
|
|
{
|
|
$h[$_.assemblyname] += $_
|
|
}
|
|
else
|
|
{
|
|
$h[$_.assemblyname] = @($_)
|
|
}
|
|
}
|
|
|
|
foreach($kvPair in $h.GetEnumerator())
|
|
{
|
|
$runs = @($h[$kvPair.Name])
|
|
$assemblyCoverageChange = (Get-AssemblyCoverageChange -r1 $runs[0] -r2 $runs[1])
|
|
$Deltas.Add($assemblyCoverageChange) | Out-Null
|
|
}
|
|
|
|
$CoverageChange = [PSCustomObject] @{
|
|
Run1 = $r1
|
|
Run2 = $r2
|
|
Branch = $r2.Summary.BranchCoverage
|
|
Sequence = $r2.Summary.SequenceCoverage
|
|
BranchDelta = [double] ($r2.Summary.BranchCoverage - $r1.Summary.BranchCoverage)
|
|
SequenceDelta = [double] ($r2.Summary.SequenceCoverage - $r1.Summary.SequenceCoverage)
|
|
Deltas = $Deltas
|
|
}
|
|
$CoverageChange.PSTypeNames.Insert(0,"OpenCover.CoverageChange")
|
|
|
|
return $CoverageChange
|
|
}
|
|
|
|
function Get-AssemblyCoverageChange($r1, $r2)
|
|
{
|
|
if($r1 -eq $null -and $r2 -ne $null)
|
|
{
|
|
$r1 = @{ AssemblyName = $r2.AssemblyName ; Branch = 0 ; Sequence = 0 }
|
|
}
|
|
elseif($r2 -eq $null -and $r1 -ne $null)
|
|
{
|
|
$r2 = @{ AssemblyName = $r1.AssemblyName ; Branch = 0 ; Sequence = 0 }
|
|
}
|
|
|
|
if ( compare-object $r1.assemblyname $r2.assemblyname ) { throw "different assemblies" }
|
|
|
|
$AssemblyCoverageChange = [pscustomobject] @{
|
|
AssemblyName = $r1.AssemblyName
|
|
Branch = $r2.Branch
|
|
BranchDelta = $r2.Branch - $r1.Branch
|
|
Sequence = $r2.Sequence
|
|
SequenceDelta = $r2.Sequence - $r1.Sequence
|
|
}
|
|
$AssemblyCoverageChange.PSTypeNames.Insert(0,"OpenCover.AssemblyCoverageChange")
|
|
|
|
return $AssemblyCoverageChange
|
|
}
|
|
|
|
function Get-CoverageData($xmlPath)
|
|
{
|
|
[xml]$CoverageXml = get-content -readcount 0 $xmlPath
|
|
if ( $CoverageXml.CoverageSession -eq $null ) { throw "CoverageSession data not found" }
|
|
|
|
$assemblies = New-Object System.Collections.ArrayList
|
|
|
|
foreach( $module in $CoverageXml.CoverageSession.modules.module| Where-Object {$_.skippedDueTo -ne "MissingPdb"}) {
|
|
$assemblies.Add((Get-AssemblyCoverageData -element $module)) | Out-Null
|
|
}
|
|
|
|
$CoverageData = [PSCustomObject] @{
|
|
CoverageSummary = (Get-CoverageSummary -element $CoverageXml.CoverageSession.Summary)
|
|
Assembly = $assemblies
|
|
}
|
|
$CoverageData.PSTypeNames.Insert(0,"OpenCover.CoverageData")
|
|
|
|
$null = $CoverageXml
|
|
|
|
## Adding explicit garbage collection as the $CoverageXml object tends to be very large, in order of 1 GB.
|
|
[gc]::Collect()
|
|
|
|
return $CoverageData
|
|
}
|
|
|
|
function Get-CoverageSummary([xml.xmlelement] $element)
|
|
{
|
|
$CoverageSummary = [PSCustomObject] @{
|
|
NumSequencePoints = $element.numSequencePoints
|
|
VisitedSequencePoints = $element.visitedSequencePoints
|
|
NumBranchPoints = $element.numBranchPoints
|
|
VisitedBranchPoints = $element.visitedBranchPoints
|
|
SequenceCoverage = $element.sequenceCoverage
|
|
BranchCoverage = $element.branchCoverage
|
|
MaxCyclomaticComplexity = $element.maxCyclomaticComplexity
|
|
MinCyclomaticComplexity = $element.minCyclomaticComplexity
|
|
VisitedClasses = $element.visitedClasses
|
|
NumClasses = $element.numClasses
|
|
VisitedMethods = $element.visitedMethods
|
|
NumMethods = $element.numMethods
|
|
}
|
|
|
|
$CoverageSummary | Add-Member -MemberType ScriptMethod -Name ToString -Value { "Branch:{0,3} Sequence:{1,3}" -f $this.BranchCoverage,$this.SequenceCoverage } -Force
|
|
$CoverageSummary.PSTypeNames.Insert(0,"OpenCover.CoverageSummary")
|
|
|
|
return $CoverageSummary
|
|
}
|
|
|
|
# needed for PowerShell v4 as Archive module isn't available by default
|
|
function Expand-ZipArchive([string] $Path, [string] $DestinationPath)
|
|
{
|
|
try
|
|
{
|
|
Add-Type -AssemblyName System.IO.Compression
|
|
Add-Type -AssemblyName System.IO.Compression.FileSystem
|
|
|
|
$fileStream = New-Object System.IO.FileStream -ArgumentList @($Path, [System.IO.FileMode]::Open, [System.IO.FileAccess]::Read)
|
|
$zipArchive = New-Object System.IO.Compression.ZipArchive -ArgumentList @($fileStream, [System.IO.Compression.ZipArchiveMode]::Read, $false)
|
|
|
|
foreach($entry in $zipArchive.Entries)
|
|
{
|
|
$extractPath = (Join-Path $DestinationPath $entry.FullName)
|
|
|
|
$fileInfo = New-Object System.IO.FileInfo -ArgumentList $extractPath
|
|
if(-not $fileInfo.Directory.Exists) { New-Item -Path $fileInfo.Directory.FullName -ItemType Directory | Out-Null }
|
|
|
|
try
|
|
{
|
|
$newfileStream = [System.IO.File]::Create($extractPath)
|
|
$entry.Open().CopyTo($newfileStream)
|
|
}
|
|
finally
|
|
{
|
|
if($newfileStream) { $newfileStream.Dispose() }
|
|
}
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
if($zipArchive) { $zipArchive.Dispose() }
|
|
if($fileStream) { $fileStream.Dispose() }
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
<#
|
|
.Synopsis
|
|
Get code coverage information for the supplied coverage file.
|
|
.Description
|
|
Coverage information from the supplied OpenCover XML file is displayed. The output object has options to show assembly coverage and summary.
|
|
.EXAMPLE
|
|
PS> $coverage = Get-CodeCoverage -CoverageXmlFile .\opencover.xml
|
|
PS> $cov.assembly
|
|
|
|
AssemblyName Branch Sequence CoverageSummary
|
|
------------ ------ -------- ---------------
|
|
powershell 100 100 Branch:100 Sequence:100
|
|
Microsoft.PowerShell.CoreCLR.AssemblyLoadContext 53.66 95.31 Branch:53.66 Sequence:95.31
|
|
Microsoft.PowerShell.ConsoleHost 36.53 38.40 Branch:36.53 Sequence:38.40
|
|
System.Management.Automation 42.18 44.11 Branch:42.18 Sequence:44.11
|
|
Microsoft.PowerShell.CoreCLR.Eventing 28.70 36.23 Branch:28.70 Sequence:36.23
|
|
Microsoft.PowerShell.Security 15.17 18.16 Branch:15.17 Sequence:18.16
|
|
Microsoft.PowerShell.Commands.Management 18.84 21.70 Branch:18.84 Sequence:21.70
|
|
Microsoft.PowerShell.Commands.Utility 62.38 64.54 Branch:62.38 Sequence:64.54
|
|
Microsoft.WSMan.Management 3.93 4.45 Branch:3.93 Sequence:4.45
|
|
Microsoft.WSMan.Runtime 0 0 Branch: 0 Sequence: 0
|
|
Microsoft.PowerShell.Commands.Diagnostics 44.96 49.93 Branch:44.96 Sequence:49.93
|
|
Microsoft.PowerShell.PSReadLine 7.12 9.94 Branch:7.12 Sequence:9.94
|
|
Microsoft.PowerShell.PackageManagement 59.77 62.04 Branch:59.77 Sequence:62.04
|
|
Microsoft.PackageManagement 41.73 44.47 Branch:41.73 Sequence:44.47
|
|
Microsoft.Management.Infrastructure.CimCmdlets 13.20 17.01 Branch:13.20 Sequence:17.01
|
|
Microsoft.PowerShell.LocalAccounts 73.15 84.32 Branch:73.15 Sequence:84.32
|
|
Microsoft.PackageManagement.MetaProvider.PowerShell 54.79 57.90 Branch:54.79 Sequence:57.90
|
|
Microsoft.PackageManagement.NuGetProvider 62.36 65.37 Branch:62.36 Sequence:65.37
|
|
Microsoft.PackageManagement.CoreProviders 7.08 7.96 Branch:7.08 Sequence:7.96
|
|
Microsoft.PackageManagement.ArchiverProviders 0.53 0.56 Branch:0.53 Sequence:0.56
|
|
.EXAMPLE
|
|
PS> $coverage = Get-CodeCoverage -CoverageXmlFile .\opencover.xml
|
|
PS> $cov.CoverageSummary
|
|
|
|
NumSequencePoints : 337052
|
|
VisitedSequencePoints : 143209
|
|
NumBranchPoints : 115193
|
|
VisitedBranchPoints : 46132
|
|
MaxCyclomaticComplexity : 398
|
|
MinCyclomaticComplexity : 1
|
|
VisitedClasses : 2465
|
|
NumClasses : 3894
|
|
VisitedMethods : 17792
|
|
NumMethods : 37832
|
|
SequenceCoverage : 42.49
|
|
BranchCoverage : 40.05
|
|
#>
|
|
function Get-CodeCoverage
|
|
{
|
|
param ( [string]$CoverageXmlFile = "$pwd/OpenCover.xml" )
|
|
$xmlPath = (get-item $CoverageXmlFile).Fullname
|
|
(Get-CoverageData -xmlPath $xmlPath)
|
|
}
|
|
|
|
|
|
<#
|
|
.Synopsis
|
|
Compare results between two coverage runs.
|
|
.Description
|
|
Coverage information from the supplied OpenCover XML file is displayed. The output object has options to show assembly coverage and summary.
|
|
.EXAMPLE
|
|
$comp = Compare-CodeCoverage -RunFile1 .\OpenCover.xml -RunFile2 .\OpenCover.xml
|
|
$comp.Deltas | sort-object assemblyname | format-table
|
|
|
|
AssemblyName Branch BranchDelta Sequence SequenceDelta
|
|
------------ ------ ----------- -------- -------------
|
|
Microsoft.Management.Infrastructure.CimCmdlets 13.20 0 17.01 0
|
|
Microsoft.PackageManagement 41.73 0 44.47 0
|
|
Microsoft.PackageManagement.ArchiverProviders 0.53 0 0.56 0
|
|
Microsoft.PackageManagement.CoreProviders 7.08 0 7.96 0
|
|
Microsoft.PackageManagement.MetaProvider.PowerShell 54.79 0 57.90 0
|
|
Microsoft.PackageManagement.NuGetProvider 62.36 0 65.37 0
|
|
Microsoft.PowerShell.Commands.Diagnostics 44.96 0 49.93 0
|
|
Microsoft.PowerShell.Commands.Management 18.84 0 21.70 0
|
|
Microsoft.PowerShell.Commands.Utility 62.38 0 64.54 0
|
|
Microsoft.PowerShell.ConsoleHost 36.53 0 38.40 0
|
|
Microsoft.PowerShell.CoreCLR.AssemblyLoadContext 53.66 0 95.31 0
|
|
Microsoft.PowerShell.CoreCLR.Eventing 28.70 0 36.23 0
|
|
Microsoft.PowerShell.LocalAccounts 73.15 0 84.32 0
|
|
Microsoft.PowerShell.PackageManagement 59.77 0 62.04 0
|
|
Microsoft.PowerShell.PSReadLine 7.12 0 9.94 0
|
|
Microsoft.PowerShell.Security 15.17 0 18.16 0
|
|
Microsoft.WSMan.Management 3.93 0 4.45 0
|
|
Microsoft.WSMan.Runtime 0 0 0 0
|
|
powershell 100 0 100 0
|
|
System.Management.Automation 42.18 0 44.11 0
|
|
|
|
.EXAMPLE
|
|
$comp = Compare-CodeCoverage -Run1 $c -Run2 $c
|
|
$comp.Deltas | sort-object assemblyname | format-table
|
|
|
|
AssemblyName Branch BranchDelta Sequence SequenceDelta
|
|
------------ ------ ----------- -------- -------------
|
|
Microsoft.Management.Infrastructure.CimCmdlets 13.20 0 17.01 0
|
|
Microsoft.PackageManagement 41.73 0 44.47 0
|
|
Microsoft.PackageManagement.ArchiverProviders 0.53 0 0.56 0
|
|
Microsoft.PackageManagement.CoreProviders 7.08 0 7.96 0
|
|
Microsoft.PackageManagement.MetaProvider.PowerShell 54.79 0 57.90 0
|
|
Microsoft.PackageManagement.NuGetProvider 62.36 0 65.37 0
|
|
Microsoft.PowerShell.Commands.Diagnostics 44.96 0 49.93 0
|
|
Microsoft.PowerShell.Commands.Management 18.84 0 21.70 0
|
|
Microsoft.PowerShell.Commands.Utility 62.38 0 64.54 0
|
|
Microsoft.PowerShell.ConsoleHost 36.53 0 38.40 0
|
|
Microsoft.PowerShell.CoreCLR.AssemblyLoadContext 53.66 0 95.31 0
|
|
Microsoft.PowerShell.CoreCLR.Eventing 28.70 0 36.23 0
|
|
Microsoft.PowerShell.LocalAccounts 73.15 0 84.32 0
|
|
Microsoft.PowerShell.PackageManagement 59.77 0 62.04 0
|
|
Microsoft.PowerShell.PSReadLine 7.12 0 9.94 0
|
|
Microsoft.PowerShell.Security 15.17 0 18.16 0
|
|
Microsoft.WSMan.Management 3.93 0 4.45 0
|
|
Microsoft.WSMan.Runtime 0 0 0 0
|
|
powershell 100 0 100 0
|
|
System.Management.Automation 42.18 0 44.11 0
|
|
#>
|
|
function Compare-CodeCoverage
|
|
{
|
|
[CmdletBinding()]
|
|
param (
|
|
[Parameter(Mandatory=$true,Position=0,ParameterSetName="file")][string]$RunFile1,
|
|
[Parameter(Mandatory=$true,Position=1,ParameterSetName="file")][string]$RunFile2,
|
|
[Parameter(Mandatory=$true,Position=0,ParameterSetName="coverage")][Object]$Run1,
|
|
[Parameter(Mandatory=$true,Position=1,ParameterSetName="coverage")][Object]$Run2
|
|
)
|
|
|
|
if ( $PSCmdlet.ParameterSetName -eq "file" )
|
|
{
|
|
[string]$xmlPath1 = (get-item $Run1File).Fullname
|
|
$Run1 = (Get-CoverageData -xmlPath $xmlPath1)
|
|
|
|
[string]$xmlPath2 = (get-item $Run1File).Fullname
|
|
$Run2 = (Get-CoverageData -xmlPath $xmlPath2)
|
|
}
|
|
|
|
(Get-CodeCoverageChange -r1 $Run1 -r2 $Run2)
|
|
}
|
|
|
|
<#
|
|
.Synopsis
|
|
Install OpenCover by downloading the 4.6.519 version.
|
|
.Description
|
|
Install OpenCover version 4.6.519.
|
|
#>
|
|
function Install-OpenCover
|
|
{
|
|
param (
|
|
[parameter()][string]$Version = "4.6.519",
|
|
[parameter()][string]$TargetDirectory = "~/",
|
|
[parameter()][switch]$Force
|
|
)
|
|
|
|
$filename = "opencover.${version}.zip"
|
|
$tempPath = "$env:TEMP/$Filename"
|
|
$packageUrl = "https://github.com/OpenCover/opencover/releases/download/${version}/${filename}"
|
|
if ( test-path $tempPath )
|
|
{
|
|
if ( $force )
|
|
{
|
|
remove-item -force $tempPath
|
|
}
|
|
else
|
|
{
|
|
throw "Package already exists at $tempPath, not continuing. Use -force to re-install"
|
|
}
|
|
}
|
|
if ( test-path "$TargetDirectory/OpenCover" )
|
|
{
|
|
if ( $force )
|
|
{
|
|
remove-item -recurse -force "$TargetDirectory/OpenCover"
|
|
}
|
|
else
|
|
{
|
|
throw "$TargetDirectory/OpenCover exists, not continuing. Use -force to re-install"
|
|
}
|
|
}
|
|
|
|
Invoke-WebRequest -Uri $packageUrl -OutFile "$tempPath"
|
|
if ( ! (test-path $tempPath) )
|
|
{
|
|
throw "Download failed: $packageUrl"
|
|
}
|
|
|
|
## We add ErrorAction as we do not have this module on PS v4 and below. Calling import-module will throw an error otherwise.
|
|
import-module Microsoft.PowerShell.Archive -ErrorAction SilentlyContinue
|
|
|
|
if ((Get-Command Expand-Archive -ErrorAction Ignore) -ne $null) {
|
|
Expand-Archive -Path $tempPath -DestinationPath "$TargetDirectory/OpenCover"
|
|
} else {
|
|
Expand-ZipArchive -Path $tempPath -DestinationPath "$TargetDirectory/OpenCover"
|
|
}
|
|
Remove-Item -force $tempPath
|
|
}
|
|
|
|
<#
|
|
.Synopsis
|
|
Invoke-OpenCover runs tests under OpenCover to collect code coverage.
|
|
.Description
|
|
Invoke-OpenCover runs tests under OpenCover by executing tests on PowerShell.exe located at $PowerShellExeDirectory.
|
|
.EXAMPLE
|
|
Invoke-OpenCover -TestDirectory $pwd/test/powershell -PowerShellExeDirectory $pwd/src/powershell-win-core/bin/CodeCoverage/netcoreapp1.0/win10-x64
|
|
#>
|
|
function Invoke-OpenCover
|
|
{
|
|
[CmdletBinding(SupportsShouldProcess=$true)]
|
|
param (
|
|
[parameter()]$OutputLog = "$pwd/OpenCover.xml",
|
|
[parameter()]$TestDirectory = "$($script:psRepoPath)/test/powershell",
|
|
[parameter()]$OpenCoverPath = "~/OpenCover",
|
|
[parameter()]$PowerShellExeDirectory = "$($script:psRepoPath)/src/powershell-win-core/bin/CodeCoverage/netcoreapp1.0/win10-x64",
|
|
[parameter()]$PesterLogElevated = "$pwd/TestResultsElevated.xml",
|
|
[parameter()]$PesterLogUnelevated = "$pwd/TestResultsUnelevated.xml",
|
|
[parameter()]$PesterLogFormat = "NUnitXml",
|
|
[switch]$CIOnly
|
|
)
|
|
|
|
# check to be sure that OpenCover is present
|
|
|
|
$OpenCoverBin = "$OpenCoverPath\opencover.console.exe"
|
|
|
|
if ( ! (test-path $OpenCoverBin))
|
|
{
|
|
# see if it's somewhere else in the path
|
|
$openCoverBin = (Get-Command -Name 'opencover.console' -ErrorAction Ignore).Source
|
|
if ($openCoverBin -eq $null) {
|
|
throw "$OpenCoverBin does not exist, use Install-OpenCover"
|
|
}
|
|
}
|
|
|
|
# check to be sure that powershell.exe is present
|
|
$target = "${PowerShellExeDirectory}\powershell.exe"
|
|
if ( ! (test-path $target) )
|
|
{
|
|
throw "$target does not exist, use 'Start-PSBuild -configuration CodeCoverage'"
|
|
}
|
|
|
|
# create the arguments for OpenCover
|
|
$targetArgs = "-c", "Set-ExecutionPolicy Bypass -Force -Scope Process;", "Invoke-Pester","${TestDirectory}"
|
|
|
|
if ( $CIOnly )
|
|
{
|
|
$targetArgsElevated = $targetArgs + @("-excludeTag @('Feature','Scenario','Slow')", "-Tag @('RequireAdminOnWindows')")
|
|
$targetArgsUnelevated = $targetArgs + @("-excludeTag @('Feature','Scenario','Slow','RequireAdminOnWindows')")
|
|
}
|
|
else
|
|
{
|
|
$targetArgsElevated = $targetArgs + @("-Tag @('RequireAdminOnWindows')")
|
|
$targetArgsUnelevated = $targetArgs + @("-excludeTag @('RequireAdminOnWindows')")
|
|
}
|
|
|
|
$targetArgsElevated += @("-OutputFile $PesterLogElevated", "-OutputFormat $PesterLogFormat", "-Quiet")
|
|
$targetArgsUnelevated += @("-OutputFile $PesterLogUnelevated", "-OutputFormat $PesterLogFormat", "-Quiet")
|
|
|
|
$targetArgStringElevated = $targetArgsElevated -join " "
|
|
$targetArgStringUnelevated = $targetArgsUnelevated -join " "
|
|
# the order seems to be important. Always keep -targetargs as the last parameter.
|
|
$openCoverArgsElevated = "-target:$target","-register:user","-output:${outputLog}","-nodefaultfilters","-oldstyle","-hideskipped:all","-mergeoutput","-targetargs:`"$targetArgStringElevated`""
|
|
$openCoverArgsUnelevated = "-target:$target","-register:user","-output:${outputLog}","-nodefaultfilters","-oldstyle","-hideskipped:all", "-mergeoutput", "-targetargs:`"$targetArgStringUnelevated`""
|
|
$openCoverArgsUnelevatedString = $openCoverArgsUnelevated -join " "
|
|
|
|
if ( $PSCmdlet.ShouldProcess("$OpenCoverBin $openCoverArgsUnelevated") )
|
|
{
|
|
try
|
|
{
|
|
# check to be sure that the module path is present
|
|
# this isn't done earlier because there's no need to change env:psmodulepath unless we're going to really run tests
|
|
$saveModPath = $env:psmodulepath
|
|
$env:psmodulepath = "${PowerShellExeDirectory}\Modules"
|
|
if ( ! (test-path $env:psmodulepath) )
|
|
{
|
|
throw "${env:psmodulepath} does not exist"
|
|
}
|
|
|
|
# invoke OpenCover elevated
|
|
& $OpenCoverBin $openCoverArgsElevated
|
|
|
|
# invoke OpenCover unelevated and poll for completion
|
|
"$openCoverBin $openCoverArgsUnelevatedString" | Out-File -FilePath "$env:temp\unelevated.ps1" -Force
|
|
runas.exe /trustlevel:0x20000 "powershell.exe -file $env:temp\unelevated.ps1"
|
|
# wait for process to start
|
|
Start-Sleep -Seconds 5
|
|
# poll for process exit every 30 seconds
|
|
# timeout of 3 hours
|
|
$timeOut = ([datetime]::Now).AddHours(3)
|
|
while([datetime]::Now -lt $timeOut)
|
|
{
|
|
Start-Sleep -Seconds 30
|
|
$openCoverProcess = Get-Process "OpenCover.Console" -ErrorAction SilentlyContinue
|
|
|
|
if(-not $openCoverProcess)
|
|
{
|
|
#run must have completed.
|
|
break
|
|
}
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
# set it back
|
|
$env:PSModulePath = $saveModPath
|
|
Remove-Item "$env:temp\unelevated.ps1" -force -ErrorAction SilentlyContinue
|
|
}
|
|
}
|
|
} |