Merge pull request #337 from PowerShell/master

raghushantha · raghushantha · commit d265818d867f · 2015-10-28T15:46:50.000-07:00
Merge Branches
diff --git a/Engine/Helper.cs b/Engine/Helper.cs
@@ -283,8 +283,9 @@ public bool HasSplattedVariable(CommandAst cmdAst)
         /// Given a commandast, checks whether positional parameters are used or not.
         /// </summary>
         /// <param name="cmdAst"></param>
+        /// <param name="moreThanThreePositional">only return true if more than three positional parameters are used</param>
         /// <returns></returns>
-        public bool PositionalParameterUsed(CommandAst cmdAst)
+        public bool PositionalParameterUsed(CommandAst cmdAst, bool moreThanThreePositional = false)
         {
             if (cmdAst == null || cmdAst.GetCommandName() == null)
             {
@@ -351,6 +352,11 @@ public bool PositionalParameterUsed(CommandAst cmdAst)
                 arguments += 1;
             }
 
+            if (moreThanThreePositional && arguments < 3)
+            {
+                return false;
+            }
+
             return arguments > parameters;
         }
 
diff --git a/Engine/ScriptAnalyzer.cs b/Engine/ScriptAnalyzer.cs
@@ -183,6 +183,7 @@ private void Initialize(
             this.includeRegexList = new List<Regex>();
             this.excludeRegexList = new List<Regex>();
 
+            #region ParseProfile
             if (!String.IsNullOrWhiteSpace(profile))
             {
                 try
@@ -191,9 +192,7 @@ private void Initialize(
                 }
                 catch
                 {
-                    this.outputWriter.WriteError(new ErrorRecord(new FileNotFoundException(),
-                        string.Format(CultureInfo.CurrentCulture, Strings.FileNotFound, profile),
-                        ErrorCategory.InvalidArgument, this));
+                    this.outputWriter.WriteWarning(string.Format(CultureInfo.CurrentCulture, Strings.FileNotFound, profile));
                 }
 
                 if (File.Exists(profile))
@@ -202,15 +201,23 @@ private void Initialize(
                     ParseError[] parserErrors = null;
                     Ast profileAst = Parser.ParseFile(profile, out parserTokens, out parserErrors);
                     IEnumerable<Ast> hashTableAsts = profileAst.FindAll(item => item is HashtableAst, false);
-                    foreach (HashtableAst hashTableAst in hashTableAsts)
+
+                    // no hashtable, raise warning
+                    if (hashTableAsts.Count() == 0)
+                    {
+                        this.outputWriter.WriteWarning(string.Format(CultureInfo.CurrentCulture, Strings.InvalidProfile, profile));
+                    }
+                    else
                     {
+                        HashtableAst hashTableAst = hashTableAsts.First() as HashtableAst;
+
                         foreach (var kvp in hashTableAst.KeyValuePairs)
                         {
                             if (!(kvp.Item1 is StringConstantExpressionAst))
                             {
-                                this.outputWriter.WriteError(new ErrorRecord(new ArgumentException(),
-                                    string.Format(CultureInfo.CurrentCulture, Strings.WrongKeyFormat, kvp.Item1.Extent.StartLineNumber, kvp.Item1.Extent.StartColumnNumber, profile),
-                                    ErrorCategory.InvalidArgument, this));
+                                // first item (the key) should be a string
+                                this.outputWriter.WriteWarning(
+                                    string.Format(CultureInfo.CurrentCulture, Strings.WrongKeyFormat, kvp.Item1.Extent.StartLineNumber, kvp.Item1.Extent.StartColumnNumber, profile));
                                 continue;
                             }
 
@@ -257,11 +264,11 @@ private void Initialize(
                                     {
                                         foreach (var element in arrayLitAst.Elements)
                                         {
+                                            // all the values in the array needs to be string
                                             if (!(element is StringConstantExpressionAst))
                                             {
-                                                this.outputWriter.WriteError(new ErrorRecord(new ArgumentException(),
-                                                    string.Format(CultureInfo.CurrentCulture, Strings.WrongValueFormat, element.Extent.StartLineNumber, element.Extent.StartColumnNumber, profile),
-                                                    ErrorCategory.InvalidArgument, this));
+                                                this.outputWriter.WriteWarning(
+                                                    string.Format(CultureInfo.CurrentCulture, Strings.WrongValueFormat, element.Extent.StartLineNumber, element.Extent.StartColumnNumber, profile));
                                                 continue;
                                             }
 
@@ -273,9 +280,8 @@ private void Initialize(
 
                             if (rhsList.Count == 0)
                             {
-                                this.outputWriter.WriteError(new ErrorRecord(new ArgumentException(),
-                                    string.Format(CultureInfo.CurrentCulture, Strings.WrongValueFormat, kvp.Item2.Extent.StartLineNumber, kvp.Item2.Extent.StartColumnNumber, profile),
-                                    ErrorCategory.InvalidArgument, this));
+                                this.outputWriter.WriteWarning(
+                                    string.Format(CultureInfo.CurrentCulture, Strings.WrongValueFormat, kvp.Item2.Extent.StartLineNumber, kvp.Item2.Extent.StartColumnNumber, profile));
                                 break;
                             }
 
@@ -312,16 +318,17 @@ private void Initialize(
                                     }
                                     break;
                                 default:
-                                    this.outputWriter.WriteError(new ErrorRecord(new ArgumentException(),
-                                        string.Format(CultureInfo.CurrentCulture, Strings.WrongKey, kvp.Item1.Extent.StartLineNumber, kvp.Item1.Extent.StartColumnNumber, profile),
-                                        ErrorCategory.InvalidArgument, this));
+                                    this.outputWriter.WriteWarning(
+                                        string.Format(CultureInfo.CurrentCulture, Strings.WrongKey, kvp.Item1.Extent.StartLineNumber, kvp.Item1.Extent.StartColumnNumber, profile));
                                     break;
                             }
                         }
                     }
                 }
             }
 
+            #endregion
+
             //Check wild card input for the Include/ExcludeRules and create regex match patterns
             if (this.includeRule != null)
             {
diff --git a/Engine/Strings.Designer.cs b/Engine/Strings.Designer.cs
diff --git a/Engine/Strings.resx b/Engine/Strings.resx
@@ -201,4 +201,7 @@
   <data name="WrongValueFormat" xml:space="preserve">
     <value>Value in the profile hashtable should be a string or an array of strings: line {0} column {1} in file {2}</value>
   </data>
+  <data name="InvalidProfile" xml:space="preserve">
+    <value>Profile file '{0}' is invalid because it does not contain a hashtable.</value>
+  </data>
 </root>
diff --git a/Rules/AvoidPositionalParameters.cs b/Rules/AvoidPositionalParameters.cs
@@ -45,7 +45,7 @@ public IEnumerable<DiagnosticRecord> AnalyzeScript(Ast ast, string fileName)
                 if (cmdAst.GetCommandName() == null) continue;
                 
                 if (Helper.Instance.GetCommandInfo(cmdAst.GetCommandName()) != null
-                    && Helper.Instance.PositionalParameterUsed(cmdAst))
+                    && Helper.Instance.PositionalParameterUsed(cmdAst, true))
                 {
                     PipelineAst parent = cmdAst.Parent as PipelineAst;
 
@@ -55,14 +55,14 @@ public IEnumerable<DiagnosticRecord> AnalyzeScript(Ast ast, string fileName)
                         if (parent.PipelineElements[0] == cmdAst)
                         {
                             yield return new DiagnosticRecord(string.Format(CultureInfo.CurrentCulture, Strings.AvoidUsingPositionalParametersError, cmdAst.GetCommandName()),
-                                cmdAst.Extent, GetName(), DiagnosticSeverity.Warning, fileName, cmdAst.GetCommandName());
+                                cmdAst.Extent, GetName(), DiagnosticSeverity.Information, fileName, cmdAst.GetCommandName());
                         }
                     }
                     // not in pipeline so just raise it normally
                     else
                     {
                         yield return new DiagnosticRecord(string.Format(CultureInfo.CurrentCulture, Strings.AvoidUsingPositionalParametersError, cmdAst.GetCommandName()),
-                            cmdAst.Extent, GetName(), DiagnosticSeverity.Warning, fileName, cmdAst.GetCommandName());
+                            cmdAst.Extent, GetName(), DiagnosticSeverity.Information, fileName, cmdAst.GetCommandName());
                     }
                 }
             }
