mirror of
https://github.com/PowerShell/PowerShell
synced 2026-06-08 12:12:50 +00:00
663 lines
20 KiB
PowerShell
663 lines
20 KiB
PowerShell
# Copyright (c) Microsoft Corporation.
|
|
# Licensed under the MIT License.
|
|
|
|
Describe "Breakpoints set on custom FileSystem provider files should work" -Tags "CI" {
|
|
#
|
|
# <Test>
|
|
# <TestType>DRT</TestType>
|
|
# <Summary>
|
|
# Regression test for
|
|
#
|
|
# 221362 Breakpoints set on files in Custom FileSystem providers and networked shares are not hit
|
|
#
|
|
# </Summary>
|
|
# </Test>
|
|
#
|
|
try
|
|
{
|
|
#
|
|
# Create a simple script
|
|
#
|
|
$scriptPath = [io.path]::GetTempPath()
|
|
$scriptName = "DebuggerScriptTests-ExposeBug221362.ps1"
|
|
$scriptFullName = [io.path]::Combine($scriptPath, $scriptName)
|
|
|
|
Write-Output '"hello"' > $scriptFullName
|
|
|
|
#
|
|
# Create a file system provider
|
|
#
|
|
New-PSDrive -Name tmpTestA1 -PSProvider FileSystem -Root $scriptPath > $null
|
|
|
|
#
|
|
# Verify that the breakpoint is hit when using the provider
|
|
#
|
|
Push-Location tmpTestA1:\
|
|
$breakpoint = Set-PSBreakpoint .\$scriptName 1 -Action { continue }
|
|
& .\$scriptName
|
|
|
|
It "Breakpoint hit count" {
|
|
$breakpoint.HitCount | Should -Be 1
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
Pop-Location
|
|
|
|
if ($null -ne $breakpoint) { $breakpoint | Remove-PSBreakpoint }
|
|
if (Test-Path $scriptFullName) { Remove-Item $scriptFullName -Force }
|
|
if ($null -ne (Get-PSDrive -Name tmpTestA1 2> $null)) { Remove-PSDrive -Name tmpTestA1 -Force }
|
|
}
|
|
}
|
|
|
|
Describe "Tests line breakpoints on dot-sourced files" -Tags "CI" {
|
|
#
|
|
# <Test>
|
|
# <TestType>DRT</TestType>
|
|
# <Summary>Unit tests for line breakpoints on dot-sourced files...</Summary>
|
|
# </Test>
|
|
|
|
try
|
|
{
|
|
#
|
|
# Create the repro script
|
|
#
|
|
$scriptFile = [io.path]::Combine([io.path]::GetTempPath(), "DebuggerScriptTests-ExposeBug245331.ps1")
|
|
|
|
Write-Output '
|
|
function fibonacci
|
|
{
|
|
param($number)
|
|
|
|
if ($number -eq 0) {
|
|
return 0
|
|
}
|
|
|
|
if ($number -eq 1) {
|
|
return 1
|
|
}
|
|
|
|
$f1 = fibonacci($number - 1)
|
|
$f2 = fibonacci($number - 2)
|
|
|
|
$f1 + $f2 ######################## line 17
|
|
}
|
|
|
|
fibonacci(3)
|
|
' > $scriptFile
|
|
|
|
#
|
|
# Set the breakpoint and verify it is hit
|
|
#
|
|
$breakpoint = Set-PSBreakpoint $scriptFile 17 -Action { continue; }
|
|
|
|
& $scriptFile
|
|
|
|
It "Breakpoint on recursive function hit count" {
|
|
$breakpoint.HitCount | Should -BeGreaterThan 0
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
if ($null -ne $breakpoint) { $breakpoint | Remove-PSBreakpoint }
|
|
if (Test-Path $scriptFile) { Remove-Item -Path $scriptFile -Force }
|
|
}
|
|
}
|
|
|
|
Describe "Function calls clear debugger cache too early" -Tags "CI" {
|
|
#
|
|
# <Test>
|
|
# <TestType>DRT</TestType>
|
|
# <Summary>
|
|
# Regression test for
|
|
#
|
|
# 248703 Function calls clear debugger cache too early
|
|
#
|
|
# </Summary>
|
|
# </Test>
|
|
#
|
|
try
|
|
{
|
|
#
|
|
# Create the repro script
|
|
#
|
|
$scriptFile = [io.path]::Combine([io.path]::GetTempPath(), "DebuggerScriptTests-ExposeBug248703.ps1")
|
|
|
|
Write-Output '
|
|
function Hello
|
|
{
|
|
write-output "hello"
|
|
}
|
|
|
|
write-output "begin" ### line 7
|
|
Hello
|
|
write-output "end" ### line 9
|
|
' > $scriptFile
|
|
|
|
#
|
|
# Set the breakpoints and verify they are hit
|
|
#
|
|
$breakpoint1 = Set-PSBreakpoint $scriptFile 7 -Action { continue; }
|
|
$breakpoint2 = Set-PSBreakpoint $scriptFile 9 -Action { continue; }
|
|
|
|
& $scriptFile
|
|
|
|
It "Breakpoint before function call count" {
|
|
$breakpoint1.HitCount | Should -Be 1
|
|
}
|
|
|
|
It "Breakpoint after function call count" {
|
|
$breakpoint2.HitCount | Should -Be 1
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
if ($null -ne $breakpoint1) { $breakpoint1 | Remove-PSBreakpoint }
|
|
if ($null -ne $breakpoint2) { $breakpoint2 | Remove-PSBreakpoint }
|
|
if (Test-Path $scriptFile) { Remove-Item $scriptFile -Force }
|
|
}
|
|
}
|
|
|
|
Describe "Line breakpoints on commands in multi-line pipelines" -Tags "CI" {
|
|
#
|
|
# <Test>
|
|
# <TestType>DRT</TestType>
|
|
# <Summary>
|
|
# Regression test for
|
|
#
|
|
# 588887 Line breakpoints on commands in multi-line pipelines are not hit
|
|
#
|
|
# </Summary>
|
|
# </Test>
|
|
|
|
$script = Join-Path ${TestDrive} ExposeBug588887.DRT.tmp.ps1
|
|
|
|
try
|
|
{
|
|
Set-Content $script @'
|
|
1..3 |
|
|
ForEach-Object { $_ } | sort-object |
|
|
get-unique
|
|
'@
|
|
|
|
$breakpoints = Set-PSBreakpoint $script 1,2,3 -Action { continue }
|
|
|
|
$null = & $script
|
|
|
|
It "Breakpoint on line 1 hit count" {
|
|
$breakpoints[0].HitCount | Should -Be 1
|
|
}
|
|
|
|
It "Breakpoint on line 2 hit count" {
|
|
$breakpoints[1].HitCount | Should -Be 3
|
|
}
|
|
|
|
It "Breakpoint on line 3 hit count" {
|
|
$breakpoints[2].HitCount | Should -Be 1
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
if ($null -ne $breakpoints) { $breakpoints | Remove-PSBreakpoint }
|
|
if (Test-Path $script)
|
|
{
|
|
Remove-Item $script -Force
|
|
}
|
|
}
|
|
|
|
Context "COM TESTS" {
|
|
# DRT for 133807 SetBreakpointWithShortPath
|
|
BeforeAll {
|
|
if ( $IsCoreCLR ) { return } # no COM on core
|
|
$scriptPath1 = Join-Path $TestDrive SBPShortPathBug133807.DRT.tmp.ps1
|
|
$scriptPath1 = Setup -f SBPShortPathBug133807.DRT.tmp.ps1 -Content '
|
|
1..3 |
|
|
ForEach-Object { $_ } | sort-object |
|
|
get-unique'
|
|
$a = New-Object -ComObject Scripting.FileSystemObject
|
|
$f = $a.GetFile($scriptPath1)
|
|
$scriptPath2 = $f.ShortPath
|
|
|
|
$breakpoints = Set-PSBreakpoint $scriptPath2 1,2,3 -Action { continue }
|
|
$null = & $scriptPath2
|
|
}
|
|
|
|
AfterAll {
|
|
if ( $IsCoreCLR ) { return }
|
|
if ($null -ne $breakpoints) { $breakpoints | Remove-PSBreakpoint }
|
|
}
|
|
|
|
It "Short path Breakpoint on line 1 hit count" -Skip:$IsCoreCLR {
|
|
$breakpoints[0].HitCount | Should -Be 1
|
|
}
|
|
|
|
It "Short path Breakpoint on line 2 hit count" -Skip:$IsCoreCLR {
|
|
$breakpoints[1].HitCount | Should -Be 3
|
|
}
|
|
|
|
It "Short path Breakpoint on line 3 hit count" -Skip:$IsCoreCLR {
|
|
$breakpoints[2].HitCount | Should -Be 1
|
|
}
|
|
}
|
|
}
|
|
|
|
Describe "Unit tests for various script breakpoints" -Tags "CI" {
|
|
#
|
|
# <Test>
|
|
# <TestType>DRT</TestType>
|
|
# <Summary>Unit tests for line breakpoints on dot-sourced files...</Summary>
|
|
# </Test>
|
|
param($path = $null)
|
|
|
|
if ($null -eq $path)
|
|
{
|
|
$path = Split-Path $MyInvocation.InvocationName
|
|
}
|
|
|
|
#
|
|
# Verifies that the given command returns the expected set of breakpoints
|
|
#
|
|
function Verify([ScriptBlock] $command, [System.Management.Automation.Breakpoint[]] $expected)
|
|
{
|
|
$actual = @(& $command)
|
|
|
|
It "Script breakpoint count '${command}'|${expected}" {
|
|
$actual.Count | Should -Be $expected.Count
|
|
}
|
|
|
|
foreach ($breakpoint in $actual)
|
|
{
|
|
It "Expected script breakpoints '${command}|${breakpoint}'" {
|
|
($expected -contains $breakpoint) | Should -BeTrue
|
|
}
|
|
}
|
|
}
|
|
|
|
#
|
|
# Verifies that the command fails with the given exception
|
|
#
|
|
function VerifyException([ScriptBlock] $command, [string] $exception)
|
|
{
|
|
$e = { & $command } | Should -Throw -PassThru
|
|
$e.Exception.GetType().Name | Should -Be $exception
|
|
}
|
|
|
|
#
|
|
# Tests
|
|
#
|
|
try
|
|
{
|
|
#
|
|
# Ensure there are no breakpoints at start of test
|
|
#
|
|
Get-PSBreakpoint | Remove-PSBreakpoint
|
|
|
|
#
|
|
# Create a couple of scripts
|
|
#
|
|
$scriptFile1 = [io.path]::Combine([io.path]::GetTempPath(), "DebuggerScriptTests-Get-PsBreakpoint1.ps1")
|
|
$scriptFile2 = [io.path]::Combine([io.path]::GetTempPath(), "DebuggerScriptTests-Get-PsBreakpoint2.ps1")
|
|
|
|
Write-Output '' > $scriptFile1
|
|
Write-Output '' > $scriptFile2
|
|
|
|
#
|
|
# Set several breakpoints of different types
|
|
#
|
|
$line1 = Set-PSBreakpoint $scriptFile1 1
|
|
$line2 = Set-PSBreakpoint $scriptFile2 2
|
|
|
|
$cmd1 = Set-PSBreakpoint -c command1 -s $scriptFile1
|
|
$cmd2 = Set-PSBreakpoint -c command2 -s $scriptFile2
|
|
$cmd3 = Set-PSBreakpoint -c command3
|
|
|
|
$var1 = Set-PSBreakpoint -v variable1 -s $scriptFile1
|
|
$var2 = Set-PSBreakpoint -v variable2 -s $scriptFile2
|
|
$var3 = Set-PSBreakpoint -v variable3
|
|
|
|
#
|
|
# The default parameter set must return all breakpoints
|
|
#
|
|
Verify { Get-PSBreakpoint } $line1,$line2,$cmd1,$cmd2,$cmd3,$var1,$var2,$var3
|
|
|
|
#
|
|
# Query by ID
|
|
#
|
|
Verify { Get-PSBreakpoint -Id $line1.ID,$cmd1.ID,$var1.ID } $line1,$cmd1,$var1 # -id
|
|
Verify { Get-PSBreakpoint $line2.ID,$cmd2.ID,$var2.ID } $line2,$cmd2,$var2 # positional
|
|
Verify { $cmd3.ID,$var3.ID | Get-PSBreakpoint } $cmd3,$var3 # value from pipeline
|
|
|
|
VerifyException { Get-PSBreakpoint -Id $null } "ParameterBindingValidationException"
|
|
VerifyException { Get-PSBreakpoint -Id $line1.ID -Script $scriptFile1 } "ParameterBindingException"
|
|
|
|
#
|
|
# Query by Script
|
|
#
|
|
Verify { Get-PSBreakpoint -Script $scriptFile1 } $line1,$cmd1,$var1 # -script
|
|
Verify { Get-PSBreakpoint $scriptFile2 } $line2,$cmd2,$var2 # positional
|
|
Verify { $scriptFile2 | Get-PSBreakpoint } $line2,$cmd2,$var2 # value from pipeline
|
|
|
|
VerifyException { Get-PSBreakpoint -Script $null } "ParameterBindingValidationException"
|
|
VerifyException { Get-PSBreakpoint -Script $scriptFile1,$null } "ParameterBindingValidationException"
|
|
|
|
# Verify that relative paths are handled correctly
|
|
$directoryName = [System.IO.Path]::GetDirectoryName($scriptFile1)
|
|
$fileName = [System.IO.Path]::GetFileName($scriptFile1)
|
|
|
|
Push-Location $directoryName
|
|
Verify { Get-PSBreakpoint -Script $fileName } $line1,$cmd1,$var1
|
|
Pop-Location
|
|
|
|
#
|
|
# Query by Type
|
|
#
|
|
$commandType = [Microsoft.PowerShell.Commands.BreakpointType]"command"
|
|
$variableType = [Microsoft.PowerShell.Commands.BreakpointType]"variable"
|
|
|
|
Verify { Get-PSBreakpoint -Type "line" } $line1,$line2 # -type
|
|
Verify { Get-PSBreakpoint $commandType } $cmd1,$cmd2,$cmd3 # positional
|
|
Verify { $variableType | Get-PSBreakpoint } $var1,$var2,$var3 # value from pipeline
|
|
Verify { Get-PSBreakpoint -Type "line" -Script $scriptFile1 } @($line1) # -script parameter
|
|
|
|
VerifyException { Get-PSBreakpoint -Type $null } "ParameterBindingValidationException"
|
|
|
|
#
|
|
# Query by Command
|
|
#
|
|
Verify { Get-PSBreakpoint -Command "command1","command2" } $cmd1,$cmd2 # -command
|
|
Verify { Get-PSBreakpoint -Command "command1","command2" -Script $scriptFile1 } @($cmd1) # -script parameter
|
|
|
|
VerifyException { Get-PSBreakpoint -Command $null } "ParameterBindingValidationException"
|
|
|
|
#
|
|
# Query by Variable
|
|
#
|
|
Verify { Get-PSBreakpoint -Variable "variable1","variable2" } $var1,$var2 # -command
|
|
Verify { Get-PSBreakpoint -Variable "variable1","variable2" -Script $scriptFile1 } @($var1) # -script parameter
|
|
|
|
VerifyException { Get-PSBreakpoint -Variable $null } "ParameterBindingValidationException"
|
|
}
|
|
finally
|
|
{
|
|
if ($null -ne $line1) { $line1 | Remove-PSBreakpoint }
|
|
if ($null -ne $line2) { $line2 | Remove-PSBreakpoint }
|
|
if ($null -ne $cmd1) { $cmd1 | Remove-PSBreakpoint }
|
|
if ($null -ne $cmd2) { $cmd2 | Remove-PSBreakpoint }
|
|
if ($null -ne $cmd3) { $cmd3 | Remove-PSBreakpoint }
|
|
if ($null -ne $var1) { $var1 | Remove-PSBreakpoint }
|
|
if ($null -ne $var2) { $var2 | Remove-PSBreakpoint }
|
|
if ($null -ne $var3) { $var3 | Remove-PSBreakpoint }
|
|
|
|
if (Test-Path $scriptFile1) { Remove-Item $scriptFile1 -Force }
|
|
if (Test-Path $scriptFile2) { Remove-Item $scriptFile2 -Force }
|
|
}
|
|
}
|
|
|
|
Describe "Unit tests for line breakpoints on dot-sourced files" -Tags "CI" {
|
|
#
|
|
# <Test>
|
|
# <TestType>PriorityOne</TestType>
|
|
# <Summary>Unit tests for line breakpoints on dot-sourced files...</Summary>
|
|
# </Test>
|
|
#
|
|
param($path = $null)
|
|
|
|
if ($null -eq $path)
|
|
{
|
|
$path = Split-Path $MyInvocation.InvocationName
|
|
}
|
|
|
|
try
|
|
{
|
|
#
|
|
# Create a test script
|
|
#
|
|
$scriptFile = [io.path]::Combine([io.path]::GetTempPath(), "DebuggerScriptTests-InMemoryBreakpoints.ps1")
|
|
|
|
Write-Output '
|
|
function Function1
|
|
{
|
|
write-host "In Function1" # line 4
|
|
}
|
|
|
|
function Function2
|
|
{
|
|
write-host "In Function2" # line 9
|
|
}
|
|
|
|
function Get-TestCmdlet
|
|
{
|
|
[CmdletBinding()]
|
|
param()
|
|
|
|
begin
|
|
{
|
|
write-host "In Get-TestCmdlet (begin)"
|
|
}
|
|
|
|
process
|
|
{
|
|
write-host "In Get-TestCmdlet (process)" # line 24
|
|
}
|
|
|
|
end
|
|
{
|
|
write-host "In Get-TestCmdlet (end)"
|
|
}
|
|
}
|
|
' > $scriptFile
|
|
|
|
#
|
|
# Set a couple of line breakpoints on the file, dot-source it and verify that the breakpoints are hit
|
|
#
|
|
$breakpoint1 = Set-PSBreakpoint $scriptFile 4 -Action { continue; }
|
|
$breakpoint2 = Set-PSBreakpoint $scriptFile 9 -Action { continue; }
|
|
$breakpoint3 = Set-PSBreakpoint $scriptFile 24 -Action { continue; }
|
|
|
|
. $scriptFile
|
|
|
|
Function1
|
|
Get-TestCmdlet
|
|
|
|
It "Breakpoint on function hit count" {
|
|
$breakpoint1.HitCount | Should -Be 1
|
|
}
|
|
|
|
It "Breakpoint on uncalled function hit count" {
|
|
$breakpoint2.HitCount | Should -Be 0
|
|
}
|
|
|
|
It "Breakpoint on cmdlet hit count" {
|
|
$breakpoint3.HitCount | Should -Be 1
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
if ($null -ne $breakpoint1) { $breakpoint1 | Remove-PSBreakpoint }
|
|
if ($null -ne $breakpoint2) { $breakpoint2 | Remove-PSBreakpoint }
|
|
if ($null -ne $breakpoint3) { $breakpoint3 | Remove-PSBreakpoint }
|
|
if (Test-Path $scriptFile) { Remove-Item $scriptFile -Force }
|
|
}
|
|
}
|
|
|
|
Describe "Unit tests for line breakpoints on modules" -Tags "CI" {
|
|
#
|
|
# <Test>
|
|
# <TestType>DRT</TestType>
|
|
# <Summary>Unit tests for line breakpoints on modules...</Summary>
|
|
# </Test>
|
|
#
|
|
$oldModulePath = $env:PSModulePath
|
|
try
|
|
{
|
|
#
|
|
# Create a test module
|
|
#
|
|
$moduleName = "ModuleBreakpoints"
|
|
$moduleRoot = [io.path]::GetTempPath();
|
|
$moduleDirectory = [io.path]::Combine($moduleRoot, $moduleName)
|
|
$moduleFile = [io.path]::Combine($moduleDirectory, $moduleName + ".psm1")
|
|
|
|
New-Item -ItemType Directory $moduleDirectory 2> $null
|
|
|
|
Write-Output '
|
|
function ModuleFunction1
|
|
{
|
|
write-output "In ModuleFunction1" # line 4
|
|
}
|
|
|
|
function ModuleFunction2
|
|
{
|
|
write-output "In ModuleFunction2" # line 9
|
|
}
|
|
|
|
function Get-ModuleCmdlet
|
|
{
|
|
[CmdletBinding()]
|
|
param()
|
|
|
|
begin
|
|
{
|
|
write-output "In Get-ModuleCmdlet (begin)"
|
|
}
|
|
|
|
process
|
|
{
|
|
write-output "In Get-ModuleCmdlet (process)" # line 24
|
|
}
|
|
|
|
end
|
|
{
|
|
write-output "In Get-ModuleCmdlet (end)"
|
|
}
|
|
}
|
|
|
|
export-modulemember ModuleFunction1
|
|
export-modulemember ModuleFunction2
|
|
export-modulemember Get-ModuleCmdlet
|
|
' > $moduleFile
|
|
|
|
#
|
|
# Load the module
|
|
#
|
|
$ENV:PSModulePath = $moduleRoot
|
|
|
|
Import-Module $moduleName
|
|
|
|
#
|
|
# Set a couple of line breakpoints on the module and verify that they are hit
|
|
#
|
|
$breakpoint1 = Set-PSBreakpoint $moduleFile 4 -Action { continue }
|
|
$breakpoint2 = Set-PSBreakpoint $moduleFile 9 -Action { continue }
|
|
$breakpoint3 = Set-PSBreakpoint $moduleFile 24 -Action { continue }
|
|
$breakpoint4 = Set-PSBreakpoint $moduleFile 25 -Action { continue }
|
|
|
|
ModuleFunction1
|
|
|
|
Get-ModuleCmdlet
|
|
|
|
It "Breakpoint1 on module function hit count" {
|
|
$breakpoint1.HitCount | Should -Be 1
|
|
}
|
|
|
|
It "Breakpoint2 on uncalled module function hit count" {
|
|
$breakpoint2.HitCount | Should -Be 0
|
|
}
|
|
|
|
It "Breakpoint3 on module cmdlet hit count" {
|
|
$breakpoint3.HitCount | Should -Be 1
|
|
}
|
|
|
|
It "Breakpoint4 on module cmdlet hit count" {
|
|
$breakpoint4.HitCount | Should -Be 1
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
$env:PSModulePath = $oldModulePath
|
|
if ($null -ne $breakpoint1) { Remove-PSBreakpoint $breakpoint1 }
|
|
if ($null -ne $breakpoint2) { Remove-PSBreakpoint $breakpoint2 }
|
|
if ($null -ne $breakpoint3) { Remove-PSBreakpoint $breakpoint3 }
|
|
if ($null -ne $breakpoint4) { Remove-PSBreakpoint $breakpoint4 }
|
|
Get-Module $moduleName | Remove-Module
|
|
if (Test-Path $moduleDirectory) { Remove-Item $moduleDirectory -Recurse -Force -ErrorAction silentlycontinue }
|
|
}
|
|
}
|
|
|
|
Describe "Sometimes line breakpoints are ignored" -Tags "CI" {
|
|
#####################################################################################
|
|
#
|
|
# <Test>
|
|
# <TestType>DRT</TestType>
|
|
# <Summary>
|
|
# WinBlue: 177846 - Win8: Sometimes line breakpoints are ignored after the first
|
|
# time you use the 'c' debugger command.
|
|
# </Summary>
|
|
# </Test>
|
|
#
|
|
#####################################################################################
|
|
|
|
$path = [io.path]::GetTempPath();
|
|
$tempFileName1 = Join-Path -Path $path -ChildPath "TDBG47488F.ps1"
|
|
$tempFileName2 = Join-Path -Path $path -ChildPath "TDBG88473F.ps1"
|
|
|
|
try
|
|
{
|
|
@'
|
|
while ($count -lt 5)
|
|
{
|
|
$count += 1
|
|
"Hello $count"
|
|
}
|
|
'@ > $tempFileName1
|
|
|
|
@'
|
|
do
|
|
{
|
|
$count2 += 1
|
|
"Hello do $count2"
|
|
}
|
|
while ($count2 -lt 5)
|
|
'@ > $tempFileName2
|
|
|
|
$bp1 = Set-PSBreakpoint -Script $tempFileName1 -Line 3 -Action {continue}
|
|
& $tempFileName1
|
|
|
|
It "Breakpoint 1 hit count" {
|
|
$bp1.HitCount | Should -Be 6
|
|
}
|
|
|
|
$bp2 = Set-PSBreakpoint -Script $tempFileName2 -Line 3 -Action {continue}
|
|
& $tempFileName2
|
|
|
|
It "Breakpoint 2 hit count" {
|
|
$bp2.HitCount | Should -Be 6
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
if ($null -ne $bp1) { Remove-PSBreakpoint $bp1 }
|
|
if ($null -ne $bp2) { Remove-PSBreakpoint $bp2 }
|
|
|
|
if (Test-Path -Path $tempFileName1) { Remove-Item $tempFileName1 -Force }
|
|
if (Test-Path -Path $tempFileName2) { Remove-Item $tempFileName2 -Force }
|
|
}
|
|
}
|
|
|
|
Describe 'Breakpoints use case-insensitive match for script paths' -Tags 'CI' {
|
|
# https://github.com/PowerShell/PowerShell/issues/20044
|
|
# Running on Windows only as Set-PSBreakpoint does case sensitive check on provided path on Unix
|
|
It 'Hits breakpoint' -Skip:(!$IsWindows) {
|
|
$filePath = Join-Path -Path $TestDrive -ChildPath 'demoIssue20044.ps1'
|
|
Set-Content -Path $filePath -Value "'Hello World'"
|
|
|
|
$bp = Set-PSBreakpoint -Script $filePath.ToUpper() -Line 1 -Action { continue }
|
|
|
|
& $filePath
|
|
|
|
$bp.HitCount | Should -Be 1
|
|
|
|
if ($null -ne $bp) { Remove-PSBreakpoint $bp }
|
|
}
|
|
}
|