@@ -109,7 +109,7 @@ public SourceType GetSourceType()
         /// <returns></returns>
         public RuleSeverity GetSeverity()
         {
-            return RuleSeverity.Warning;
+            return RuleSeverity.Information;
         }
 
         /// <summary>
diff --git a/Tests/Engine/GetScriptAnalyzerRule.tests.ps1 b/Tests/Engine/GetScriptAnalyzerRule.tests.ps1
@@ -118,7 +118,7 @@ Describe "TestSeverity" {
 
     It "filters rules based on multiple severity inputs"{
         $rules = Get-ScriptAnalyzerRule -Severity Error,Information
-        $rules.Count | Should be 13
+        $rules.Count | Should be 14
     }
 
         It "takes lower case inputs" {
diff --git a/Tests/Engine/InvokeScriptAnalyzer.tests.ps1 b/Tests/Engine/InvokeScriptAnalyzer.tests.ps1
@@ -179,12 +179,12 @@ Describe "Test IncludeRule" {
     Context "IncludeRule supports wild card" {
         It "includes 1 wildcard rule"{
             $includeWildcard = Invoke-ScriptAnalyzer $directory\..\Rules\BadCmdlet.ps1 -IncludeRule $avoidRules
-            $includeWildcard.Count | Should be 3
+            $includeWildcard.Count | Should be 0
         }
 
         it "includes 2 wildcardrules" {
             $includeWildcard = Invoke-ScriptAnalyzer $directory\..\Rules\BadCmdlet.ps1 -IncludeRule $avoidRules, $useRules 
-            $includeWildcard.Count | Should be 7
+            $includeWildcard.Count | Should be 4
         }
     }
 }
@@ -210,12 +210,12 @@ Describe "Test Severity" {
 
         It "works with 2 arguments" {
             $errors = Invoke-ScriptAnalyzer $directory\TestScript.ps1 -Severity Information, Warning
-            $errors.Count | Should Be 2
+            $errors.Count | Should Be 1
         }
 
         It "works with lowercase argument"{
              $errors = Invoke-ScriptAnalyzer $directory\TestScript.ps1 -Severity information, warning
-            $errors.Count | Should Be 2
+            $errors.Count | Should Be 1
         }
     }
 
diff --git a/Tests/Engine/RuleSuppression.tests.ps1 b/Tests/Engine/RuleSuppression.tests.ps1
@@ -50,7 +50,7 @@ Describe "RuleSuppressionWithScope" {
     Context "FunctionScope" {
         It "Does not raise violations" {
             $suppression = $violations | Where-Object {$_.RuleName -eq "PSAvoidUsingPositionalParameters" }
-            $suppression.Count | Should Be 1
+            $suppression.Count | Should Be 0
         }
     }
 
diff --git a/Tests/Rules/AvoidPositionalParameters.ps1 b/Tests/Rules/AvoidPositionalParameters.ps1
@@ -1,5 +1,2 @@
-﻿Get-Content Test
-Get-ChildItem Tests
-Write-Output "I don't want to use positional parameters"
-Split-Path "RandomPath" -Leaf
-Get-Process | ForEach-Object {Write-Host $_.name -foregroundcolor cyan}
+﻿# give it 3 positional parameters
+Get-Command "abc" 4 4.3
diff --git a/Tests/Rules/AvoidPositionalParameters.tests.ps1 b/Tests/Rules/AvoidPositionalParameters.tests.ps1
@@ -1,5 +1,5 @@
 ﻿Import-Module PSScriptAnalyzer
-$violationMessage = "Cmdlet 'Write-Host' has positional parameter. Please use named parameters instead of positional parameters when calling a command."
+$violationMessage = "Cmdlet 'Get-Command' has positional parameter. Please use named parameters instead of positional parameters when calling a command."
 $violationName = "PSAvoidUsingPositionalParameters"
 $directory = Split-Path -Parent $MyInvocation.MyCommand.Path
 $violations = Invoke-ScriptAnalyzer $directory\AvoidPositionalParameters.ps1 | Where-Object {$_.RuleName -eq $violationName}
@@ -8,8 +8,8 @@ $noViolationsDSC = Invoke-ScriptAnalyzer -ErrorAction SilentlyContinue $director
 
 Describe "AvoidPositionalParameters" {
     Context "When there are violations" {
-        It "has 4 avoid positional parameters violation" {
-            $violations.Count | Should Be 5
+        It "has 1 avoid positional parameters violation" {
+            $violations.Count | Should Be 1
         }
 
         It "has the correct description message" {
diff --git a/Tests/Rules/AvoidPositionalParametersNoViolations.ps1 b/Tests/Rules/AvoidPositionalParametersNoViolations.ps1
@@ -13,4 +13,11 @@ get-service-computername localhost | where {($_.status -eq "Running") -and ($_.C
 function TestExternalApplication
 {    
     & "c:\Windows\System32\Calc.exe" parameter1
-}
+}
+
+# less than 3 arguments so rule won't trigger
+Get-Content Test
+Get-ChildItem Tests
+Write-Output "I don't want to use positional parameters"
+Split-Path "RandomPath" -Leaf
+Get-Process | ForEach-Object {Write-Host $_.name -foregroundcolor cyan}

Original file line number	Diff line number	Diff line change
`@@ -283,8 +283,9 @@ public bool HasSplattedVariable(CommandAst cmdAst)`
`283`	`283`	`/// Given a commandast, checks whether positional parameters are used or not.`
`284`	`284`	`/// </summary>`
`285`	`285`	`/// <param name="cmdAst"></param>`
	`286`	`+ /// <param name="moreThanThreePositional">only return true if more than three positional parameters are used</param>`
`286`	`287`	`/// <returns></returns>`
`287`		`- public bool PositionalParameterUsed(CommandAst cmdAst)`
	`288`	`+ public bool PositionalParameterUsed(CommandAst cmdAst, bool moreThanThreePositional = false)`
`288`	`289`	`{`
`289`	`290`	`if (cmdAst == null \|\| cmdAst.GetCommandName() == null)`
`290`	`291`	`{`
`@@ -351,6 +352,11 @@ public bool PositionalParameterUsed(CommandAst cmdAst)`
`351`	`352`	`arguments += 1;`
`352`	`353`	`}`
`353`	`354`
	`355`	`+ if (moreThanThreePositional && arguments < 3)`
	`356`	`+ {`
	`357`	`+ return false;`
	`358`	`+ }`
	`359`	`+`
`354`	`360`	`return arguments > parameters;`
`355`	`361`	`}`
`356`	`362`
Original file line number	Diff line number	Diff line change
`@@ -183,6 +183,7 @@ private void Initialize(`
`183`	`183`	`this.includeRegexList = new List<Regex>();`
`184`	`184`	`this.excludeRegexList = new List<Regex>();`
`185`	`185`
	`186`	`+ #region ParseProfile`
`186`	`187`	`if (!String.IsNullOrWhiteSpace(profile))`
`187`	`188`	`{`
`188`	`189`	`try`
`@@ -191,9 +192,7 @@ private void Initialize(`
`191`	`192`	`}`
`192`	`193`	`catch`
`193`	`194`	`{`
`194`		`- this.outputWriter.WriteError(new ErrorRecord(new FileNotFoundException(),`
`195`		`- string.Format(CultureInfo.CurrentCulture, Strings.FileNotFound, profile),`
`196`		`- ErrorCategory.InvalidArgument, this));`
	`195`	`+ this.outputWriter.WriteWarning(string.Format(CultureInfo.CurrentCulture, Strings.FileNotFound, profile));`
`197`	`196`	`}`
`198`	`197`
`199`	`198`	`if (File.Exists(profile))`
`@@ -202,15 +201,23 @@ private void Initialize(`
`202`	`201`	`ParseError[] parserErrors = null;`
`203`	`202`	`Ast profileAst = Parser.ParseFile(profile, out parserTokens, out parserErrors);`
`204`	`203`	`IEnumerable<Ast> hashTableAsts = profileAst.FindAll(item => item is HashtableAst, false);`
`205`		`- foreach (HashtableAst hashTableAst in hashTableAsts)`
	`204`	`+`
	`205`	`+ // no hashtable, raise warning`
	`206`	`+ if (hashTableAsts.Count() == 0)`
	`207`	`+ {`
	`208`	`+ this.outputWriter.WriteWarning(string.Format(CultureInfo.CurrentCulture, Strings.InvalidProfile, profile));`
	`209`	`+ }`
	`210`	`+ else`
`206`	`211`	`{`
	`212`	`+ HashtableAst hashTableAst = hashTableAsts.First() as HashtableAst;`
	`213`	`+`
`207`	`214`	`foreach (var kvp in hashTableAst.KeyValuePairs)`
`208`	`215`	`{`
`209`	`216`	`if (!(kvp.Item1 is StringConstantExpressionAst))`
`210`	`217`	`{`
`211`		`- this.outputWriter.WriteError(new ErrorRecord(new ArgumentException(),`
`212`		`- string.Format(CultureInfo.CurrentCulture, Strings.WrongKeyFormat, kvp.Item1.Extent.StartLineNumber, kvp.Item1.Extent.StartColumnNumber, profile),`
`213`		`- ErrorCategory.InvalidArgument, this));`
	`218`	`+ // first item (the key) should be a string`
	`219`	`+ this.outputWriter.WriteWarning(`
	`220`	`+ string.Format(CultureInfo.CurrentCulture, Strings.WrongKeyFormat, kvp.Item1.Extent.StartLineNumber, kvp.Item1.Extent.StartColumnNumber, profile));`
`214`	`221`	`continue;`
`215`	`222`	`}`
`216`	`223`
`@@ -257,11 +264,11 @@ private void Initialize(`
`257`	`264`	`{`
`258`	`265`	`foreach (var element in arrayLitAst.Elements)`
`259`	`266`	`{`
	`267`	`+ // all the values in the array needs to be string`
`260`	`268`	`if (!(element is StringConstantExpressionAst))`
`261`	`269`	`{`
`262`		`- this.outputWriter.WriteError(new ErrorRecord(new ArgumentException(),`
`263`		`- string.Format(CultureInfo.CurrentCulture, Strings.WrongValueFormat, element.Extent.StartLineNumber, element.Extent.StartColumnNumber, profile),`
`264`		`- ErrorCategory.InvalidArgument, this));`
	`270`	`+ this.outputWriter.WriteWarning(`
	`271`	`+ string.Format(CultureInfo.CurrentCulture, Strings.WrongValueFormat, element.Extent.StartLineNumber, element.Extent.StartColumnNumber, profile));`
`265`	`272`	`continue;`
`266`	`273`	`}`
`267`	`274`
`@@ -273,9 +280,8 @@ private void Initialize(`
`273`	`280`
`274`	`281`	`if (rhsList.Count == 0)`
`275`	`282`	`{`
`276`		`- this.outputWriter.WriteError(new ErrorRecord(new ArgumentException(),`
`277`		`- string.Format(CultureInfo.CurrentCulture, Strings.WrongValueFormat, kvp.Item2.Extent.StartLineNumber, kvp.Item2.Extent.StartColumnNumber, profile),`
`278`		`- ErrorCategory.InvalidArgument, this));`
	`283`	`+ this.outputWriter.WriteWarning(`
	`284`	`+ string.Format(CultureInfo.CurrentCulture, Strings.WrongValueFormat, kvp.Item2.Extent.StartLineNumber, kvp.Item2.Extent.StartColumnNumber, profile));`
`279`	`285`	`break;`
`280`	`286`	`}`
`281`	`287`
`@@ -312,16 +318,17 @@ private void Initialize(`
`312`	`318`	`}`
`313`	`319`	`break;`
`314`	`320`	`default:`
`315`		`- this.outputWriter.WriteError(new ErrorRecord(new ArgumentException(),`
`316`		`- string.Format(CultureInfo.CurrentCulture, Strings.WrongKey, kvp.Item1.Extent.StartLineNumber, kvp.Item1.Extent.StartColumnNumber, profile),`
`317`		`- ErrorCategory.InvalidArgument, this));`
	`321`	`+ this.outputWriter.WriteWarning(`
	`322`	`+ string.Format(CultureInfo.CurrentCulture, Strings.WrongKey, kvp.Item1.Extent.StartLineNumber, kvp.Item1.Extent.StartColumnNumber, profile));`
`318`	`323`	`break;`
`319`	`324`	`}`
`320`	`325`	`}`
`321`	`326`	`}`
`322`	`327`	`}`
`323`	`328`	`}`
`324`	`329`
	`330`	`+ #endregion`
	`331`	`+`
`325`	`332`	`//Check wild card input for the Include/ExcludeRules and create regex match patterns`
`326`	`333`	`if (this.includeRule != null)`
`327`	`334`	`{`
Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ public IEnumerable<DiagnosticRecord> AnalyzeScript(Ast ast, string fileName)`
`45`	`45`	`if (cmdAst.GetCommandName() == null) continue;`
`46`	`46`
`47`	`47`	`if (Helper.Instance.GetCommandInfo(cmdAst.GetCommandName()) != null`
`48`		`- && Helper.Instance.PositionalParameterUsed(cmdAst))`
	`48`	`+ && Helper.Instance.PositionalParameterUsed(cmdAst, true))`
`49`	`49`	`{`
`50`	`50`	`PipelineAst parent = cmdAst.Parent as PipelineAst;`
`51`	`51`
`@@ -55,14 +55,14 @@ public IEnumerable<DiagnosticRecord> AnalyzeScript(Ast ast, string fileName)`
`55`	`55`	`if (parent.PipelineElements[0] == cmdAst)`
`56`	`56`	`{`
`57`	`57`	`yield return new DiagnosticRecord(string.Format(CultureInfo.CurrentCulture, Strings.AvoidUsingPositionalParametersError, cmdAst.GetCommandName()),`
`58`		`- cmdAst.Extent, GetName(), DiagnosticSeverity.Warning, fileName, cmdAst.GetCommandName());`
	`58`	`+ cmdAst.Extent, GetName(), DiagnosticSeverity.Information, fileName, cmdAst.GetCommandName());`
`59`	`59`	`}`
`60`	`60`	`}`
`61`	`61`	`// not in pipeline so just raise it normally`
`62`	`62`	`else`
`63`	`63`	`{`
`64`	`64`	`yield return new DiagnosticRecord(string.Format(CultureInfo.CurrentCulture, Strings.AvoidUsingPositionalParametersError, cmdAst.GetCommandName()),`
`65`		`- cmdAst.Extent, GetName(), DiagnosticSeverity.Warning, fileName, cmdAst.GetCommandName());`
	`65`	`+ cmdAst.Extent, GetName(), DiagnosticSeverity.Information, fileName, cmdAst.GetCommandName());`
`66`	`66`	`}`
`67`	`67`	`}`
`68`	`68`	`}`
`@@ -109,7 +109,7 @@ public SourceType GetSourceType()`
`109`	`109`	`/// <returns></returns>`
`110`	`110`	`public RuleSeverity GetSeverity()`
`111`	`111`	`{`
`112`		`- return RuleSeverity.Warning;`
	`112`	`+ return RuleSeverity.Information;`
`113`	`113`	`}`
`114`	`114`
`115`	`115`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -118,7 +118,7 @@ Describe "TestSeverity" {`
`118`	`118`
`119`	`119`	`It "filters rules based on multiple severity inputs"{`
`120`	`120`	`$rules = Get-ScriptAnalyzerRule -Severity Error,Information`
`121`		`- $rules.Count \| Should be 13`
	`121`	`+ $rules.Count \| Should be 14`
`122`	`122`	`}`
`123`	`123`
`124`	`124`	`It "takes lower case inputs" {`
Original file line number	Diff line number	Diff line change
`@@ -179,12 +179,12 @@ Describe "Test IncludeRule" {`
`179`	`179`	`Context "IncludeRule supports wild card" {`
`180`	`180`	`It "includes 1 wildcard rule"{`
`181`	`181`	`$includeWildcard = Invoke-ScriptAnalyzer $directory\..\Rules\BadCmdlet.ps1 -IncludeRule $avoidRules`
`182`		`- $includeWildcard.Count \| Should be 3`
	`182`	`+ $includeWildcard.Count \| Should be 0`
`183`	`183`	`}`
`184`	`184`
`185`	`185`	`it "includes 2 wildcardrules" {`
`186`	`186`	`$includeWildcard = Invoke-ScriptAnalyzer $directory\..\Rules\BadCmdlet.ps1 -IncludeRule $avoidRules, $useRules`
`187`		`- $includeWildcard.Count \| Should be 7`
	`187`	`+ $includeWildcard.Count \| Should be 4`
`188`	`188`	`}`
`189`	`189`	`}`
`190`	`190`	`}`
`@@ -210,12 +210,12 @@ Describe "Test Severity" {`
`210`	`210`
`211`	`211`	`It "works with 2 arguments" {`
`212`	`212`	`$errors = Invoke-ScriptAnalyzer $directory\TestScript.ps1 -Severity Information, Warning`
`213`		`- $errors.Count \| Should Be 2`
	`213`	`+ $errors.Count \| Should Be 1`
`214`	`214`	`}`
`215`	`215`
`216`	`216`	`It "works with lowercase argument"{`
`217`	`217`	`$errors = Invoke-ScriptAnalyzer $directory\TestScript.ps1 -Severity information, warning`
`218`		`- $errors.Count \| Should Be 2`
	`218`	`+ $errors.Count \| Should Be 1`
`219`	`219`	`}`
`220`	`220`	`}`
`221`	`221`
Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ Describe "RuleSuppressionWithScope" {`
`50`	`50`	`Context "FunctionScope" {`
`51`	`51`	`It "Does not raise violations" {`
`52`	`52`	`$suppression = $violations \| Where-Object {$_.RuleName -eq "PSAvoidUsingPositionalParameters" }`
`53`		`- $suppression.Count \| Should Be 1`
	`53`	`+ $suppression.Count \| Should Be 0`
`54`	`54`	`}`
`55`	`55`	`}`
`56`	`56`