diff --git a/test/powershell/Language/Classes/ProtectedAccess.Tests.ps1 b/test/powershell/Language/Classes/ProtectedAccess.Tests.ps1
index c54964860c..4b37e6a1a4 100644
--- a/test/powershell/Language/Classes/ProtectedAccess.Tests.ps1
+++ b/test/powershell/Language/Classes/ProtectedAccess.Tests.ps1
@@ -141,50 +141,50 @@ class Derived2 : Base {}
 '@
 
 Describe "Protected Member Access - w/ default ctor" -Tags "CI" {
-    It "Method Access" { $derived1.TestMethodAccess() | Should Be 42 }
-    It "Dynamic Method Access" { $derived1.TestDynamicMethodAccess() | Should Be 42 }
-    It "Field Access" { $derived1.TestFieldAccess() | Should Be 11 }
-    It "Dynamic Field Access" { $derived1.TestDynamicFieldAccess() | Should Be 12 }
-    It "Property Access - protected get/protected set" { $derived1.TestPropertyAccess() | Should Be 1111 }
-    It "Property Access - public get/protected set " { $derived1.TestPropertyAccess1() | Should Be 2111 }
-    It "Property Access - protected get/public set" { $derived1.TestPropertyAccess2() | Should Be 3111 }
-    It "Dynamic Property Access" { $derived1.TestDynamicPropertyAccess() | Should Be 1112 }
+    It "Method Access" { $derived1.TestMethodAccess() | Should -Be 42 }
+    It "Dynamic Method Access" { $derived1.TestDynamicMethodAccess() | Should -Be 42 }
+    It "Field Access" { $derived1.TestFieldAccess() | Should -Be 11 }
+    It "Dynamic Field Access" { $derived1.TestDynamicFieldAccess() | Should -Be 12 }
+    It "Property Access - protected get/protected set" { $derived1.TestPropertyAccess() | Should -Be 1111 }
+    It "Property Access - public get/protected set " { $derived1.TestPropertyAccess1() | Should -Be 2111 }
+    It "Property Access - protected get/public set" { $derived1.TestPropertyAccess2() | Should -Be 3111 }
+    It "Dynamic Property Access" { $derived1.TestDynamicPropertyAccess() | Should -Be 1112 }
 
-    It "Method Access - overloaded 1a" { $derived1.TestOverloadedMethodAccess1a() | Should Be 84 }
-    It "Method Access - overloaded 1b" { $derived1.TestOverloadedMethodAccess1b() | Should Be 11 }
-    It "Method Access - overloaded 2a" { $derived1.TestOverloadedMethodAccess2a() | Should Be 84 }
-    It "Method Access - overloaded 2b" { $derived1.TestOverloadedMethodAccess2b() | Should Be 11 }
-    It "Method Access - overloaded 3a" { $derived1.TestOverloadedMethodAccess3a() | Should Be 84 }
-    It "Method Access - overloaded 3b" { $derived1.TestOverloadedMethodAccess3b() | Should Be 11 }
-    It "Implicit ctor calls protected ctor" { $derived3.OverloadedMethod2(42) | Should Be 84 }
+    It "Method Access - overloaded 1a" { $derived1.TestOverloadedMethodAccess1a() | Should -Be 84 }
+    It "Method Access - overloaded 1b" { $derived1.TestOverloadedMethodAccess1b() | Should -Be 11 }
+    It "Method Access - overloaded 2a" { $derived1.TestOverloadedMethodAccess2a() | Should -Be 84 }
+    It "Method Access - overloaded 2b" { $derived1.TestOverloadedMethodAccess2b() | Should -Be 11 }
+    It "Method Access - overloaded 3a" { $derived1.TestOverloadedMethodAccess3a() | Should -Be 84 }
+    It "Method Access - overloaded 3b" { $derived1.TestOverloadedMethodAccess3b() | Should -Be 11 }
+    It "Implicit ctor calls protected ctor" { $derived3.OverloadedMethod2(42) | Should -Be 84 }
 }
 
 Describe "Protected Member Access - w/ non-default ctor" -Tags "CI" {
-    It "Method Access" { $derived2.TestMethodAccess() | Should Be 52 }
-    It "Dynamic Method Access" { $derived2.TestDynamicMethodAccess() | Should Be 52 }
-    It "Field Access" { $derived2.TestFieldAccess() | Should Be 11 }
-    It "Dynamic Field Access" { $derived2.TestDynamicFieldAccess() | Should Be 12 }
-    It "Property Access - protected get/protected set" { $derived1.TestPropertyAccess() | Should Be 1111 }
-    It "Property Access - public get/protected set " { $derived1.TestPropertyAccess1() | Should Be 2111 }
-    It "Property Access - protected get/public set" { $derived1.TestPropertyAccess2() | Should Be 3111 }
-    It "Dynamic Property Access" { $derived2.TestDynamicPropertyAccess() | Should Be 1112 }
+    It "Method Access" { $derived2.TestMethodAccess() | Should -Be 52 }
+    It "Dynamic Method Access" { $derived2.TestDynamicMethodAccess() | Should -Be 52 }
+    It "Field Access" { $derived2.TestFieldAccess() | Should -Be 11 }
+    It "Dynamic Field Access" { $derived2.TestDynamicFieldAccess() | Should -Be 12 }
+    It "Property Access - protected get/protected set" { $derived1.TestPropertyAccess() | Should -Be 1111 }
+    It "Property Access - public get/protected set " { $derived1.TestPropertyAccess1() | Should -Be 2111 }
+    It "Property Access - protected get/public set" { $derived1.TestPropertyAccess2() | Should -Be 3111 }
+    It "Dynamic Property Access" { $derived2.TestDynamicPropertyAccess() | Should -Be 1112 }
 
-    It "Method Access - overloaded 1a" { $derived2.TestOverloadedMethodAccess1a() | Should Be 94 }
-    It "Method Access - overloaded 1b" { $derived2.TestOverloadedMethodAccess1b() | Should Be 21 }
-    It "Method Access - overloaded 2a" { $derived2.TestOverloadedMethodAccess2a() | Should Be 94 }
-    It "Method Access - overloaded 2b" { $derived2.TestOverloadedMethodAccess2b() | Should Be 21 }
-    It "Method Access - overloaded 3a" { $derived2.TestOverloadedMethodAccess3a() | Should Be 94 }
-    It "Method Access - overloaded 3b" { $derived2.TestOverloadedMethodAccess3b() | Should Be 21 }
+    It "Method Access - overloaded 1a" { $derived2.TestOverloadedMethodAccess1a() | Should -Be 94 }
+    It "Method Access - overloaded 1b" { $derived2.TestOverloadedMethodAccess1b() | Should -Be 21 }
+    It "Method Access - overloaded 2a" { $derived2.TestOverloadedMethodAccess2a() | Should -Be 94 }
+    It "Method Access - overloaded 2b" { $derived2.TestOverloadedMethodAccess2b() | Should -Be 21 }
+    It "Method Access - overloaded 3a" { $derived2.TestOverloadedMethodAccess3a() | Should -Be 94 }
+    It "Method Access - overloaded 3b" { $derived2.TestOverloadedMethodAccess3b() | Should -Be 21 }
 }
 
 Describe "Protected Member Access - members not visible outside class" -Tags "CI" {
     Set-StrictMode -v 3
-    It "Invalid protected field Get Access" { { $derived1.Field } | Should Throw }
-    It "Invalid protected property Get Access" { { $derived1.Property } | Should Throw }
-    It "Invalid protected field Set Access" { { $derived1.Field = 1 } | Should Throw }
-    It "Invalid protected property Set Access" { { $derived1.Property = 1 } | Should Throw }
+    It "Invalid protected field Get Access" { { $derived1.Field } | Should -Throw -ErrorId "PropertyNotFoundStrict" }
+    It "Invalid protected property Get Access" { { $derived1.Property } | Should -Throw -ErrorId "PropertyNotFoundStrict" }
+    It "Invalid protected field Set Access" { { $derived1.Field = 1 } | Should -Throw -ErrorId "PropertyAssignmentException"}
+    It "Invalid protected property Set Access" { { $derived1.Property = 1 } | Should -Throw -ErrorId "PropertyAssignmentException" }
 
-    It "Invalid protected constructor Access" { { [Base]::new() } | Should Throw }
-    It "Invalid protected method Access" { { $derived1.Method() } | Should Throw }
+    It "Invalid protected constructor Access" { { [Base]::new() } | Should -Throw -ErrorId "MethodCountCouldNotFindBest" }
+    It "Invalid protected method Access" { { $derived1.Method() } | Should -Throw -ErrorId "MethodNotFound" }
 }
 
diff --git a/test/powershell/Language/Classes/Scripting.Classes.Attributes.Tests.ps1 b/test/powershell/Language/Classes/Scripting.Classes.Attributes.Tests.ps1
index 9813455286..b659f8de2d 100644
--- a/test/powershell/Language/Classes/Scripting.Classes.Attributes.Tests.ps1
+++ b/test/powershell/Language/Classes/Scripting.Classes.Attributes.Tests.ps1
@@ -56,15 +56,7 @@ namespace Dummy
         [C1]::new().Ensure = "Present"
 
         It 'Error when ValidateSet should be ExceptionWhenSetting' {
-            try
-            {
-                [C1]::new().Ensure = "foo"
-                throw "Exception expected"
-            }
-            catch
-            {
-                $_.FullyQualifiedErrorId | Should be 'ExceptionWhenSetting'
-            }
+            { [C1]::new().Ensure = "foo" } | Should -Throw -ErrorId 'ExceptionWhenSetting'
         }
     }
 
@@ -73,13 +65,7 @@ namespace Dummy
         # This call should not throw exception
         [C1]::Ensure = "Present"
         It 'Error when ValidateSet should be ExceptionWhenSetting'{
-            try  {
-                [C1]::Ensure = "foo"
-                throw "Exception expected"
-            }
-            catch {
-                $_.FullyQualifiedErrorId | Should be 'ExceptionWhenSetting'
-            }
+            { [C1]::Ensure = "foo" } | Should -Throw -ErrorId 'ExceptionWhenSetting'
         }
     }
 
@@ -89,13 +75,7 @@ namespace Dummy
         [C1]::new().f = 10
         [C1]::new().f = 1
         It 'Error when ValidateSet should be ExceptionWhenSetting'{
-            try {
-                [C1]::new().f = 20
-                throw "Exception expected"
-            }
-            catch {
-                $_.FullyQualifiedErrorId | Should be 'ExceptionWhenSetting'
-            }
+            { [C1]::new().f = 20 } | Should -Throw -ErrorId 'ExceptionWhenSetting'
         }
     }
 
@@ -104,13 +84,7 @@ namespace Dummy
         # This call should not throw exception
         [C1]::f = 5
         It 'Error when ValidateSet should be ExceptionWhenSetting'{
-            try {
-                [C1]::f = 20
-                throw "Exception expected"
-            }
-            catch {
-                $_.FullyQualifiedErrorId | Should be 'ExceptionWhenSetting'
-            }
+            { [C1]::f = 20 } | Should -Throw -ErrorId 'ExceptionWhenSetting'
         }
     }
 
@@ -120,13 +94,7 @@ namespace Dummy
         [C1]::o = "abc"
         [C1]::o = 5
         It 'Error when ValidateSet should be ExceptionWhenSetting'{
-            try {
-                [C1]::o = 1
-                throw "Exception expected"
-            }
-            catch {
-                $_.FullyQualifiedErrorId | Should be 'ExceptionWhenSetting'
-            }
+            { [C1]::o = 1 } | Should -Throw -ErrorId 'ExceptionWhenSetting'
         }
     }
 
@@ -142,11 +110,11 @@ namespace Dummy
 
         It 'Implicitly Transform to 100' {
             $c.arg = 100
-            $c.arg | should be 100
+            $c.arg | Should -Be 100
         }
         It 'Implicitly Transform to foo' {
             $c.arg = "foo"
-            $c.arg | should be "foofoo"
+            $c.arg | Should -BeExactly "foofoo"
         }
     }
 
@@ -154,7 +122,7 @@ namespace Dummy
         $c = [scriptblock]::Create('class C1 { [Dummy.DoubleStringTransformation()][string]$arg }; [C1]::new()').Invoke()[0]
         It 'set to foo' {
             $c.arg = "foo"
-            $c.arg | should be "foofoo"
+            $c.arg | Should -BeExactly "foofoo"
         }
     }
 
@@ -162,16 +130,10 @@ namespace Dummy
         $c = [scriptblock]::Create('class C1 { [Dummy.DoubleInt()][int]$arg }; [C1]::new()').Invoke()[0]
         It 'arg should be 200' {
             $c.arg = 100
-            $c.arg | should be 200
+            $c.arg | Should -Be 200
         }
         It 'Set to string should fail with ExceptionWhenSetting' {
-            try {
-                $c.arg = "abc"
-                throw "Exception expected"
-            }
-            catch {
-                $_.FullyQualifiedErrorId | Should be 'ExceptionWhenSetting'
-            }
+            { $c.arg = "abc" } | Should -Throw -ErrorId 'ExceptionWhenSetting'
         }
     }
 
@@ -179,7 +141,7 @@ namespace Dummy
         $c = [scriptblock]::Create('class C1 { [Nullable[int]][Dummy.DoubleStringTransformation()]$arg }; [C1]::new()').Invoke()[0]
         It 'arg should be 100' {
             $c.arg = 100
-            $c.arg | should be 100
+            $c.arg | Should -Be 100
         }
     }
 
@@ -187,12 +149,12 @@ namespace Dummy
         $c = [scriptblock]::Create('class C1 { [Dummy.DoubleStringTransformation()][Dummy.AppendStringTransformation()]$arg }; [C1]::new()').Invoke()[0]
         It 'arg should be 100' {
             $c.arg = 100
-            $c.arg | should be 100
+            $c.arg | Should -Be 100
         }
 
         It 'arg should be foo___foo___g' {
             $c.arg = "foo"
-            $c.arg | should be "foo___foo___"
+            $c.arg | Should -BeExactly "foo___foo___"
         }
     }
 }
@@ -211,7 +173,7 @@ Describe 'Type resolution with attributes' -Tag "CI" {
                 [void] OnEvent([string]$Message) {}
             }
 
-            [MyEventSource]::new() | Should Not Be $null
+            [MyEventSource]::new() | Should -Not -BeNullOrEmpty
 
         }
     }
@@ -302,14 +264,14 @@ Describe 'ValidateSet support a dynamically generated set' -Tag "CI" {
         }
 
         It 'Dynamically generated set works in C# with default (immediate) cache expire' {
-            Get-TestValidateSet4 -Param1 "TestString1" -ErrorAction SilentlyContinue | Should BeExactly "TestString1"
+            Get-TestValidateSet4 -Param1 "TestString1" -ErrorAction SilentlyContinue | Should -BeExactly "TestString1"
         }
 
         It 'Empty dynamically generated set throws in C#' {
             $exc = {
                 Get-TestValidateSet5 -Param1 "TestString1" -ErrorAction Stop
             } | ShouldBeErrorId "ParameterArgumentValidationError,Test.Language.TestValidateSetCommand5"
-            $exc.Exception.InnerException.ErrorRecord.FullyQualifiedErrorId | Should BeExactly "ValidateSetGeneratedValidValuesListIsNull"
+            $exc.Exception.InnerException.ErrorRecord.FullyQualifiedErrorId | Should -BeExactly "ValidateSetGeneratedValidValuesListIsNull"
         }
     }
 
@@ -390,7 +352,7 @@ Describe 'ValidateSet support a dynamically generated set' -Tag "CI" {
         }
 
         It 'Dynamically generated set works in PowerShell script with default (immediate) cache expire' {
-            Get-TestValidateSetPS4 -Param1 "TestString1" -ErrorAction SilentlyContinue | Should BeExactly "TestString1"
+            Get-TestValidateSetPS4 -Param1 "TestString1" -ErrorAction SilentlyContinue | Should -BeExactly "TestString1"
         }
 
         It 'Get the appropriate error message' {
@@ -401,7 +363,7 @@ Describe 'ValidateSet support a dynamically generated set' -Tag "CI" {
             $exc = {
                 Get-TestValidateSetPS5 -Param1 "TestString1" -ErrorAction Stop
             } | ShouldBeErrorId "ParameterArgumentValidationError,Get-TestValidateSetPS5"
-            $exc.Exception.InnerException.ErrorRecord.FullyQualifiedErrorId | Should BeExactly "ValidateSetGeneratedValidValuesListIsNull"
+            $exc.Exception.InnerException.ErrorRecord.FullyQualifiedErrorId | Should -BeExactly "ValidateSetGeneratedValidValuesListIsNull"
         }
 
         It 'Unimplemented valid values generator type throws in PowerShell script' {
@@ -437,7 +399,7 @@ Describe 'ValidateSet support a dynamically generated set' -Tag "CI" {
 
             try {
                 Import-Module -Name $moduleFile -Force
-                Test-ValidateSet 'Hello' | Should Be 'Hello'
+                Test-ValidateSet 'Hello' | Should -BeExactly 'Hello'
             } finally {
                 Remove-Module -Name $moduleFile -Force
             }
@@ -502,14 +464,14 @@ Describe 'ValidateSet support a dynamically generated set' -Tag "CI" {
         }
 
         It 'Can implement CachedValidValuesGeneratorBase in PowerShell' {
-            Get-TestValidateSetPS4 -Param1 "TestString1" -ErrorAction SilentlyContinue | Should BeExactly "TestString1"
+            Get-TestValidateSetPS4 -Param1 "TestString1" -ErrorAction SilentlyContinue | Should -BeExactly "TestString1"
         }
 
         It 'Can implement CachedValidValuesGeneratorBase with cache expiration in PowerShell' {
-            Get-TestValidateSetPS5 -Param1 "TestString1" -ErrorAction SilentlyContinue | Should BeExactly "TestString1"
-            Get-TestValidateSetPS5 -Param1 "TestString1" -ErrorAction SilentlyContinue | Should BeExactly "TestString1"
+            Get-TestValidateSetPS5 -Param1 "TestString1" -ErrorAction SilentlyContinue | Should -BeExactly "TestString1"
+            Get-TestValidateSetPS5 -Param1 "TestString1" -ErrorAction SilentlyContinue | Should -BeExactly "TestString1"
             Start-Sleep 3
-            Get-TestValidateSetPS5 -Param1 "TestString2" -ErrorAction SilentlyContinue | Should BeExactly "TestString2"
+            Get-TestValidateSetPS5 -Param1 "TestString2" -ErrorAction SilentlyContinue | Should -BeExactly "TestString2"
         }
     }
 }
diff --git a/test/powershell/Language/Classes/Scripting.Classes.BasicParsing.Tests.ps1 b/test/powershell/Language/Classes/Scripting.Classes.BasicParsing.Tests.ps1
index 02e52384ff..1d017ce11a 100644
--- a/test/powershell/Language/Classes/Scripting.Classes.BasicParsing.Tests.ps1
+++ b/test/powershell/Language/Classes/Scripting.Classes.BasicParsing.Tests.ps1
@@ -109,13 +109,13 @@ Describe 'Positive Parse Properties Tests' -Tags "CI" {
         # Method with return type of self
         class C9 { [C9] f() { return [C9]::new() } }
         $c9 = [C9]::new().f()
-        It "Expected a C9 returned" { $c9.GetType().Name | should be C9 }
+        It "Expected a C9 returned" { $c9.GetType().Name | Should -Be C9 }
         class C9a { [C9a[]] f() { return [C9a]::new() } }
         $c9a = [C9a]::new().f()
-        It "Expected a C9a[] returned" { $c9a.GetType().Name | should be C9a[] }
+        It "Expected a C9a[] returned" { $c9a.GetType().Name | Should -Be C9a[] }
         class C9b { [System.Collections.Generic.List[C9b]] f() { return [C9b]::new() } }
         $c9b = [C9b]::new().f()
-        It "Expected a System.Collections.Generic.List[C9b] returned" {  $c9b -is [System.Collections.Generic.List[C9b]] | should be $true }
+        It "Expected a System.Collections.Generic.List[C9b] returned" {  $c9b -is [System.Collections.Generic.List[C9b]] | Should -BeTrue }
     }
 
     It 'Positive ParseProperty Attributes Test' {
@@ -216,7 +216,7 @@ Describe 'Positive Parse Properties Tests' -Tags "CI" {
             {
                 $LASTEXITCODE
                 $lastexitcode
-                '111' -match '1'
+                '111' -Match '1'
                 $Matches
                 $mAtches
                 $Error[0]
@@ -242,7 +242,7 @@ Describe 'Positive Parse Properties Tests' -Tags "CI" {
                 $this.h = [ordered] @{}
             }
         }
-        [A]::new().h.GetType().Name | Should Be 'OrderedDictionary'
+        [A]::new().h.GetType().Name | Should -BeExactly 'OrderedDictionary'
     }
 }
 
@@ -365,31 +365,31 @@ Describe 'Negative ClassAttributes Tests' -Tags "CI" {
     [System.Management.Automation.Cmdlet("Get", "Thing")]class C{}
     $t = [C].GetCustomAttributes($false)
 
-    It "Should have one attribute (class C)" {$t.Count | should be 1}
-    It "Should have instance of CmdletAttribute (class C)" {$t[0].GetType().FullName | should be System.Management.Automation.CmdletAttribute }
+    It "Should have one attribute (class C)" {$t.Count | Should -Be 1}
+    It "Should have instance of CmdletAttribute (class C)" {$t[0] | Should -BeOfType System.Management.Automation.CmdletAttribute }
 
     [System.Management.Automation.CmdletAttribute]$c = $t[0]
-    It "Verb should be Get (class C)" {$c.VerbName | should be 'Get'}
-    It "Noun should be Thing (class C)" {$c.NounName | should be 'Thing'}
+    It "Verb should be Get (class C)" {$c.VerbName | Should -BeExactly 'Get'}
+    It "Noun should be Thing (class C)" {$c.NounName | Should -BeExactly 'Thing'}
 
     [System.Management.Automation.Cmdlet("Get", "Thing", SupportsShouldProcess = $true, SupportsPaging = $true)]class C2{}
     $t = [C2].GetCustomAttributes($false)
-    It "Should have one attribute (class C2)" { $t.Count | should be 1 }
-    It "Should have instance of CmdletAttribute (class C2)" { $t[0].GetType().FullName | should be System.Management.Automation.CmdletAttribute }
+    It "Should have one attribute (class C2)" { $t.Count | should -Be 1 }
+    It "Should have instance of CmdletAttribute (class C2)" { $t[0] | Should -BeOfType System.Management.Automation.CmdletAttribute }
     [System.Management.Automation.CmdletAttribute]$c = $t[0]
-    It "Verb should be Get (class C2)" {$c.VerbName | should be 'Get'}
-    It "Noun should be Thing (class C2)" {$c.NounName | should be 'Thing'}
+    It "Verb should be Get (class C2)" {$c.VerbName | Should -BeExactly 'Get'}
+    It "Noun should be Thing (class C2)" {$c.NounName | Should -BeExactly 'Thing'}
 
-    It  "SupportsShouldProcess should be $true" { $c.ConfirmImpact | should be $true }
-    It  "SupportsPaging should be `$true" { $c.SupportsPaging | should be $true }
+    It  "SupportsShouldProcess should be $true" { $c.ConfirmImpact | Should -BeTrue }
+    It  "SupportsPaging should be `$true" { $c.SupportsPaging | Should -BeTrue }
     Context "Support ConfirmImpact as an attribute" {
-        It  "ConfirmImpact should be high" -pending {
+        It  "ConfirmImpact should be high" {
             [System.Management.Automation.Cmdlet("Get", "Thing", ConfirmImpact = 'High', SupportsPaging = $true)]class C3{}
             $t = [C3].GetCustomAttributes($false)
-            It "Should have one attribute" { $t.Count | should be 1 }
-            It "Should have instance of CmdletAttribute" { $t[0].GetType().FullName | should be System.Management.Automation.CmdletAttribute }
+            $t.Count | Should -Be 1
+            $t[0] | Should -BeOfType System.Management.Automation.CmdletAttribute
             [System.Management.Automation.CmdletAttribute]$c = $t[0]
-            $c.ConfirmImpact | should be 'High'
+            $c.ConfirmImpact | Should -BeExactly 'High'
 
         }
     }
@@ -399,19 +399,19 @@ Describe 'Property Attributes Test' -Tags "CI" {
         class C { [ValidateSet('a', 'b')]$p; }
 
         $t = [C].GetProperty('p').GetCustomAttributes($false)
-        It "Should have one attribute" { $t.Count | should be 1 }
+        It "Should have one attribute" { $t.Count | Should -Be 1 }
         [ValidateSet]$v = $t[0]
-        It "Should have 2 valid values" { $v.ValidValues.Count | should be 2 }
-        It "first value should be a" { $v.ValidValues[0] | should be 'a' }
-        It "second value should be b" { $v.ValidValues[1] | should be 'b' }
+        It "Should have 2 valid values" { $v.ValidValues.Count | Should -Be 2 }
+        It "first value should be a" { $v.ValidValues[0] | Should -Be 'a' }
+        It "second value should be b" { $v.ValidValues[1] | Should -Be 'b' }
 }
 
 Describe 'Method Attributes Test' -Tags "CI" {
         class C { [Obsolete("aaa")][int]f() { return 1 } }
 
         $t = [C].GetMethod('f').GetCustomAttributes($false)
-        It "Should have one attribute" {$t.Count | should be 1 }
-        It "Attribute type should be ObsoleteAttribute" { $t[0].GetType().FullName | should be System.ObsoleteAttribute }
+        It "Should have one attribute" {$t.Count | Should -Be 1 }
+        It "Attribute type should be ObsoleteAttribute" { $t[0].GetType().FullName | Should -Be System.ObsoleteAttribute }
 }
 
 Describe 'Positive SelfClass Type As Parameter Test' -Tags "CI" {
@@ -432,8 +432,8 @@ Describe 'Positive SelfClass Type As Parameter Test' -Tags "CI" {
             $point2 = [Point]::new(1,2)
             $point.Add($point2)
 
-            $point.x | should be 101
-            $point.y | should be 202
+            $point.x | Should -Be 101
+            $point.y | Should -Be 202
         }
 
         It  "[Point]::Add works construction via new-object" {
@@ -441,8 +441,8 @@ Describe 'Positive SelfClass Type As Parameter Test' -Tags "CI" {
             $point2 = New-Object Point 1,2
             $point.Add($point2)
 
-            $point.x | should be 101
-            $point.y | should be 202
+            $point.x | Should -Be 101
+            $point.y | Should -Be 202
         }
 }
 
@@ -460,7 +460,7 @@ Describe 'PositiveReturnSelfClassTypeFromMemberFunction Test' -Tags "CI" {
         }
         $f = [ReturnObjectFromMemberFunctionTest]::new()
         $z = $f.CreateInstance() # Line 13
-        It "CreateInstance works" { $z.SayHello() | should be 'Hello1' }
+        It "CreateInstance works" { $z.SayHello() | Should -BeExactly 'Hello1' }
 }
 
 Describe 'TestMultipleArguments Test' -Tags "CI" {
@@ -511,8 +511,8 @@ $ctorAssignments
 
     `$inst = [Foo]::new($methodArguments)
     `$sum = $addUpProperties
-    It "ExpectedTotal: Sum should be $expectedTotal" { `$sum | should be $expectedTotal }
-    It "ExpectedTotal: Invocation should return $expectedTotal" { `$inst.DoSomething($methodArguments) | should be $expectedTotal }
+    It "ExpectedTotal: Sum should be $expectedTotal" { `$sum | Should -Be $expectedTotal }
+    It "ExpectedTotal: Invocation should return $expectedTotal" { `$inst.DoSomething($methodArguments) | Should -Be $expectedTotal }
 "@
 
             Invoke-Expression $class
@@ -542,7 +542,7 @@ Describe 'Check PS Class Assembly Test' -Tags "CI" {
         $assem = [C1].Assembly
         $attrs = @($assem.GetCustomAttributes($true))
         $expectedAttr = @($attrs | Where-Object { $_  -is [System.Management.Automation.DynamicClassImplementationAssemblyAttribute] })
-        It "Expected a DynamicClassImplementationAssembly attribute" { $expectedAttr.Length | should be 1}
+        It "Expected a DynamicClassImplementationAssembly attribute" { $expectedAttr.Length | Should -Be 1}
 }
 
 Describe 'ScriptScopeAccessFromClassMethod' -Tags "CI" {
@@ -550,7 +550,7 @@ Describe 'ScriptScopeAccessFromClassMethod' -Tags "CI" {
         try
         {
             $c = Get-MSFT_778492
-            It "Method should have found variable in module scope" { $c.F() | should be 'MSFT_778492 script scope'}
+            It "Method should have found variable in module scope" { $c.F() | Should -BeExactly 'MSFT_778492 script scope'}
         }
         finally
         {
@@ -569,32 +569,32 @@ Describe 'Hidden Members Test ' -Tags "CI" {
         # Create an instance
         $instance = [C1]@{ visibleX = 10; visibleY = 12; hiddenZ = 42 }
 
-        It "Access hidden property should still work" { $instance.hiddenZ | should be 42 }
+        It "Access hidden property should still work" { $instance.hiddenZ | Should -Be 42 }
 
         # Formatting should not include hidden members by default
         $tableOutput = $instance | Format-Table -HideTableHeaders -AutoSize | Out-String
-        It "Table formatting should not have included hidden member hiddenZ - should contain 10" { $tableOutput.Contains(10) | should be $true}
-        It "Table formatting should not have included hidden member hiddenZ- should contain 12" { $tableOutput.Contains(12) | should be $true}
-        It "Table formatting should not have included hidden member hiddenZ - should not contain 42" { $tableOutput.Contains(42) | should be $false}
+        It "Table formatting should not have included hidden member hiddenZ - should contain 10" { $tableOutput.Contains(10) | Should -BeTrue}
+        It "Table formatting should not have included hidden member hiddenZ- should contain 12" { $tableOutput.Contains(12) | Should -BeTrue}
+        It "Table formatting should not have included hidden member hiddenZ - should not contain 42" { $tableOutput.Contains(42) | Should -BeFalse}
 
         # Get-Member should not include hidden members by default
         $member = $instance | Get-Member hiddenZ
-        it "Get-Member should not find hidden member w/o -Force" { $member | should be $null }
+        it "Get-Member should not find hidden member w/o -Force" { $member | Should -BeNullOrEmpty }
 
         # Get-Member should include hidden members with -Force
         $member = $instance | Get-Member hiddenZ -Force
-        It "Get-Member should find hidden member w/ -Force" { $member | should not be $null }
+        It "Get-Member should find hidden member w/ -Force" { $member | Should -Not -BeNullOrEmpty }
 
         # Tab completion should not return a hidden member
         $line = 'class C2 { hidden [int]$hiddenZ } [C2]::new().h'
         $completions = [System.Management.Automation.CommandCompletion]::CompleteInput($line, $line.Length, $null)
-        It "Tab completion should not return a hidden member" { $completions.CompletionMatches.Count | should be 0 }
+        It "Tab completion should not return a hidden member" { $completions.CompletionMatches.Count | Should -Be 0 }
 }
 
 Describe 'BaseMethodCall Test ' -Tags "CI" {
-        It "Derived class method call" {"abc".ToString() | should be "abc" }
+        It "Derived class method call" {"abc".ToString() | Should -BeExactly "abc" }
         # call [object] ToString() method as a base class method.
-        It "Base class method call" {([object]"abc").ToString() | should be "System.String" }
+        It "Base class method call" {([object]"abc").ToString() | Should -BeExactly "System.String" }
 }
 
 Describe 'Scoped Types Test' -Tags "CI" {
@@ -614,14 +614,14 @@ Describe 'Scoped Types Test' -Tags "CI" {
             return (new-object C1).GetContext()
         }
 
-        It "New-Object at test scope" { (new-object C1).GetContext() | should be "Test scope" }
-        It "[C1]::new() at test scope" { [C1]::new().GetContext() | should be "Test scope" }
+        It "New-Object at test scope" { (new-object C1).GetContext() | Should -BeExactly "Test scope" }
+        It "[C1]::new() at test scope" { [C1]::new().GetContext() | Should -BeExactly "Test scope" }
 
-        It "[C1]::new() in nested scope" { (f1) | should be "f1 scope" }
-        It "'new-object C1' in nested scope" { (f2) | should be "f2 scope" }
+        It "[C1]::new() in nested scope" { (f1) | Should -BeExactly "f1 scope" }
+        It "'new-object C1' in nested scope" { (f2) | Should -BeExactly "f2 scope" }
 
-        It "[C1]::new() in nested scope (in pipeline)" { (1 | f1 | f2 | f1) | should be "f1 scope" }
-        It "'new-object C1' in nested scope (in pipeline)" { (1 | f2 | f1 | f2) | should be "f2 scope" }
+        It "[C1]::new() in nested scope (in pipeline)" { (1 | f1 | f2 | f1) | Should -BeExactly "f1 scope" }
+        It "'new-object C1' in nested scope (in pipeline)" { (1 | f2 | f1 | f2) | Should -BeExactly "f2 scope" }
 }
 
 Describe 'ParameterOfClassTypeInModule Test' -Tags "CI" {
@@ -633,7 +633,7 @@ function test-it([EE]$ee){$ee}
 '@)
             $mod = New-Module $sb -Name MSFT_2081529 | Import-Module
             $result = test-it -ee one
-            It "Parameter of class/enum type defined in module should work" { $result | should be 1 }
+            It "Parameter of class/enum type defined in module should work" { $result | Should -Be 1 }
         }
         finally
         {
@@ -647,7 +647,7 @@ Describe 'Type building' -Tags "CI" {
         1..10 | ForEach-Object {
             class C {}
             if ($a) {
-                $a -eq [C] | Should Be $true
+	         $a -eq [C] | Should -BeTrue
             }
             $a = [C]
         }
@@ -657,8 +657,8 @@ Describe 'Type building' -Tags "CI" {
         $sb = [scriptblock]::Create('class A {static [int] $a }; [A]::new()')
         1..2 | ForEach-Object {
         $a = $sb.Invoke()[0]
-            ++$a::a | Should Be 1
-            ++$a::a | Should Be 2
+            ++$a::a | Should -Be 1
+            ++$a::a | Should -Be 2
         }
     }
 
@@ -667,7 +667,7 @@ Describe 'Type building' -Tags "CI" {
 
         $a = [C].Assembly.GetCustomAttributes($false).Where{
             $_ -is [System.Management.Automation.DynamicClassImplementationAssemblyAttribute]}
-        $a.ScriptFile | Should BeExactly $PSCommandPath
+        $a.ScriptFile | Should -BeExactly $PSCommandPath
     }
 }
 
@@ -693,17 +693,17 @@ class Derived : Base
         $iss.Commands.Add($ssfe)
 
         $ps = [powershell]::Create($iss)
-        $ps.AddCommand("foo").Invoke() | Should be 200
-        $ps.Streams.Error | Should Be $null
+        $ps.AddCommand("foo").Invoke() | Should -Be 200
+        $ps.Streams.Error | Should -BeNullOrEmpty
 
         $ps1 = [powershell]::Create($iss)
-        $ps1.AddCommand("foo").Invoke() | Should be 200
-        $ps1.Streams.Error | Should Be $null
+        $ps1.AddCommand("foo").Invoke() | Should -Be 200
+        $ps1.Streams.Error | Should -BeNullOrEmpty
 
         $ps.Commands.Clear()
         $ps.Streams.Error.Clear()
-        $ps.AddScript(". foo").Invoke() | Should be 200
-        $ps.Streams.Error | Should Be $null
+        $ps.AddScript(". foo").Invoke() | Should -Be 200
+        $ps.Streams.Error | Should -BeNullOrEmpty
     }
 }
 
@@ -724,11 +724,11 @@ class B
 '@).Invoke()[0]
 
         It 'can do type lookup by name' {
-            $b.getA1() | Should Be 'A'
+            $b.getA1() | Should -BeExactly 'A'
         }
 
         It 'can do type lookup by [type]' {
-            $b.getA2() | Should Be 'A'
+            $b.getA2() | Should -BeExactly 'A'
         }
     }
 }
@@ -745,7 +745,7 @@ namespace Foo
 }
 '@
 
-     It 'doesn''t allow protected methods access outside of inheritance chain' -pending {
+     It 'doesn''t allow protected methods access outside of inheritance chain' {
         $a = [scriptblock]::Create(@'
 class A
 {
@@ -764,20 +764,8 @@ class A
 
 '@).Invoke()
         $bar = [Foo.Bar]::new()
-        $throwCount = 0
-        try {
-            $a.SetX($bar, 42)
-        } catch {
-            $_.FullyQualifiedErrorId | Should Be PropertyAssignmentException
-            $throwCount++
-        }
-        try {
-            $a.GetX($bar)
-        } catch {
-            $_.FullyQualifiedErrorId | Should Be PropertyNotFoundStrict
-            $throwCount++
-        }
-        $throwCount | Should Be 2
+        { $a.SetX($bar, 42) } | Should -Throw -ErrorId 'PropertyAssignmentException'
+        { $a.GetX($bar) } | Should -Throw -ErrorId 'PropertyNotFoundStrict'
      }
 
      It 'can call protected methods sequentially from two different contexts' {
@@ -802,17 +790,17 @@ return [A]::new()
 
         $ps = [powershell]::Create($iss)
         $a = $ps.AddCommand("foo").Invoke()[0]
-        $ps.Streams.Error | Should Be $null
+        $ps.Streams.Error | Should -BeNullOrEmpty
 
         $ps1 = [powershell]::Create($iss)
         $a1 = $ps1.AddCommand("foo").Invoke()[0]
-        $ps1.Streams.Error | Should Be $null
+        $ps1.Streams.Error | Should -BeNullOrEmpty
 
         $a.SetX(101)
         $a1.SetX(103)
 
-        $a.GetX() | Should Be 101
-        $a1.GetX() | Should Be 103
+        $a.GetX() | Should -Be 101
+        $a1.GetX() | Should -Be 103
     }
 }
 
@@ -829,6 +817,6 @@ Describe 'variable analysis' -Tags "CI" {
             }
         }
 
-        [B]::getA().getFoo() | Should Be 'foo'
+        [B]::getA().getFoo() | Should -BeExactly 'foo'
     }
 }
diff --git a/test/powershell/Language/Classes/Scripting.Classes.Break.Tests.ps1 b/test/powershell/Language/Classes/Scripting.Classes.Break.Tests.ps1
index e4fc11e4f5..ead2ed5ee2 100644
--- a/test/powershell/Language/Classes/Scripting.Classes.Break.Tests.ps1
+++ b/test/powershell/Language/Classes/Scripting.Classes.Break.Tests.ps1
@@ -21,8 +21,8 @@ class A
     }
 }
 '@
-            $errors.Count | Should be 1
-            $errors[0].ErrorId | Should be 'LabelNotFound'
+            $errors.Count | Should -Be 1
+            $errors[0].ErrorId | Should -BeExactly 'LabelNotFound'
         }
 
         It 'reports parse error for break outside of loop' {
@@ -36,8 +36,8 @@ class A
     }
 }
 '@
-            $errors.Count | Should be 1
-            $errors[0].ErrorId | Should be 'LabelNotFound'
+            $errors.Count | Should -Be 1
+            $errors[0].ErrorId | Should -BeExactly 'LabelNotFound'
         }
 
         It 'work fine, when break is legit' {
@@ -51,7 +51,7 @@ class A
                     return $i
                 }
             }
-            [C]::foo() | Should be 101
+            [C]::foo() | Should -Be 101
         }
     }
 
@@ -67,8 +67,8 @@ class A
     }
 }
 '@
-            $errors.Count | Should be 1
-            $errors[0].ErrorId | Should be 'LabelNotFound'
+            $errors.Count | Should -Be 1
+            $errors[0].ErrorId | Should -BeExactly 'LabelNotFound'
         }
     }
 
@@ -90,10 +90,10 @@ class A
 
             $canary = $false
             try {
-                [C]::getInt() | Should Be 123
+                [C]::getInt() | Should -Be 123
                 $canary = $true
             } finally {
-                $canary | Should be $true
+                $canary | Should -BeTrue
             }
         }
 
@@ -121,10 +121,10 @@ class A
 
             $canary = $false
             try {
-                [C]::getInt() | Should Be (123 + 4*4)
+                [C]::getInt() | Should -Be (123 + 4*4)
                 $canary = $true
             } finally {
-                $canary | Should be $true
+                $canary | Should -BeTrue
             }
         }
     }
@@ -140,7 +140,7 @@ function foo()
     return 1
 }
 '@
-            $errors.Count | Should be 0
+            $errors.Count | Should -Be 0
         }
 
     }
diff --git a/test/powershell/Language/Classes/Scripting.Classes.Exceptions.Tests.ps1 b/test/powershell/Language/Classes/Scripting.Classes.Exceptions.Tests.ps1
index ccb6b5c17f..f38d2fda1c 100644
--- a/test/powershell/Language/Classes/Scripting.Classes.Exceptions.Tests.ps1
+++ b/test/powershell/Language/Classes/Scripting.Classes.Exceptions.Tests.ps1
@@ -42,7 +42,7 @@ class C
 
             } catch {}
 
-            $canaryHashtable['canary'] | Should Be 42
+            $canaryHashtable['canary'] | Should -Be 42
         }
 
         It 'does not execute statements after static method with exception' {
@@ -71,7 +71,7 @@ class C
 
             } catch {}
 
-            $canaryHashtable['canary'] | Should Be 43
+            $canaryHashtable['canary'] | Should -Be 43
         }
 
         It 'does not execute statements after instance method with exception and deep stack' {
@@ -127,7 +127,7 @@ class C
 
             } catch {}
 
-            $canaryHashtable['canary'] | Should Be 11111
+            $canaryHashtable['canary'] | Should -Be 11111
         }
     }
 
@@ -185,7 +185,7 @@ function ImThrow()
 
             } catch {}
 
-            $canaryHashtable['canaryM'] | Should Be 45
+            $canaryHashtable['canaryM'] | Should -Be 45
         }
 
         It 'does not execute statements after function with exception called from static method' {
@@ -198,7 +198,7 @@ function ImThrow()
 
             } catch {}
 
-            $canaryHashtable['canaryS'] | Should Be 46
+            $canaryHashtable['canaryS'] | Should -Be 46
         }
 
     }
@@ -220,7 +220,7 @@ $canaryHashtable['canary'] += 100
 
             } catch {}
 
-            $canaryHashtable['canary'] | Should Be 111
+            $canaryHashtable['canary'] | Should -Be 111
         }
     }
 }
@@ -239,7 +239,7 @@ Describe "Exception error position" -Tags "CI" {
             [MSFT_3090412]::f1()
             throw "f1 should have thrown"
         } catch {
-            $_.InvocationInfo.Line | Should Match ([regex]::Escape('[MSFT_3090412]::bar = 42'))
+            $_.InvocationInfo.Line | Should -Match ([regex]::Escape('[MSFT_3090412]::bar = 42'))
         }
     }
 
@@ -248,7 +248,7 @@ Describe "Exception error position" -Tags "CI" {
             [MSFT_3090412]::f2()
             throw "f2 should have thrown"
         } catch {
-            $_.InvocationInfo.Line | Should Match ([regex]::Escape('throw "an error in f2"'))
+            $_.InvocationInfo.Line | Should -Match ([regex]::Escape('throw "an error in f2"'))
         }
     }
 
@@ -257,7 +257,7 @@ Describe "Exception error position" -Tags "CI" {
             [MSFT_3090412]::f3()
             throw "f3 should have thrown"
         } catch {
-            $_.InvocationInfo.Line | Should Match ([regex]::Escape('"".Substring(0, 10)'))
+            $_.InvocationInfo.Line | Should -Match ([regex]::Escape('"".Substring(0, 10)'))
         }
     }
 
@@ -266,7 +266,7 @@ Describe "Exception error position" -Tags "CI" {
             [MSFT_3090412]::f4()
             throw "f4 should have thrown"
         } catch {
-            $_.InvocationInfo.Line | Should Match ([regex]::Escape('dir nosuchfile -ea Stop'))
+            $_.InvocationInfo.Line | Should -Match ([regex]::Escape('dir nosuchfile -ea Stop'))
         }
     }
 }
@@ -302,8 +302,8 @@ Describe "Exception from initializer" -Tags "CI" {
         catch
         {
             $e = $_
-            $e.FullyQualifiedErrorId | Should Be InvalidCastFromStringToInteger
-            $e.InvocationInfo.Line | Should Match 'a = "zz"'
+            $e.FullyQualifiedErrorId | Should -BeExactly 'InvalidCastFromStringToInteger'
+            $e.InvocationInfo.Line | Should -Match 'a = "zz"'
         }
     }
 
@@ -315,8 +315,8 @@ Describe "Exception from initializer" -Tags "CI" {
         catch
         {
             $e = $_
-            $e.FullyQualifiedErrorId | Should Be InvalidCastFromStringToInteger
-            $e.InvocationInfo.Line | Should Match 'a = "zz"'
+            $e.FullyQualifiedErrorId | Should -BeExactly 'InvalidCastFromStringToInteger'
+            $e.InvocationInfo.Line | Should -Match 'a = "zz"'
         }
     }
 
@@ -327,10 +327,10 @@ Describe "Exception from initializer" -Tags "CI" {
         }
         catch
         {
-            $_.Exception | Should BeOfType System.TypeInitializationException
+            $_.Exception | Should -BeOfType System.TypeInitializationException
             $e  = $_.Exception.InnerException.InnerException.ErrorRecord
-            $e.FullyQualifiedErrorId | Should Be InvalidCastFromStringToInteger
-            $e.InvocationInfo.Line | Should Match 'a = "zz"'
+            $e.FullyQualifiedErrorId | Should -BeExactly 'InvalidCastFromStringToInteger'
+            $e.InvocationInfo.Line | Should -Match 'a = "zz"'
         }
     }
 
@@ -341,10 +341,10 @@ Describe "Exception from initializer" -Tags "CI" {
         }
         catch
         {
-            $_.Exception | Should BeOfType System.TypeInitializationException
+            $_.Exception | Should -BeOfType System.TypeInitializationException
             $e  = $_.Exception.InnerException.InnerException.ErrorRecord
-            $e.FullyQualifiedErrorId | Should Be InvalidCastFromStringToInteger
-            $e.InvocationInfo.Line | Should Match 'a = "zz"'
+            $e.FullyQualifiedErrorId | Should -BeExactly 'InvalidCastFromStringToInteger'
+            $e.InvocationInfo.Line | Should -Match 'a = "zz"'
         }
     }
 }
diff --git a/test/powershell/Language/Classes/Scripting.Classes.MiscOps.Tests.ps1 b/test/powershell/Language/Classes/Scripting.Classes.MiscOps.Tests.ps1
index 9cd054ea1b..0b7be62ebe 100644
--- a/test/powershell/Language/Classes/Scripting.Classes.MiscOps.Tests.ps1
+++ b/test/powershell/Language/Classes/Scripting.Classes.MiscOps.Tests.ps1
@@ -15,10 +15,10 @@ Describe 'Misc Test' -Tags "CI" {
         }
         }
         It 'Invoke Where' {
-                [C1]::new().Foo() | should be "1;2;3"
+                [C1]::new().Foo() | Should -Be "1;2;3"
         }
         It 'Pipe to where' {
-                [C1]::new().Bar() | should be "1;2;3"
+                [C1]::new().Bar() | Should -Be "1;2;3"
         }
     }
 
@@ -39,10 +39,10 @@ Describe 'Misc Test' -Tags "CI" {
         }
         }
         It 'Invoke Foreach' {
-                [C1]::new().Foo() | should be "1;2;3;"
+                [C1]::new().Foo() | Should -Be "1;2;3;"
         }
         It 'Pipe to Foreach' {
-                [C1]::new().Bar() | should be "1;2;3;"
+                [C1]::new().Bar() | Should -Be "1;2;3;"
         }
     }
 
@@ -78,7 +78,7 @@ Describe 'Misc Test' -Tags "CI" {
             function InstantiateInNewRunspace([Type]$type) {
                 try {
                     $result = $powershell.AddCommand("New-UnboundInstance").AddParameter("type", $type).Invoke()
-                    $result.Count | Should Be 1 > $null
+                    $result.Count | Should -Be 1
                     return $result[0]
                 } finally {
                     $powershell.Commands.Clear()
@@ -88,7 +88,7 @@ Describe 'Misc Test' -Tags "CI" {
             function RunFooInNewRunspace($instance) {
                 try {
                     $result = $powershell.AddCommand("Run-Foo").AddParameter("C1Instance", $instance).Invoke()
-                    $result.Count | Should Be 1 > $null
+                    $result.Count | Should -Be 1
                     return $result[0]
                 } finally {
                     $powershell.Commands.Clear()
@@ -104,16 +104,16 @@ Describe 'Misc Test' -Tags "CI" {
             $instance = [C1]::new()
             ## For a bound class instance, the execution of an instance method is
             ## done in the Runspace/SessionState the instance is bound to.
-            $instance.Foo() | Should Be $ExpectedTextFromBoundInstance
-            RunFooInNewRunspace $instance | Should Be $ExpectedTextFromBoundInstance
+            $instance.Foo() | Should -BeExactly $ExpectedTextFromBoundInstance
+            RunFooInNewRunspace $instance | Should -BeExactly $ExpectedTextFromBoundInstance
         }
 
         It "Create instance that is NOT bound to a SessionState" {
             $instance = InstantiateInNewRunspace ([C1])
             ## For an unbound class instance, the execution of an instance method is done in
             ## the Runspace/SessionState where the call to the instance method is made.
-            $instance.Foo() | Should Be $ExpectedTextFromBoundInstance
-            RunFooInNewRunspace $instance | Should Be $ExpectedTextFromUnboundInstance
+            $instance.Foo() | Should -BeExactly $ExpectedTextFromBoundInstance
+            RunFooInNewRunspace $instance | Should -BeExactly $ExpectedTextFromUnboundInstance
         }
     }
 }
diff --git a/test/powershell/Language/Classes/Scripting.Classes.Modules.Tests.ps1 b/test/powershell/Language/Classes/Scripting.Classes.Modules.Tests.ps1
index d28c898aa5..0bd882013b 100644
--- a/test/powershell/Language/Classes/Scripting.Classes.Modules.Tests.ps1
+++ b/test/powershell/Language/Classes/Scripting.Classes.Modules.Tests.ps1
@@ -3,7 +3,7 @@
 Describe 'PSModuleInfo.GetExportedTypeDefinitions()' -Tags "CI" {
     It "doesn't throw for any module" {
         $discard = Get-Module -ListAvailable | ForEach-Object { $_.GetExportedTypeDefinitions() }
-        $true | Should Be $true # we only verify that we didn't throw. This line contains a dummy Should to make pester happy.
+        $true | Should -BeTrue # we only verify that we didn't throw. This line contains a dummy Should to make pester happy.
     }
 }
 
@@ -26,7 +26,7 @@ Describe 'use of a module from two runspaces' -Tags "CI" {
         }
         New-ModuleManifest @manifestParams
 
-        if ($env:PSModulePath -notlike "*$TestModulePath*") {
+        if ($env:PSModulePath -NotLike "*$TestModulePath*") {
             $env:PSModulePath += "$([System.IO.Path]::PathSeparator)$TestModulePath"
         }
     }
@@ -62,10 +62,10 @@ Import-Module Random
                 }
             }
 
-            $res.Count | Should Be 4
-            $res[0] | Should Not Be $res[1]
-            $res[0] | Should Be $res[2]
-            $res[1] | Should Be $res[3]
+            $res.Count | Should -Be 4
+            $res[0] | Should -Not -Be $res[1]
+            $res[0] | Should -Be $res[2]
+            $res[1] | Should -Be $res[3]
         }
 
     } finally {
@@ -93,23 +93,23 @@ function Get-PassedArgsNoRoot { $passedArgs }
 
     It "Class execution reflects changes in module reloading with '-Force'" {
         Import-Module TestDrive:\TestModule.psm1 -ArgumentList $Arg_Hello
-        Get-PassedArgsRoot | Should Be $Arg_Hello
-        Get-PassedArgsNoRoot | Should Be $Arg_Hello
+        Get-PassedArgsRoot | Should -BeExactly $Arg_Hello
+        Get-PassedArgsNoRoot | Should -BeExactly $Arg_Hello
 
         Import-Module TestDrive:\TestModule.psm1 -ArgumentList $Arg_World -Force
-        Get-PassedArgsRoot | Should Be $Arg_World
-        Get-PassedArgsNoRoot | Should Be $Arg_World
+        Get-PassedArgsRoot | Should -BeExactly $Arg_World
+        Get-PassedArgsNoRoot | Should -BeExactly $Arg_World
     }
 
     It "Class execution reflects changes in module reloading with 'Remove-Module' and 'Import-Module'" {
         Import-Module TestDrive:\TestModule.psm1 -ArgumentList $Arg_Hello
-        Get-PassedArgsRoot | Should Be $Arg_Hello
-        Get-PassedArgsNoRoot | Should Be $Arg_Hello
+        Get-PassedArgsRoot | Should -BeExactly $Arg_Hello
+        Get-PassedArgsNoRoot | Should -BeExactly $Arg_Hello
 
         Remove-Module TestModule
 
         Import-Module TestDrive:\TestModule.psm1 -ArgumentList $Arg_World
-        Get-PassedArgsRoot | Should Be $Arg_World
-        Get-PassedArgsNoRoot | Should Be $Arg_World
+        Get-PassedArgsRoot | Should -BeExactly $Arg_World
+        Get-PassedArgsNoRoot | Should -BeExactly $Arg_World
     }
 }
diff --git a/test/powershell/Language/Classes/Scripting.Classes.RunPath.Tests.ps1 b/test/powershell/Language/Classes/Scripting.Classes.RunPath.Tests.ps1
index 7d88e5ccb7..85c78a7494 100644
--- a/test/powershell/Language/Classes/Scripting.Classes.RunPath.Tests.ps1
+++ b/test/powershell/Language/Classes/Scripting.Classes.RunPath.Tests.ps1
@@ -17,6 +17,6 @@ class MyClass { static [string]$MyProperty = 'Some value' }
 [MyClass]::MyProperty
 '@ | Out-File -FilePath $FilePath
 
-        ( . $FilePath ) | Should Match 'Some value'
+        ( . $FilePath ) | Should -Match 'Some value'
     }
 }
diff --git a/test/powershell/Language/Classes/Scripting.Classes.StaticMethod.Tests.ps1 b/test/powershell/Language/Classes/Scripting.Classes.StaticMethod.Tests.ps1
index 69619df096..687877c06a 100644
--- a/test/powershell/Language/Classes/Scripting.Classes.StaticMethod.Tests.ps1
+++ b/test/powershell/Language/Classes/Scripting.Classes.StaticMethod.Tests.ps1
@@ -13,7 +13,7 @@ Describe "Additional static method tests" -Tags "CI" {
                 static Foo() { [Foo]::Name = Get-Name }
             }
 
-            [Foo]::Name | Should Be "Yes"
+            [Foo]::Name | Should -Be "Yes"
         }
 
         It "test basic static method" {
@@ -21,7 +21,7 @@ Describe "Additional static method tests" -Tags "CI" {
                 static [string] GetName() { return (Get-Name) }
             }
 
-            [Foo]::GetName() | Should Be "Yes"
+            [Foo]::GetName() | Should -Be "Yes"
         }
     }
 
@@ -84,22 +84,22 @@ class Foo
             ## The static constructor is triggered by accessing '[Foo]::Name' which happens in the current Runspace.
             ## The class 'Foo' has been defined in the current Runspace, so it uses the current Runspace to run the
             ## static constructor.
-            [Foo]::Name | Should Be "Default Runspace - Name"
+            [Foo]::Name | Should -BeExactly "Default Runspace - Name"
 
             ## Static constructor runs only once, so accessing the Name property in the PS1 Runspace will just return
             ## the existing value.
-            RunScriptInPS -PowerShell $ps1 -Script "[Foo]::Name" | Should Be "Default Runspace - Name"
+            RunScriptInPS -PowerShell $ps1 -Script "[Foo]::Name" | Should -BeExactly "Default Runspace - Name"
         }
 
         It "Static method use the Runspace where the call happens if the class has been defined in that Runspace" {
 
             ## We call the static method in the current Runspace. The class 'Foo' has been defined
             ## in the current Runspace, so it will use it to run the method.
-            [Foo]::GetName() | Should Be "Default Runspace - AnotherName"
+            [Foo]::GetName() | Should -BeExactly "Default Runspace - AnotherName"
 
             ## We call the static method in PS1 Runspace. The class 'Foo' has been defined in the
             ## PS1 Runspace, so it will use it to run the method.
-            RunScriptInPS -PowerShell $ps1 -Script "[Foo]::GetName()" | Should Be 'PS1 Runspace - AnotherName'
+            RunScriptInPS -PowerShell $ps1 -Script "[Foo]::GetName()" | Should -BeExactly 'PS1 Runspace - AnotherName'
         }
 
         It "Static method use the default SessionState if it's called in a Runspace where the class is not defined" {
@@ -116,7 +116,7 @@ class Foo
             ## is always the one where the class was defined most recently. In this case, the class
             ## was lastly defined in PS1 Runspace, os the method will be invoked in PS1 Runspace.
             $result = $ps2.AddCommand("Call-GetName").AddParameter("type", [Foo]).Invoke()
-            $result | Should Be 'PS1 Runspace - AnotherName'
+            $result | Should -BeExactly 'PS1 Runspace - AnotherName'
         }
     }
 }
diff --git a/test/powershell/Language/Classes/scripting.Classes.NestedModules.tests.ps1 b/test/powershell/Language/Classes/scripting.Classes.NestedModules.tests.ps1
index b62f45311c..70089cb5f8 100644
--- a/test/powershell/Language/Classes/scripting.Classes.NestedModules.tests.ps1
+++ b/test/powershell/Language/Classes/scripting.Classes.NestedModules.tests.ps1
@@ -57,40 +57,40 @@ Describe 'NestedModules' -Tags "CI" {
 
         It 'Get-Module is able to find types' {
             $module = Get-Module NoRoot -ListAvailable
-            $module.GetExportedTypeDefinitions().Count | Should Be 1
+            $module.GetExportedTypeDefinitions().Count | Should -Be 1
 
             $module = Get-Module WithRoot -ListAvailable
-            $module.GetExportedTypeDefinitions().Count | Should Be 1
+            $module.GetExportedTypeDefinitions().Count | Should -Be 1
 
             $module = Get-Module ABC -ListAvailable
-            $module.GetExportedTypeDefinitions().Count | Should Be 3
+            $module.GetExportedTypeDefinitions().Count | Should -Be 3
         }
 
         It 'Import-Module pick the right type' {
             $module = Import-Module ABC -PassThru
-            $module.GetExportedTypeDefinitions().Count | Should Be 3
+            $module.GetExportedTypeDefinitions().Count | Should -Be 3
             $module = Import-Module ABC -PassThru -Force
-            $module.GetExportedTypeDefinitions().Count | Should Be 3
+            $module.GetExportedTypeDefinitions().Count | Should -Be 3
 
             $module = Import-Module NoRoot -PassThru
-            $module.GetExportedTypeDefinitions().Count | Should Be 1
+            $module.GetExportedTypeDefinitions().Count | Should -Be 1
             $module = Import-Module NoRoot -PassThru -Force
-            $module.GetExportedTypeDefinitions().Count | Should Be 1
+            $module.GetExportedTypeDefinitions().Count | Should -Be 1
             [scriptblock]::Create(@'
 using module NoRoot
 [A]::new().foo()
 '@
-).Invoke() | Should Be A2
+).Invoke() | Should -Be A2
 
             $module = Import-Module WithRoot -PassThru
-            $module.GetExportedTypeDefinitions().Count | Should Be 1
+            $module.GetExportedTypeDefinitions().Count | Should -Be 1
             $module = Import-Module WithRoot -PassThru -Force
-            $module.GetExportedTypeDefinitions().Count | Should Be 1
+            $module.GetExportedTypeDefinitions().Count | Should -Be 1
             [scriptblock]::Create(@'
 using module WithRoot
 [A]::new().foo()
 '@
-).Invoke() | Should Be A0
+).Invoke() | Should -Be A0
         }
 
         Context 'execute type creation in the module context' {
@@ -104,17 +104,17 @@ using module WithRoot
             # Currently, types are resolved in compile-time to the 'local' versions
             # So at runtime we don't call the module versions.
             It 'Can execute type creation in the module context with new()' -pending {
-                & (Get-Module ABC) { [C]::new().foo() } | Should Be C
-                & (Get-Module NoRoot) { [A]::new().foo() } | Should Be A2
-                & (Get-Module WithRoot) { [A]::new().foo() } | Should Be A0
-                & (Get-Module ABC) { [A]::new().foo() } | Should Be A
+                & (Get-Module ABC) { [C]::new().foo() } | Should -Be C
+                & (Get-Module NoRoot) { [A]::new().foo() } | Should -Be A2
+                & (Get-Module WithRoot) { [A]::new().foo() } | Should -Be A0
+                & (Get-Module ABC) { [A]::new().foo() } | Should -Be A
             }
 
             It 'Can execute type creation in the module context with New-Object' {
-                & (Get-Module ABC) { (New-Object C).foo() } | Should Be C
-                & (Get-Module NoRoot) { (New-Object A).foo() } | Should Be A2
-                & (Get-Module WithRoot) { (New-Object A).foo() } | Should Be A0
-                & (Get-Module ABC) { (New-Object A).foo() } | Should Be A
+                & (Get-Module ABC) { (New-Object C).foo() } | Should -Be C
+                & (Get-Module NoRoot) { (New-Object A).foo() } | Should -Be A2
+                & (Get-Module WithRoot) { (New-Object A).foo() } | Should -Be A0
+                & (Get-Module ABC) { (New-Object A).foo() } | Should -Be A
             }
         }
 
diff --git a/test/powershell/Language/Classes/scripting.Classes.inheritance.tests.ps1 b/test/powershell/Language/Classes/scripting.Classes.inheritance.tests.ps1
index e2dfc8d928..0295b53502 100644
--- a/test/powershell/Language/Classes/scripting.Classes.inheritance.tests.ps1
+++ b/test/powershell/Language/Classes/scripting.Classes.inheritance.tests.ps1
@@ -8,8 +8,8 @@ Describe 'Classes inheritance syntax' -Tags "CI" {
         class C2a : C1 {}
         class C2b:C1 {}
 
-        [C2a]::new().GetType().BaseType.Name | Should Be "C1"
-        [C2b].BaseType.Name | Should Be "C1"
+        [C2a]::new().GetType().BaseType.Name | Should -Be "C1"
+        [C2b].BaseType.Name | Should -Be "C1"
     }
 
     It 'inheritance from abstract base class with no abstract methods and protected ctor' {
@@ -43,13 +43,13 @@ Describe 'Classes inheritance syntax' -Tags "CI" {
                 }
             }
 
-        [C2a].GetInterface("System.IDisposable") | Should Not Be $null
-        [C2b].GetInterface("System.IDisposable") | Should Not Be $null
+        [C2a].GetInterface("System.IDisposable") | Should -Not -BeNullOrEmpty
+        [C2b].GetInterface("System.IDisposable") | Should -Not -BeNullOrEmpty
     }
 
     It 'can subclass .NET type' {
         class MyIntList : system.collections.generic.list[int] {}
-        [MyIntList]::new().GetType().BaseType.FullName.StartsWith('System.Collections.Generic.List') | Should Be $true
+        [MyIntList]::new().GetType().BaseType.FullName.StartsWith('System.Collections.Generic.List') | Should -BeTrue
     }
 
     It 'can implement .NET interface' {
@@ -60,19 +60,14 @@ Describe 'Classes inheritance syntax' -Tags "CI" {
                 return 0;
             }
         }
-        [MyComparable].GetInterface("System.IComparable") | Should Not Be $null
+        [MyComparable].GetInterface("System.IComparable") | Should -Not -BeNullOrEmpty
     }
 
     It 'allows use of defined later type as a property type' {
         class A { static [B]$b }
         class B : A {}
         [A]::b = [B]::new()
-        try {
-            [A]::b = "bla"
-            throw "No Exception!"
-        } catch {
-            $_.Exception | Should BeOfType 'System.Management.Automation.SetValueInvocationException'
-        }
+        { [A]::b = "bla" } | Should -Throw -ErrorId 'ExceptionWhenSetting'
     }
 }
 
@@ -123,7 +118,7 @@ Describe 'Classes methods with inheritance' -Tags "CI" {
                 [int]foo() {return 100500}
             }
             class baz : bar {}
-            [baz]::new().foo() | Should Be 100500
+            [baz]::new().foo() | Should -Be 100500
         }
 
         It 'can call static method on base class' {
@@ -132,7 +127,7 @@ Describe 'Classes methods with inheritance' -Tags "CI" {
                 static [int]foo() {return 100500}
             }
             class baz : bar {}
-            [baz]::foo() | Should Be 100500
+            [baz]::foo() | Should -Be 100500
         }
 
         It 'can access static and instance base class property' {
@@ -151,8 +146,8 @@ Describe 'Classes methods with inheritance' -Tags "CI" {
             }
             $b = [B]::new()
             $b.foo()
-            [A]::si | Should Be 1001
-            ($b.i) | Should Be 1003
+            [A]::si | Should -Be 1001
+            ($b.i) | Should -Be 1003
         }
 
         It 'works with .NET types' {
@@ -160,9 +155,9 @@ Describe 'Classes methods with inheritance' -Tags "CI" {
             $intList = [MyIntList]::new()
             $intList.Add(100501)
             $intList.Add(100502)
-            $intList.Count | Should Be 2
-            $intList[0] | Should Be 100501
-            $intList[1] | Should Be 100502
+            $intList.Count | Should -Be 2
+            $intList[0] | Should -Be 100501
+            $intList[1] | Should -Be 100502
         }
 
         It 'overrides instance method' {
@@ -174,7 +169,7 @@ Describe 'Classes methods with inheritance' -Tags "CI" {
             {
                 [int]foo() {return 200600}
             }
-            [baz]::new().foo() | Should Be 200600
+            [baz]::new().foo() | Should -Be 200600
         }
 
         It 'allows base class method call and doesn''t fall into recursion' {
@@ -196,7 +191,7 @@ Describe 'Classes methods with inheritance' -Tags "CI" {
             }
 
             $res = [baz]::new().foo()
-            $res | Should Be 3003
+            $res | Should -Be 3003
         }
 
         It 'case insensitive for base class method calls' {
@@ -218,7 +213,7 @@ Describe 'Classes methods with inheritance' -Tags "CI" {
             }
 
             $res = [baz]::new().foo()
-            $res | Should Be 2002
+            $res | Should -Be 2002
         }
 
         It 'allows any call from the inheritance hierarchy' {
@@ -240,11 +235,11 @@ Describe 'Classes methods with inheritance' -Tags "CI" {
             }
             $d = [D]::new()
 
-            ([A]$d).GetName() | Should Be "A"
-            ([B]$d).GetName() | Should Be "B"
-            ([C]$d).GetName() | Should Be "C"
-            ([D]$d).GetName() | Should Be "D"
-            $d.GetName() | Should Be "D"
+            ([A]$d).GetName() | Should -Be "A"
+            ([B]$d).GetName() | Should -Be "B"
+            ([C]$d).GetName() | Should -Be "C"
+            ([D]$d).GetName() | Should -Be "D"
+            $d.GetName() | Should -Be "D"
         }
 
         It 'can call base method with params' {
@@ -257,8 +252,8 @@ Describe 'Classes methods with inheritance' -Tags "CI" {
                 [string]ToStr([int]$a) {return "B" + $a}
             }
             $b = [B]::new()
-            ([A]$b).ToStr(101) | Should Be "A101"
-            $b.ToStr(100) | Should Be "B100"
+            ([A]$b).ToStr(101) | Should -Be "A101"
+            $b.ToStr(100) | Should -Be "B100"
         }
 
         It 'can call base method with many params' {
@@ -289,8 +284,8 @@ Describe 'Classes methods with inheritance' -Tags "CI" {
             # we don't really care about methods results, we only checks that calls doesn't throw
 
             # 14 args is a limit
-            $b.ToStr(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14) | Should Be 'B'
-            ([A]$b).ToStr(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14) | Should Be 'A'
+            $b.ToStr(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14) | Should -Be 'B'
+            ([A]$b).ToStr(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14) | Should -Be 'A'
 
             # 14 args is a limit
             $b.Noop(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14)
@@ -311,13 +306,13 @@ Describe 'Classes methods with inheritance' -Tags "CI" {
             }
             $b = [B]::new()
             ([A]$b).SetStr(101)
-            $script:voidOverrideVar | Should Be "A101"
+            $script:voidOverrideVar | Should -Be "A101"
             $b.SetStr(100)
-            $script:voidOverrideVar | Should Be "B100"
+            $script:voidOverrideVar | Should -Be "B100"
             ([A]$b).SetStr()
-            $script:voidOverrideVar | Should Be "A"
+            $script:voidOverrideVar | Should -Be "A"
             $b.SetStr()
-            $script:voidOverrideVar | Should Be "B"
+            $script:voidOverrideVar | Should -Be "B"
         }
 
         It 'hides final .NET method' {
@@ -332,8 +327,8 @@ Describe 'Classes methods with inheritance' -Tags "CI" {
 
             $intList = [MyIntList]::new()
             $intList.Add(100201)
-            $intList.Count | Should Be 1
-            $intList[0] | Should Be 200402
+            $intList.Count | Should -Be 1
+            $intList[0] | Should -Be 200402
         }
     }
 
@@ -352,11 +347,11 @@ Describe 'Classes methods with inheritance' -Tags "CI" {
         # MSFT:1911652
         # MSFT:2973835
         It 'doesn''t affect static method call on type' -Skip {
-            ([A]$b)::ToStr(101) | Should Be "A101"
+            ([A]$b)::ToStr(101) | Should -Be "A101"
         }
 
         It 'overrides static method call on instance' {
-            $b::ToStr(100) | Should Be "B100"
+            $b::ToStr(100) | Should -Be "B100"
         }
     }
 }
@@ -393,7 +388,7 @@ Describe 'Classes inheritance ctors' -Tags "CI" {
         }
 
         $b = [B]::new(101)
-        $b.a | Should Be 202
+        $b.a | Should -Be 202
     }
 
     # TODO: can we detect it in the parse time?
@@ -411,12 +406,7 @@ Describe 'Classes inheritance ctors' -Tags "CI" {
             B([int]$a) : base($a * 2, 100) {}
         }
 
-        try {
-            [B]::new(101)
-            throw "No Exception!"
-        } catch {
-            $_.Exception | Should BeOfType "System.Management.Automation.MethodException"
-        }
+        { [B]::new(101) } | Should -Throw -ErrorId "MethodCountCouldNotFindBest"
     }
 
     It 'call default base ctor implicitly' {
@@ -439,21 +429,14 @@ Describe 'Classes inheritance ctors' -Tags "CI" {
 
         $b = [B]::new()
         $c = [C]::new()
-        $b.a | Should Be 1007
-        $c.a | Should Be 1007
+        $b.a | Should -Be 1007
+        $c.a | Should -Be 1007
     }
 
     It 'doesn''t allow base ctor as an explicit method call' {
         $o = [object]::new()
-        try {
-            # we should not allow direct .ctor call.
-            $o.{.ctor}()
-        } catch {
-            $_.FullyQualifiedErrorId | Should Be MethodNotFound
-            return
-        }
-        # Fail
-        '' | Should Be "Exception expected"
+        # we should not allow direct .ctor call.
+        { $o.{.ctor}() } | Should -Throw -ErrorId "MethodNotFound"
     }
 
     It 'allow use conversion [string -> int] in base ctor call' {
@@ -471,7 +454,7 @@ Describe 'Classes inheritance ctors' -Tags "CI" {
         }
 
         $b = [B]::new()
-        $b.a | Should Be 103
+        $b.a | Should -Be 103
     }
 
     It 'resolves ctor call based on argument type' {
@@ -495,8 +478,8 @@ Describe 'Classes inheritance ctors' -Tags "CI" {
 
         $b1 = [B]::new("foo")
         $b2 = [B]::new(1001)
-        $b1.s | Should Be "foo"
-        $b2.i | Should Be 1001
+        $b1.s | Should -Be "foo"
+        $b2.i | Should -Be 1001
     }
 }
 
@@ -515,7 +498,7 @@ class Derived : Base
 
 [Derived]::new().foo()
 '@)
-        $sb.Invoke() | Should Be 200
-        $sb.Invoke() | Should Be 200
+        $sb.Invoke() | Should -Be 200
+        $sb.Invoke() | Should -Be 200
     }
 }
diff --git a/test/powershell/Language/Classes/scripting.Classes.using.tests.ps1 b/test/powershell/Language/Classes/scripting.Classes.using.tests.ps1
index 57c99f91e8..88b32b8c8e 100644
--- a/test/powershell/Language/Classes/scripting.Classes.using.tests.ps1
+++ b/test/powershell/Language/Classes/scripting.Classes.using.tests.ps1
@@ -41,7 +41,7 @@ Describe 'using module' -Tags "CI" {
 
         $module = Import-Module Foo  -PassThru
         try {
-            $module.ImplementingAssembly | Should Not Be $null
+            $module.ImplementingAssembly | Should -Not -BeNullOrEmpty
         } finally {
             $module | Remove-Module
         }
@@ -54,7 +54,7 @@ class Bar : Foo {}
 [Bar]
 "@).Invoke()
 
-        $barType.BaseType.Name | Should Be 'Foo'
+        $barType.BaseType.Name | Should -BeExactly 'Foo'
     }
 
     It "can use class from another module in New-Object" {
@@ -65,9 +65,9 @@ New-Object FooWithManifest.Foo
 New-Object Foo.Foo
 "@).Invoke()
 
-        $foo.Count | Should Be 2
-        $foo[0].GetModuleName() | Should Be 'FooWithManifest'
-        $foo[1].GetModuleName() | Should Be 'Foo'
+        $foo.Count | Should -Be 2
+        $foo[0].GetModuleName() | Should -BeExactly 'FooWithManifest'
+        $foo[1].GetModuleName() | Should -BeExactly 'Foo'
     }
 
     It "can use class from another module by full name as base class and [type]" {
@@ -76,7 +76,7 @@ using module Foo
 class Bar : Foo.Foo {}
 [Foo.Foo]::new()
 "@).Invoke()
-        $fooObject.GetModuleName() | Should Be 'Foo'
+        $fooObject.GetModuleName() | Should -BeExactly 'Foo'
     }
 
     It "can use modules with classes collision" {
@@ -99,11 +99,11 @@ class Bar : Foo {}
 (New-Object Foo).GetModuleName() # This
 "@).Invoke()
 
-        $fooModuleName.Count | Should Be 4
-        $fooModuleName[0] | Should Be 'Foo'
-        $fooModuleName[1] | Should Be 'FooWithManifest'
-        $fooModuleName[2] | Should Be 'This'
-        $fooModuleName[3] | Should Be 'This'
+        $fooModuleName.Count | Should -Be 4
+        $fooModuleName[0] | Should -BeExactly 'Foo'
+        $fooModuleName[1] | Should -BeExactly 'FooWithManifest'
+        $fooModuleName[2] | Should -BeExactly 'This'
+        $fooModuleName[3] | Should -BeExactly 'This'
     }
 
     It "doesn't mess up two consecutive scripts" {
@@ -121,8 +121,8 @@ class Bar : Foo {}
 [Bar]::new().GetModuleName()
 
 "@)
-        $sb1.Invoke() | Should Be 'Foo'
-        $sb2.Invoke() | Should Be 'This'
+        $sb1.Invoke() | Should -BeExactly 'Foo'
+        $sb2.Invoke() | Should -BeExactly 'This'
     }
 
     It "can use modules with classes collision simple" {
@@ -141,12 +141,12 @@ class Bar : Foo {}
 (New-Object Foo).GetModuleName() # This
 "@).Invoke()
 
-        $fooModuleName.Count | Should Be 5
-        $fooModuleName[0] | Should Be 'Foo'
-        $fooModuleName[1] | Should Be 'Foo'
-        $fooModuleName[2] | Should Be 'This'
-        $fooModuleName[3] | Should Be 'This'
-        $fooModuleName[4] | Should Be 'This'
+        $fooModuleName.Count | Should -Be 5
+        $fooModuleName[0] | Should -BeExactly 'Foo'
+        $fooModuleName[1] | Should -BeExactly 'Foo'
+        $fooModuleName[2] | Should -BeExactly 'This'
+        $fooModuleName[3] | Should -BeExactly 'This'
+        $fooModuleName[4] | Should -BeExactly 'This'
     }
 
     It "can use class from another module as a base class with using module with manifest" {
@@ -156,7 +156,7 @@ class Bar : Foo {}
 [Bar]
 "@).Invoke()
 
-        $barType.BaseType.Name | Should Be 'Foo'
+        $barType.BaseType.Name | Should -BeExactly 'Foo'
     }
 
     It "can instantiate class from another module" {
@@ -165,7 +165,7 @@ using module Foo
 [Foo]::new()
 "@).Invoke()
 
-        $foo.GetModuleName() | Should Be 'Foo'
+        $foo.GetModuleName() | Should -BeExactly 'Foo'
     }
 
     It "cannot instantiate class from another module without using statement" {
@@ -173,7 +173,7 @@ using module Foo
 #using module Foo
 [Foo]::new()
 "@
-        $err.FullyQualifiedErrorId | Should Be TypeNotFound
+        $err.FullyQualifiedErrorId | Should -BeExactly 'TypeNotFound'
     }
 
     It "can use class from another module in New-Object by short name" {
@@ -181,7 +181,7 @@ using module Foo
 using module FooWithManifest
 New-Object Foo
 "@).Invoke()
-        $foo.GetModuleName() | Should Be 'FooWithManifest'
+        $foo.GetModuleName() | Should -BeExactly 'FooWithManifest'
     }
 
     It "can use class from this module in New-Object by short name" {
@@ -189,7 +189,7 @@ New-Object Foo
 class Foo {}
 New-Object Foo
 "@).Invoke()
-        $foo | Should Not Be $null
+        $foo | Should -Not -BeNullOrEmpty
     }
 
     # Pending reason:
@@ -199,90 +199,90 @@ New-Object Foo
 using module @{ ModuleName = 'FooWithManifest'; ModuleVersion = '1.0' }
 New-Object Foo
 "@).Invoke()
-        $foo.GetModuleName() | Should Be 'FooWithManifest'
+        $foo.GetModuleName() | Should -BeExactly 'FooWithManifest'
     }
 
     Context 'parse time errors' {
 
         It "report an error about not found module" {
             $err = Get-ParseResults "using module ThisModuleDoesntExist"
-            $err.Count | Should Be 1
-            $err[0].ErrorId | Should Be 'ModuleNotFoundDuringParse'
+            $err.Count | Should -Be 1
+            $err[0].ErrorId | Should -BeExactly 'ModuleNotFoundDuringParse'
         }
 
         It "report an error about misformatted module specification" {
             $err = Get-ParseResults "using module @{ Foo = 'Foo' }"
-            $err.Count | Should Be 1
-            $err[0].ErrorId | Should Be 'RequiresModuleInvalid'
+            $err.Count | Should -Be 1
+            $err[0].ErrorId | Should -BeExactly 'RequiresModuleInvalid'
         }
 
         It "report an error about wildcard in the module name" {
             $err = Get-ParseResults "using module fo*"
-            $err.Count | Should Be 1
-            $err[0].ErrorId | Should Be 'WildCardModuleNameError'
+            $err.Count | Should -Be 1
+            $err[0].ErrorId | Should -BeExactly 'WildCardModuleNameError'
         }
 
         It "report an error about wildcard in the module path" {
             $err = Get-ParseResults "using module C:\fo*"
-            $err.Count | Should Be 1
-            $err[0].ErrorId | Should Be 'WildCardModuleNameError'
+            $err.Count | Should -Be 1
+            $err[0].ErrorId | Should -BeExactly 'WildCardModuleNameError'
         }
 
         It "report an error about wildcard in the module name inside ModuleSpecification hashtable" {
             $err = Get-ParseResults "using module @{ModuleName = 'Fo*'; RequiredVersion = '1.0'}"
-            $err.Count | Should Be 1
-            $err[0].ErrorId | Should Be 'WildCardModuleNameError'
+            $err.Count | Should -Be 1
+            $err[0].ErrorId | Should -BeExactly 'WildCardModuleNameError'
         }
 
         # MSFT:5246105
         It "report an error when tokenizer encounters comma" {
             $err = Get-ParseResults "using module ,FooWithManifest"
-            $err.Count | Should Be 1
-            $err[0].ErrorId | Should Be 'MissingUsingItemName'
+            $err.Count | Should -Be 1
+            $err[0].ErrorId | Should -BeExactly 'MissingUsingItemName'
         }
 
         It "report an error when tokenizer encounters nothing" {
             $err = Get-ParseResults "using module "
-            $err.Count | Should Be 1
-            $err[0].ErrorId | Should Be 'MissingUsingItemName'
+            $err.Count | Should -Be 1
+            $err[0].ErrorId | Should -BeExactly 'MissingUsingItemName'
         }
 
         It "report an error on badly formatted RequiredVersion" {
             $err = Get-ParseResults "using module @{ModuleName = 'FooWithManifest'; RequiredVersion = 1. }"
-            $err.Count | Should Be 1
-            $err[0].ErrorId | Should Be 'RequiresModuleInvalid'
+            $err.Count | Should -Be 1
+            $err[0].ErrorId | Should -BeExactly 'RequiresModuleInvalid'
         }
 
         # MSFT:6897275
         It "report an error on incomplete using input" {
             $err = Get-ParseResults "using module @{ModuleName = 'FooWithManifest'; FooWithManifest = 1." # missing closing bracket
-            $err.Count | Should Be 2
-            $err[0].ErrorId | Should Be 'MissingEndCurlyBrace'
-            $err[1].ErrorId | Should Be 'RequiresModuleInvalid'
+            $err.Count | Should -Be 2
+            $err[0].ErrorId | Should -BeExactly 'MissingEndCurlyBrace'
+            $err[1].ErrorId | Should -BeExactly 'RequiresModuleInvalid'
         }
 
         It "report an error when 'using module' terminating by NewLine" {
             $err = Get-ParseResults "using module"
-            $err.Count | Should Be 1
-            $err[0].ErrorId | Should Be 'MissingUsingItemName'
+            $err.Count | Should -Be 1
+            $err[0].ErrorId | Should -BeExactly 'MissingUsingItemName'
         }
 
         It "report an error when 'using module' terminating by Semicolon" {
             $err = Get-ParseResults "using module; $testvar=1"
-            $err.Count | Should Be 1
-            $err[0].ErrorId | Should Be 'MissingUsingItemName'
+            $err.Count | Should -Be 1
+            $err[0].ErrorId | Should -BeExactly 'MissingUsingItemName'
         }
 
         It "report an error when a value after 'using module' is a unallowed expression" {
             $err = Get-ParseResults "using module )"
-            $err.Count | Should Be 1
-            $err[0].ErrorId | Should Be 'InvalidValueForUsingItemName'
+            $err.Count | Should -Be 1
+            $err[0].ErrorId | Should -BeExactly 'InvalidValueForUsingItemName'
         }
 
         It "report an error when a value after 'using module' is not a valid module name" {
             $err = Get-ParseResults "using module 123"
-            $err.Count | Should Be 1
-            $err[0].ErrorId | Should Be 'InvalidValueForUsingItemName'
+            $err.Count | Should -Be 1
+            $err[0].ErrorId | Should -BeExactly 'InvalidValueForUsingItemName'
         }
     }
 
@@ -293,7 +293,7 @@ using module Foo
 using module FooWithManifest
 class Bar : Foo {}
 "@
-            $err.FullyQualifiedErrorId | Should Be AmbiguousTypeReference
+            $err.FullyQualifiedErrorId | Should -Be AmbiguousTypeReference
         }
 
         It "cannot use as [...]" {
@@ -302,7 +302,7 @@ using module Foo
 using module FooWithManifest
 [Foo]
 "@
-            $err.FullyQualifiedErrorId | Should Be AmbiguousTypeReference
+            $err.FullyQualifiedErrorId | Should -BeExactly 'AmbiguousTypeReference'
         }
 
         It "cannot use in New-Object" {
@@ -311,7 +311,7 @@ using module Foo
 using module FooWithManifest
 New-Object Foo
 "@
-            $err.FullyQualifiedErrorId | Should Be 'AmbiguousTypeReference,Microsoft.PowerShell.Commands.NewObjectCommand'
+            $err.FullyQualifiedErrorId | Should -BeExactly 'AmbiguousTypeReference,Microsoft.PowerShell.Commands.NewObjectCommand'
         }
 
         It "cannot use [type] cast from string" {
@@ -320,7 +320,7 @@ using module Foo
 using module FooWithManifest
 [type]"Foo"
 "@
-            $err.FullyQualifiedErrorId | Should Be AmbiguousTypeReference
+            $err.FullyQualifiedErrorId | Should -BeExactly 'AmbiguousTypeReference'
         }
     }
 
@@ -335,7 +335,7 @@ using module Foo
 [Foo]::new().GetModuleName()
 "@).Invoke()
 
-            $moduleName | Should Be 'Foo2'
+            $moduleName | Should -BeExactly 'Foo2'
         }
     }
 
@@ -357,7 +357,7 @@ using module Foo
 using module FooWithManifest
 [Foo]::new()
 "@).Invoke()
-            $foo.GetModuleName() | Should Be 'Foo230'
+            $foo.GetModuleName() | Should -BeExactly 'Foo230'
         }
 
         It "uses right version, when RequiredModule=1.0 specified" {
@@ -365,7 +365,7 @@ using module FooWithManifest
 using module @{ModuleName = 'FooWithManifest'; RequiredVersion = '1.0'}
 [Foo]::new()
 "@).Invoke()
-            $foo.GetModuleName() | Should Be 'FooWithManifest'
+            $foo.GetModuleName() | Should -BeExactly 'FooWithManifest'
         }
 
         It "uses right version, when RequiredModule=2.3.0 specified" {
@@ -373,7 +373,7 @@ using module @{ModuleName = 'FooWithManifest'; RequiredVersion = '1.0'}
 using module @{ModuleName = 'FooWithManifest'; RequiredVersion = '2.3.0'}
 [Foo]::new()
 "@).Invoke()
-            $foo.GetModuleName() | Should Be 'Foo230'
+            $foo.GetModuleName() | Should -BeExactly 'Foo230'
         }
 
         It "uses right version, when RequiredModule=3.4.5 specified" {
@@ -381,7 +381,7 @@ using module @{ModuleName = 'FooWithManifest'; RequiredVersion = '2.3.0'}
 using module @{ModuleName = 'FooWithManifest'; RequiredVersion = '3.4.5'}
 [Foo]::new()
 "@).Invoke()
-            $foo.GetModuleName() | Should Be 'Foo345'
+            $foo.GetModuleName() | Should -BeExactly 'Foo345'
         }
     }
 
@@ -399,7 +399,7 @@ using module ModuleWithRuntimeError
 [Foo]::new().GetModuleName()
 "@
 
-                $err | Should Be 'error'
+                $err | Should -Be 'error'
         }
     }
 
@@ -421,17 +421,17 @@ function foo()
             $iss.StartupScripts.Add($scriptToProcessPath)
 
             $ps = [powershell]::Create($iss)
-            $ps.AddCommand("foo").Invoke() | Should be Foo
-            $ps.Streams.Error | Should Be $null
+            $ps.AddCommand("foo").Invoke() | Should -BeExactly 'Foo'
+            $ps.Streams.Error | Should -BeNullOrEmpty
 
             $ps1 = [powershell]::Create($iss)
-            $ps1.AddCommand("foo").Invoke() | Should be Foo
-            $ps1.Streams.Error | Should Be $null
+            $ps1.AddCommand("foo").Invoke() | Should -BeExactly 'Foo'
+            $ps1.Streams.Error | Should -BeNullOrEmpty
 
             $ps.Commands.Clear()
             $ps.Streams.Error.Clear()
-            $ps.AddScript(". foo").Invoke() | Should be Foo
-            $ps.Streams.Error | Should Be $null
+            $ps.AddScript(". foo").Invoke() | Should -BeExactly 'Foo'
+            $ps.Streams.Error | Should -BeNullOrEmpty
         }
     }
 
@@ -457,17 +457,17 @@ class Bar : Foo {}
         }
 
         It 'use non-modified PSModulePath' {
-            $env:PSModulePath | Should Be $originalPSModulePath
+            $env:PSModulePath | Should -BeExactly $originalPSModulePath
         }
 
         It "can be accessed by relative path" {
             $barObject = & TestDrive:\FooRelativeConsumer\FooRelativeConsumer.ps1
-            $barObject.GetModuleName() | Should Be 'FooForPaths'
+            $barObject.GetModuleName() | Should -BeExactly 'FooForPaths'
         }
 
         It "cannot be accessed by relative path without .\ from a script" {
             $err = Get-RuntimeError '& TestDrive:\FooRelativeConsumerErr.ps1'
-            $err.FullyQualifiedErrorId | Should Be ModuleNotFoundDuringParse
+            $err.FullyQualifiedErrorId | Should -BeExactly 'ModuleNotFoundDuringParse'
         }
 
         It "can be accessed by absolute path" {
@@ -477,9 +477,9 @@ using module $resolvedTestDrivePath\FooForPaths
 [Foo]::new()
 "@
             $err = Get-ParseResults $s
-            $err.Count | Should Be 0
+            $err.Count | Should -Be 0
             $barObject = [scriptblock]::Create($s).Invoke()
-            $barObject.GetModuleName() | Should Be 'FooForPaths'
+            $barObject.GetModuleName() | Should -BeExactly 'FooForPaths'
         }
 
         It "can be accessed by absolute path with file extension" {
@@ -488,7 +488,7 @@ using module $resolvedTestDrivePath\FooForPaths
 using module $resolvedTestDrivePath\FooForPaths\FooForPaths.psm1
 [Foo]::new()
 "@).Invoke()
-            $barObject.GetModuleName() | Should Be 'FooForPaths'
+            $barObject.GetModuleName() | Should -BeExactly 'FooForPaths'
         }
 
         It "can be accessed by relative path without file" {
@@ -497,7 +497,7 @@ using module $resolvedTestDrivePath\FooForPaths\FooForPaths.psm1
 using module .\FooForPaths
 [Foo]::new()
 "@
-            $err.FullyQualifiedErrorId | Should Be ModuleNotFoundDuringParse
+            $err.FullyQualifiedErrorId | Should -BeExactly 'ModuleNotFoundDuringParse'
 
             Push-Location TestDrive:\modules
             try {
@@ -505,7 +505,7 @@ using module .\FooForPaths
 using module .\FooForPaths
 [Foo]::new()
 "@).Invoke()
-                $barObject.GetModuleName() | Should Be 'FooForPaths'
+                $barObject.GetModuleName() | Should -BeExactly 'FooForPaths'
             } finally {
                 Pop-Location
             }
@@ -518,7 +518,7 @@ using module .\FooForPaths
 using module FooForPaths
 [Foo]::new()
 "@
-                $err.FullyQualifiedErrorId | Should Be ModuleNotFoundDuringParse
+                $err.FullyQualifiedErrorId | Should -BeExactly 'ModuleNotFoundDuringParse'
             } finally {
                 Pop-Location
             }
@@ -543,7 +543,7 @@ class TestClass { [string] GetName() { return "TestClass" } }
 using module $testFile
 [TestClass]::new()
 "@).Invoke()
-            $result.GetName() | Should Be "TestClass"
+            $result.GetName() | Should -BeExactly "TestClass"
         }
     }
 }
diff --git a/test/powershell/Language/Classes/scripting.enums.tests.ps1 b/test/powershell/Language/Classes/scripting.enums.tests.ps1
index 7e6c3d3af8..02bb420e1e 100644
--- a/test/powershell/Language/Classes/scripting.enums.tests.ps1
+++ b/test/powershell/Language/Classes/scripting.enums.tests.ps1
@@ -10,11 +10,11 @@ Describe 'enums' -Tags "CI" {
             e2
         }
 
-        It "has correct value 0" { [E1]::e0 | Should Be ([E1]0) }
-        It "has correct value 1" { [E1]::e1 | Should Be ([E1]1) }
-        It "has correct value 2" { [E1]::e2 | Should Be ([E1]2) }
-        It "cast from string"    { [E1]::e1 | Should Be 'e1' }
-        It "cast to string"      { 'e2' | Should Be ([E1]::e2) }
+        It "has correct value 0" { [E1]::e0 | Should -Be ([E1]0) }
+        It "has correct value 1" { [E1]::e1 | Should -Be ([E1]1) }
+        It "has correct value 2" { [E1]::e2 | Should -Be ([E1]2) }
+        It "cast from string"    { [E1]::e1 | Should -Be 'e1' }
+        It "cast to string"      { 'e2' | Should -Be ([E1]::e2) }
     }
 
     Context 'Basic enum with initial value' {
@@ -25,11 +25,11 @@ Describe 'enums' -Tags "CI" {
             e2
         }
 
-        It "has correct value 0" { [E2]::e0 | Should Be ([E2]0) }
-        It "has correct value 5" { [E2]::e1 | Should Be ([E2]5) }
-        It "has correct value 6" { [E2]::e2 | Should Be ([E2]6) }
-        It "cast from string"    { [E2]::e1 | Should Be 'e1' }
-        It "cast to string"      { 'e2' | Should Be ([E2]::e2) }
+        It "has correct value 0" { [E2]::e0 | Should -Be ([E2]0) }
+        It "has correct value 5" { [E2]::e1 | Should -Be ([E2]5) }
+        It "has correct value 6" { [E2]::e2 | Should -Be ([E2]6) }
+        It "cast from string"    { [E2]::e1 | Should -Be 'e1' }
+        It "cast to string"      { 'e2' | Should -Be ([E2]::e2) }
     }
 
     Context 'Basic enum with initial value expression' {
@@ -41,12 +41,12 @@ Describe 'enums' -Tags "CI" {
             e3 = 1    # This shouldn't be an error even though previous member was max int
         }
 
-        It "has correct value 0"               { [E3]::e0 | Should Be ([E3]0) }
-        It "has correct value 5"               { [E3]::e1 | Should Be ([E3]5) }
-        It "has correct value [int]::MaxValue" { [E3]::e2 | Should Be ([E3]([int]::MaxValue)) }
-        It "has correct value 1"               { [E3]::e3 | Should Be ([E3]1) }
-        It "cast from string"                  { [E3]::e2 | Should Be 'e2' }
-        It "cast to string"                    { 'e3' | Should Be ([E3]::e3) }
+        It "has correct value 0"               { [E3]::e0 | Should -Be ([E3]0) }
+        It "has correct value 5"               { [E3]::e1 | Should -Be ([E3]5) }
+        It "has correct value [int]::MaxValue" { [E3]::e2 | Should -Be ([E3]([int]::MaxValue)) }
+        It "has correct value 1"               { [E3]::e3 | Should -Be ([E3]1) }
+        It "cast from string"                  { [E3]::e2 | Should -Be 'e2' }
+        It "cast to string"                    { 'e3' | Should -Be ([E3]::e3) }
     }
 
     Context 'Enum with complicated initial value' {
@@ -66,9 +66,9 @@ Describe 'enums' -Tags "CI" {
             e0 =38
         }
 
-        It 'E4 has correct value' { [E4]::e0 | Should Be ([E4]42) }
-        It 'E5 has correct value' { [E5]::e0 | Should Be ([E5]40) }
-        It 'E6 has correct value' { [E6]::e0 | Should Be ([E6]38) }
+        It 'E4 has correct value' { [E4]::e0 | Should -Be ([E4]42) }
+        It 'E5 has correct value' { [E5]::e0 | Should -Be ([E5]40) }
+        It 'E6 has correct value' { [E6]::e0 | Should -Be ([E6]38) }
     }
 }
 
diff --git a/test/powershell/Language/CompletionTestSupport.psm1 b/test/powershell/Language/CompletionTestSupport.psm1
index 71b4acc7b4..3490830c48 100644
--- a/test/powershell/Language/CompletionTestSupport.psm1
+++ b/test/powershell/Language/CompletionTestSupport.psm1
@@ -113,7 +113,7 @@ function Test-Completions
                         {
                             It "Checking for duplicates of: $($expected.CompletionText)" {
                                 # We should only find 1 of each expected result
-                                $expected.Found | Should Be $false
+                                $expected.Found | Should -BeFalse
                             }
                             $expected.Found = $true
                         }
@@ -123,7 +123,7 @@ function Test-Completions
                 foreach ($expected in $test.ExpectedResults)
                 {
                     It "Checking for presence of expected result: $($expected.CompletionText)" {
-                        $expected.Found | Should Be $true
+                        $expected.Found | Should -BeTrue
                     }
                 }
 
@@ -132,7 +132,7 @@ function Test-Completions
                     foreach ($result in $results.CompletionMatches)
                     {
                         It "Checking for results that should not be found: $notExpected" {
-                            $result.CompletionText -cne $notExpected | Should Be $true
+                            $result.CompletionText | Should -Not -Be $notExpected
                         }
                     }
                 }
diff --git a/test/powershell/Language/Interop/DotNet/DotNetAPI.Tests.ps1 b/test/powershell/Language/Interop/DotNet/DotNetAPI.Tests.ps1
index 75a2f426a4..f5e72690ad 100644
--- a/test/powershell/Language/Interop/DotNet/DotNetAPI.Tests.ps1
+++ b/test/powershell/Language/Interop/DotNet/DotNetAPI.Tests.ps1
@@ -5,23 +5,23 @@ Describe "DotNetAPI" -Tags "CI" {
     $posh_pi = 3.14159265358979
 
     It "Should be able to use static .NET classes and get a constant" {
-	[System.Math]::E  | Should Match $posh_E.ToString()
-	[System.Math]::PI | Should Match $posh_pi.ToString()
+	[System.Math]::E  | Should -Match $posh_E.ToString()
+	[System.Math]::PI | Should -Match $posh_pi.ToString()
     }
 
     It "Should be able to invoke a method" {
-	[System.Environment]::GetEnvironmentVariable("PATH") | Should Be $env:PATH
+	[System.Environment]::GetEnvironmentVariable("PATH") | Should -Be $env:PATH
     }
 
     It "Should not require 'system' in front of static classes" {
-	[Environment]::CommandLine | Should Be ([System.Environment]::CommandLine)
+	[Environment]::CommandLine | Should -Be ([System.Environment]::CommandLine)
 
-	[Math]::E | Should Be ([System.Math]::E)
+	[Math]::E | Should -Be ([System.Math]::E)
     }
 
     It "Should be able to create a new instance of a .Net object" {
 	[System.Guid]$guidVal = [System.Guid]::NewGuid()
 
-	$guidVal | Should BeOfType Guid
+	$guidVal | Should -BeOfType Guid
     }
 }
diff --git a/test/powershell/Language/Interop/DotNet/DotNetInterop.Tests.ps1 b/test/powershell/Language/Interop/DotNet/DotNetInterop.Tests.ps1
index fb1283287c..63884843a9 100644
--- a/test/powershell/Language/Interop/DotNet/DotNetInterop.Tests.ps1
+++ b/test/powershell/Language/Interop/DotNet/DotNetInterop.Tests.ps1
@@ -2,6 +2,6 @@
 # Licensed under the MIT License.
 Describe ".NET class interoperability" -Tags "CI" {
     It "Should access types in System.Console" {
-        [System.Console]::TreatControlCAsInput | Should Be $false
+        [System.Console]::TreatControlCAsInput | Should -BeFalse
     }
 }
diff --git a/test/powershell/Language/Operators/ComparisonOperator.Tests.ps1 b/test/powershell/Language/Operators/ComparisonOperator.Tests.ps1
index 06c78de8c0..92c5264194 100644
--- a/test/powershell/Language/Operators/ComparisonOperator.Tests.ps1
+++ b/test/powershell/Language/Operators/ComparisonOperator.Tests.ps1
@@ -21,7 +21,7 @@ Describe "ComparisonOperator" -tag "CI" {
         @{lhs = 0; operator = "-or"; rhs = 0; result = $false}
     ) {
         param($lhs, $operator, $rhs, $result)
-	    Invoke-Expression "$lhs $operator $rhs" | Should Be $result
+	    Invoke-Expression "$lhs $operator $rhs" | Should -Be $result
     }
 
 	It "Should be <result> for <operator> <rhs>" -TestCases @(
@@ -33,7 +33,7 @@ Describe "ComparisonOperator" -tag "CI" {
         @{operator = "!"; rhs = "0"; result = $true}
     ) {
         param($operator, $rhs, $result)
-        Invoke-Expression "$operator$rhs" | Should Be $result
+        Invoke-Expression "$operator$rhs" | Should -Be $result
     }
 
 	It "Should be <result> for <lhs> <operator> <rhs>" -TestCases @(
@@ -48,7 +48,7 @@ Describe "ComparisonOperator" -tag "CI" {
         @{lhs = "'Hello world'"; operator = "-notlike"; rhs = "'Hello*'"; result = $false}
     ) {
         param($lhs, $operator, $rhs, $result)
-        Invoke-Expression "$lhs $operator $rhs" | Should Be $result
+        Invoke-Expression "$lhs $operator $rhs" | Should -Be $result
     }
 
     It "Should return error if right hand is not a valid type: 'hello' <operator> <type>" -TestCases @(
@@ -71,7 +71,7 @@ Describe "ComparisonOperator" -tag "CI" {
         @{lhs = '"hello"'; operator = '-isnot'; rhs = "[int]"}
     ) {
         param($lhs, $operator, $rhs)
-        Invoke-Expression "$lhs $operator $rhs" | Should Be $true
+        Invoke-Expression "$lhs $operator $rhs" | Should -BeTrue
     }
 
     It "Should fail in comparing type: <lhs> <operator> <rhs>" -TestCases @(
@@ -80,7 +80,7 @@ Describe "ComparisonOperator" -tag "CI" {
         @{lhs = '"hello"'; operator = '-isnot'; rhs = "[string]"}
     ) {
         param($lhs, $operator, $rhs)
-        Invoke-Expression "$lhs $operator $rhs" | Should Be $false
+        Invoke-Expression "$lhs $operator $rhs" | Should -BeFalse
     }
 }
 
@@ -89,36 +89,36 @@ Describe "Bytewise Operator" -tag "CI" {
     It "Test -bor on enum with [byte] as underlying type" {
         $result = [System.Security.AccessControl.AceFlags]::ObjectInherit -bxor `
                   [System.Security.AccessControl.AceFlags]::ContainerInherit
-        $result.ToString() | Should Be "ObjectInherit, ContainerInherit"
+        $result.ToString() | Should -BeExactly "ObjectInherit, ContainerInherit"
     }
 
     It "Test -bor on enum with [int] as underlying type" {
         $result = [System.Management.Automation.CommandTypes]::Alias -bor `
                   [System.Management.Automation.CommandTypes]::Application
-        $result.ToString() | Should Be "Alias, Application"
+        $result.ToString() | Should -BeExactly "Alias, Application"
     }
 
     It "Test -band on enum with [byte] as underlying type" {
         $result = [System.Security.AccessControl.AceFlags]::ObjectInherit -band `
                   [System.Security.AccessControl.AceFlags]::ContainerInherit
-        $result.ToString() | Should Be "None"
+        $result.ToString() | Should -BeExactly "None"
     }
 
     It "Test -band on enum with [int] as underlying type" {
         $result = [System.Management.Automation.CommandTypes]::Alias -band `
                   [System.Management.Automation.CommandTypes]::All
-        $result.ToString() | Should Be "Alias"
+        $result.ToString() | Should -BeExactly "Alias"
     }
 
     It "Test -bxor on enum with [byte] as underlying type" {
         $result = [System.Security.AccessControl.AceFlags]::ObjectInherit -bxor `
                   [System.Security.AccessControl.AceFlags]::ContainerInherit
-        $result.ToString() | Should Be "ObjectInherit, ContainerInherit"
+        $result.ToString() | Should -BeExactly "ObjectInherit, ContainerInherit"
     }
 
     It "Test -bxor on enum with [int] as underlying type" {
         $result = [System.Management.Automation.CommandTypes]::Alias -bxor `
                   [System.Management.Automation.CommandTypes]::Application
-        $result.ToString() | Should Be "Alias, Application"
+        $result.ToString() | Should -BeExactly "Alias, Application"
     }
 }
diff --git a/test/powershell/Language/Operators/RangeOperator.Tests.ps1 b/test/powershell/Language/Operators/RangeOperator.Tests.ps1
index d847422be4..01ca4627e2 100644
--- a/test/powershell/Language/Operators/RangeOperator.Tests.ps1
+++ b/test/powershell/Language/Operators/RangeOperator.Tests.ps1
@@ -4,255 +4,255 @@ Describe "Range Operator" -Tags CI {
     Context "Range integer operations" {
         It "Range operator generates arrays of integers" {
             $Range = 5..8
-            $Range.count | Should Be 4
-            $Range[0] | Should BeOfType [int]
-            $Range[1] | Should BeOfType [int]
-            $Range[2] | Should BeOfType [int]
-            $Range[3] | Should BeOfType [int]
+            $Range.count | Should -Be 4
+            $Range[0] | Should -BeOfType [int]
+            $Range[1] | Should -BeOfType [int]
+            $Range[2] | Should -BeOfType [int]
+            $Range[3] | Should -BeOfType [int]
 
-            $Range[0] | Should Be 5
-            $Range[1] | Should Be 6
-            $Range[2] | Should Be 7
-            $Range[3] | Should Be 8
+            $Range[0] | Should -Be 5
+            $Range[1] | Should -Be 6
+            $Range[2] | Should -Be 7
+            $Range[3] | Should -Be 8
         }
 
         It "Range operator accepts negative integer values" {
             $Range = -8..-5
-            $Range.count | Should Be 4
-            $Range[0] | Should Be -8
-            $Range[1] | Should Be -7
-            $Range[2] | Should Be -6
-            $Range[3] | Should Be -5
+            $Range.count | Should -Be 4
+            $Range[0] | Should -Be -8
+            $Range[1] | Should -Be -7
+            $Range[2] | Should -Be -6
+            $Range[3] | Should -Be -5
         }
 
         It "Range operator support single-item sequences" {
             $Range = 0..0
-            $Range.count | Should Be 1
-            $Range[0] | Should BeOfType [int]
-            $Range[0] | Should Be 0
+            $Range.count | Should -Be 1
+            $Range[0] | Should -BeOfType [int]
+            $Range[0] | Should -Be 0
         }
 
         It "Range operator works in descending order" {
             $Range = 4..3
-            $Range.count | Should Be 2
-            $Range[0] | Should Be 4
-            $Range[1] | Should Be 3
+            $Range.count | Should -Be 2
+            $Range[0] | Should -Be 4
+            $Range[1] | Should -Be 3
         }
 
         It "Range operator works for sequences of both negative and positive numbers" {
             $Range = -2..2
-            $Range.count | Should Be 5
-            $Range[0] | Should Be -2
-            $Range[1] | Should Be -1
-            $Range[2] | Should Be 0
-            $Range[3] | Should Be 1
-            $Range[4] | Should Be 2
+            $Range.count | Should -Be 5
+            $Range[0] | Should -Be -2
+            $Range[1] | Should -Be -1
+            $Range[2] | Should -Be 0
+            $Range[3] | Should -Be 1
+            $Range[4] | Should -Be 2
         }
 
         It "Range operator enumerator works" {
             $Range = -2..2 | ForEach-Object { $_ }
-            $Range.count | Should Be 5
-            $Range[0] | Should Be -2
-            $Range[1] | Should Be -1
-            $Range[2] | Should Be 0
-            $Range[3] | Should Be 1
-            $Range[4] | Should Be 2
+            $Range.count | Should -Be 5
+            $Range[0] | Should -Be -2
+            $Range[1] | Should -Be -1
+            $Range[2] | Should -Be 0
+            $Range[3] | Should -Be 1
+            $Range[4] | Should -Be 2
         }
 
         It "Range operator works with variables" {
             $var1 = -1
             $var2 = 1
             $Range = $var1..$var2
-            $Range.count | Should Be 3
-            $Range[0] | Should Be -1
-            $Range[1] | Should Be 0
-            $Range[2] | Should Be 1
+            $Range.count | Should -Be 3
+            $Range[0] | Should -Be -1
+            $Range[1] | Should -Be 0
+            $Range[2] | Should -Be 1
 
             $Range = [int]$var2..[int]$var1
-            $Range.count | Should Be 3
-            $Range[0] | Should Be 1
-            $Range[1] | Should Be 0
-            $Range[2] | Should Be -1
+            $Range.count | Should -Be 3
+            $Range[0] | Should -Be 1
+            $Range[1] | Should -Be 0
+            $Range[2] | Should -Be -1
 
             $Range = $var1..$var2 | ForEach-Object { $_ }
-            $Range.count | Should Be 3
-            $Range[0] | Should Be -1
-            $Range[1] | Should Be 0
-            $Range[2] | Should Be 1
+            $Range.count | Should -Be 3
+            $Range[0] | Should -Be -1
+            $Range[1] | Should -Be 0
+            $Range[2] | Should -Be 1
 
             $Range = [int]$var2..[int]$var1 | ForEach-Object { $_ }
-            $Range.count | Should Be 3
-            $Range[0] | Should Be 1
-            $Range[1] | Should Be 0
-            $Range[2] | Should Be -1
+            $Range.count | Should -Be 3
+            $Range[0] | Should -Be 1
+            $Range[1] | Should -Be 0
+            $Range[2] | Should -Be -1
         }
     }
 
     Context "Character expansion" {
         It "Range operator generates an array of [char] from single-character operands" {
             $CharRange = 'A'..'E'
-            $CharRange.count | Should Be 5
-            $CharRange[0] | Should BeOfType [char]
-            $CharRange[1] | Should BeOfType [char]
-            $CharRange[2] | Should BeOfType [char]
-            $CharRange[3] | Should BeOfType [char]
-            $CharRange[4] | Should BeOfType [char]
+            $CharRange.count | Should -Be 5
+            $CharRange[0] | Should -BeOfType [char]
+            $CharRange[1] | Should -BeOfType [char]
+            $CharRange[2] | Should -BeOfType [char]
+            $CharRange[3] | Should -BeOfType [char]
+            $CharRange[4] | Should -BeOfType [char]
         }
 
         It "Range operator enumerator generates an array of [string] from single-character operands" {
             $CharRange = 'A'..'E' | ForEach-Object { $_ }
-            $CharRange.count | Should Be 5
-            $CharRange[0] | Should BeOfType [char]
-            $CharRange[1] | Should BeOfType [char]
-            $CharRange[2] | Should BeOfType [char]
-            $CharRange[3] | Should BeOfType [char]
-            $CharRange[4] | Should BeOfType [char]
+            $CharRange.count | Should -Be 5
+            $CharRange[0] | Should -BeOfType [char]
+            $CharRange[1] | Should -BeOfType [char]
+            $CharRange[2] | Should -BeOfType [char]
+            $CharRange[3] | Should -BeOfType [char]
+            $CharRange[4] | Should -BeOfType [char]
         }
 
         It "Range operator works in ascending and descending order" {
             $CharRange = 'a'..'c'
-            $CharRange.count | Should Be 3
-            $CharRange[0] | Should BeExactly ([char]'a')
-            $CharRange[1] | Should BeExactly ([char]'b')
-            $CharRange[2] | Should BeExactly ([char]'c')
+            $CharRange.count | Should -Be 3
+            $CharRange[0] | Should -BeExactly ([char]'a')
+            $CharRange[1] | Should -BeExactly ([char]'b')
+            $CharRange[2] | Should -BeExactly ([char]'c')
 
             $CharRange = 'C'..'A'
-            $CharRange.count | Should Be 3
-            $CharRange[0] | Should BeExactly ([char]'C')
-            $CharRange[1] | Should BeExactly ([char]'B')
-            $CharRange[2] | Should BeExactly ([char]'A')
+            $CharRange.count | Should -Be 3
+            $CharRange[0] | Should -BeExactly ([char]'C')
+            $CharRange[1] | Should -BeExactly ([char]'B')
+            $CharRange[2] | Should -BeExactly ([char]'A')
         }
 
         It "Range operator works in ascending and descending order with [char] cast" {
             $CharRange = [char]'a'..[char]'c'
-            $CharRange.count | Should Be 3
-            $CharRange[0] | Should BeExactly ([char]'a')
-            $CharRange[1] | Should BeExactly ([char]'b')
-            $CharRange[2] | Should BeExactly ([char]'c')
+            $CharRange.count | Should -Be 3
+            $CharRange[0] | Should -BeExactly ([char]'a')
+            $CharRange[1] | Should -BeExactly ([char]'b')
+            $CharRange[2] | Should -BeExactly ([char]'c')
 
             $CharRange = [char]"a".."c"
-            $CharRange.count | Should Be 3
-            $CharRange[0] | Should BeExactly ([char]'a')
-            $CharRange[1] | Should BeExactly ([char]'b')
-            $CharRange[2] | Should BeExactly ([char]'c')
+            $CharRange.count | Should -Be 3
+            $CharRange[0] | Should -BeExactly ([char]'a')
+            $CharRange[1] | Should -BeExactly ([char]'b')
+            $CharRange[2] | Should -BeExactly ([char]'c')
 
             $CharRange = "a"..[char]"c"
-            $CharRange.count | Should Be 3
-            $CharRange[0] | Should BeExactly ([char]'a')
-            $CharRange[1] | Should BeExactly ([char]'b')
-            $CharRange[2] | Should BeExactly ([char]'c')
+            $CharRange.count | Should -Be 3
+            $CharRange[0] | Should -BeExactly ([char]'a')
+            $CharRange[1] | Should -BeExactly ([char]'b')
+            $CharRange[2] | Should -BeExactly ([char]'c')
 
             # The same works in reverse order.
             $CharRange = [char]'C'..[char]'A'
-            $CharRange.count | Should Be 3
-            $CharRange[0] | Should BeExactly ([char]'C')
-            $CharRange[1] | Should BeExactly ([char]'B')
-            $CharRange[2] | Should BeExactly ([char]'A')
+            $CharRange.count | Should -Be 3
+            $CharRange[0] | Should -BeExactly ([char]'C')
+            $CharRange[1] | Should -BeExactly ([char]'B')
+            $CharRange[2] | Should -BeExactly ([char]'A')
 
             $CharRange = [char]"C".."A"
-            $CharRange.count | Should Be 3
-            $CharRange[0] | Should BeExactly ([char]'C')
-            $CharRange[1] | Should BeExactly ([char]'B')
-            $CharRange[2] | Should BeExactly ([char]'A')
+            $CharRange.count | Should -Be 3
+            $CharRange[0] | Should -BeExactly ([char]'C')
+            $CharRange[1] | Should -BeExactly ([char]'B')
+            $CharRange[2] | Should -BeExactly ([char]'A')
 
             $CharRange = "C"..[char]"A"
-            $CharRange.count | Should Be 3
-            $CharRange[0] | Should BeExactly ([char]'C')
-            $CharRange[1] | Should BeExactly ([char]'B')
-            $CharRange[2] | Should BeExactly ([char]'A')
+            $CharRange.count | Should -Be 3
+            $CharRange[0] | Should -BeExactly ([char]'C')
+            $CharRange[1] | Should -BeExactly ([char]'B')
+            $CharRange[2] | Should -BeExactly ([char]'A')
         }
 
         It "Range operator enumerator works in ascending and descending order" {
             $CharRange = 'a'..'c' | ForEach-Object { $_ }
-            $CharRange.count | Should Be 3
-            $CharRange[0] | Should BeExactly "a"
-            $CharRange[1] | Should BeExactly "b"
-            $CharRange[2] | Should BeExactly "c"
+            $CharRange.count | Should -Be 3
+            $CharRange[0] | Should -BeExactly "a"
+            $CharRange[1] | Should -BeExactly "b"
+            $CharRange[2] | Should -BeExactly "c"
 
             $CharRange = 'C'..'A' | ForEach-Object { $_ }
-            $CharRange.count | Should Be 3
-            $CharRange[0] | Should BeExactly "C"
-            $CharRange[1] | Should BeExactly "B"
-            $CharRange[2] | Should BeExactly "A"
+            $CharRange.count | Should -Be 3
+            $CharRange[0] | Should -BeExactly "C"
+            $CharRange[1] | Should -BeExactly "B"
+            $CharRange[2] | Should -BeExactly "A"
         }
 
         It "Range operator enumerator works in ascending and descending order with [char] cast" {
             $CharRange = [char]'a'..[char]'c' | ForEach-Object { $_ }
-            $CharRange.count | Should Be 3
-            $CharRange[0] | Should BeExactly "a"
-            $CharRange[1] | Should BeExactly "b"
-            $CharRange[2] | Should BeExactly "c"
+            $CharRange.count | Should -Be 3
+            $CharRange[0] | Should -BeExactly "a"
+            $CharRange[1] | Should -BeExactly "b"
+            $CharRange[2] | Should -BeExactly "c"
 
             $CharRange = [char]'C'..[char]'A' | ForEach-Object { $_ }
-            $CharRange.count | Should Be 3
-            $CharRange[0] | Should BeExactly "C"
-            $CharRange[1] | Should BeExactly "B"
-            $CharRange[2] | Should BeExactly "A"
+            $CharRange.count | Should -Be 3
+            $CharRange[0] | Should -BeExactly "C"
+            $CharRange[1] | Should -BeExactly "B"
+            $CharRange[2] | Should -BeExactly "A"
         }
 
         It "Range operator works with variables" {
             $var1 = 'a'
             $var2 = 'c'
             $CharRange = $var1..$var2
-            $CharRange.count | Should Be 3
-            $CharRange[0] | Should BeExactly "a"
-            $CharRange[1] | Should BeExactly "b"
-            $CharRange[2] | Should BeExactly "c"
+            $CharRange.count | Should -Be 3
+            $CharRange[0] | Should -BeExactly "a"
+            $CharRange[1] | Should -BeExactly "b"
+            $CharRange[2] | Should -BeExactly "c"
 
             $CharRange = [char]$var2..[char]$var1
-            $CharRange.count | Should Be 3
-            $CharRange[0] | Should BeExactly "c"
-            $CharRange[1] | Should BeExactly "b"
-            $CharRange[2] | Should BeExactly "a"
+            $CharRange.count | Should -Be 3
+            $CharRange[0] | Should -BeExactly "c"
+            $CharRange[1] | Should -BeExactly "b"
+            $CharRange[2] | Should -BeExactly "a"
 
             $CharRange = $var1..$var2 | ForEach-Object { $_ }
-            $CharRange.count | Should Be 3
-            $CharRange[0] | Should BeExactly "a"
-            $CharRange[1] | Should BeExactly "b"
-            $CharRange[2] | Should BeExactly "c"
+            $CharRange.count | Should -Be 3
+            $CharRange[0] | Should -BeExactly "a"
+            $CharRange[1] | Should -BeExactly "b"
+            $CharRange[2] | Should -BeExactly "c"
 
             $CharRange = [char]$var2..[char]$var1 | ForEach-Object { $_ }
-            $CharRange.count | Should Be 3
-            $CharRange[0] | Should BeExactly "c"
-            $CharRange[1] | Should BeExactly "b"
-            $CharRange[2] | Should BeExactly "a"
+            $CharRange.count | Should -Be 3
+            $CharRange[0] | Should -BeExactly "c"
+            $CharRange[1] | Should -BeExactly "b"
+            $CharRange[2] | Should -BeExactly "a"
         }
 
         It "Range operator works with 16-bit unicode characters" {
             $UnicodeRange = "`u{0110}".."`u{0114}"
-            $UnicodeRange.count | Should Be 5
-            $UnicodeRange[0] | Should Be "`u{0110}"[0]
-            $UnicodeRange[1] | Should Be "`u{0111}"[0]
-            $UnicodeRange[2] | Should Be "`u{0112}"[0]
-            $UnicodeRange[3] | Should Be "`u{0113}"[0]
-            $UnicodeRange[4] | Should Be "`u{0114}"[0]
-            $UnicodeRange.Where({$_ -is [char]}).count | Should Be 5
+            $UnicodeRange.count | Should -Be 5
+            $UnicodeRange[0] | Should -Be "`u{0110}"[0]
+            $UnicodeRange[1] | Should -Be "`u{0111}"[0]
+            $UnicodeRange[2] | Should -Be "`u{0112}"[0]
+            $UnicodeRange[3] | Should -Be "`u{0113}"[0]
+            $UnicodeRange[4] | Should -Be "`u{0114}"[0]
+            $UnicodeRange.Where({$_ -is [char]}).count | Should -Be 5
         }
 
         It "Range operator with special ranges" {
             $SpecRange = "0".."9"
-            $SpecRange.count | Should Be 10
-            $SpecRange.Where({$_ -is [int]}).count | Should Be 10
+            $SpecRange.count | Should -Be 10
+            $SpecRange.Where({$_ -is [int]}).count | Should -Be 10
 
             $SpecRange = '0'..'9'
-            $SpecRange.count | Should Be 10
-            $SpecRange.Where({$_ -is [int]}).count | Should Be 10
+            $SpecRange.count | Should -Be 10
+            $SpecRange.Where({$_ -is [int]}).count | Should -Be 10
 
             $SpecRange = [char]'0'..[char]'9'
-            $SpecRange.count | Should Be 10
-            $SpecRange.Where({$_ -is [char]}).count | Should Be 10
+            $SpecRange.count | Should -Be 10
+            $SpecRange.Where({$_ -is [char]}).count | Should -Be 10
         }
     }
 
     Context "Range operator operand types" {
         It "Range operator works on [decimal]" {
             $Range = 1.1d..3.9d
-            $Range.count | Should Be 4
-            $Range[0] | Should Be 1
-            $Range[1] | Should Be 2
-            $Range[2] | Should Be 3
-            $Range[3] | Should Be 4
-            $Range.Where({$_ -is [int]}).count | Should Be 4
+            $Range.count | Should -Be 4
+            $Range[0] | Should -Be 1
+            $Range[1] | Should -Be 2
+            $Range[2] | Should -Be 3
+            $Range[3] | Should -Be 4
+            $Range.Where({$_ -is [int]}).count | Should -Be 4
         }
     }
 }
diff --git a/test/powershell/Language/Operators/SplitOperator.Tests.ps1 b/test/powershell/Language/Operators/SplitOperator.Tests.ps1
index 907ebf18b7..25514c9a75 100644
--- a/test/powershell/Language/Operators/SplitOperator.Tests.ps1
+++ b/test/powershell/Language/Operators/SplitOperator.Tests.ps1
@@ -4,105 +4,105 @@ Describe "Split Operator" -Tags CI {
     Context "Binary split operator" {
         It "Binary split operator can split array of value" {
             $res = "a b", "c d" -split " "
-            $res.count | Should Be 4
-            $res[0] | Should Be "a"
-            $res[1] | Should Be "b"
-            $res[2] | Should Be "c"
-            $res[3] | Should Be "d"
+            $res.count | Should -Be 4
+            $res[0] | Should -Be "a"
+            $res[1] | Should -Be "b"
+            $res[2] | Should -Be "c"
+            $res[3] | Should -Be "d"
         }
 
         It "Binary split operator can split a string" {
             $res = "a b c d" -split " "
-            $res.count | Should Be 4
-            $res[0] | Should Be "a"
-            $res[1] | Should Be "b"
-            $res[2] | Should Be "c"
-            $res[3] | Should Be "d"
+            $res.count | Should -Be 4
+            $res[0] | Should -Be "a"
+            $res[1] | Should -Be "b"
+            $res[2] | Should -Be "c"
+            $res[3] | Should -Be "d"
         }
 
         It "Binary split operator can works with max substring limit" {
             $res = "a b c d" -split " ", 2
-            $res.count | Should Be 2
-            $res[0] | Should Be "a"
-            $res[1] | Should Be "b c d"
+            $res.count | Should -Be 2
+            $res[0] | Should -Be "a"
+            $res[1] | Should -Be "b c d"
 
             $res = "a b c d" -split " ", 0
-            $res.count | Should Be 4
-            $res[0] | Should Be "a"
-            $res[1] | Should Be "b"
-            $res[2] | Should Be "c"
-            $res[3] | Should Be "d"
+            $res.count | Should -Be 4
+            $res[0] | Should -Be "a"
+            $res[1] | Should -Be "b"
+            $res[2] | Should -Be "c"
+            $res[3] | Should -Be "d"
 
             $res = "a b c d" -split " ", -1
-            $res.count | Should Be 4
-            $res[0] | Should Be "a"
-            $res[1] | Should Be "b"
-            $res[2] | Should Be "c"
-            $res[3] | Should Be "d"
+            $res.count | Should -Be 4
+            $res[0] | Should -Be "a"
+            $res[1] | Should -Be "b"
+            $res[2] | Should -Be "c"
+            $res[3] | Should -Be "d"
         }
 
         It "Binary split operator can works with freeform delimiter" {
             $res = "a::b::c::d" -split "::"
-            $res.count | Should Be 4
-            $res[0] | Should Be "a"
-            $res[1] | Should Be "b"
-            $res[2] | Should Be "c"
-            $res[3] | Should Be "d"
+            $res.count | Should -Be 4
+            $res[0] | Should -Be "a"
+            $res[1] | Should -Be "b"
+            $res[2] | Should -Be "c"
+            $res[3] | Should -Be "d"
         }
 
         It "Binary split operator can preserve delimiter" {
             $res = "a1:b1:c1:d" -split "(1:)"
-            $res.count | Should Be 7
-            $res[0] | Should Be "a"
-            $res[1] | Should Be "1:"
-            $res[2] | Should Be "b"
-            $res[3] | Should Be "1:"
-            $res[4] | Should Be "c"
-            $res[5] | Should Be "1:"
-            $res[6] | Should Be "d"
+            $res.count | Should -Be 7
+            $res[0] | Should -Be "a"
+            $res[1] | Should -Be "1:"
+            $res[2] | Should -Be "b"
+            $res[3] | Should -Be "1:"
+            $res[4] | Should -Be "c"
+            $res[5] | Should -Be "1:"
+            $res[6] | Should -Be "d"
 
             $res = "a1:b1:c1:d" -split "1(:)"
-            $res.count | Should Be 7
-            $res[0] | Should Be "a"
-            $res[1] | Should Be ":"
-            $res[2] | Should Be "b"
-            $res[3] | Should Be ":"
-            $res[4] | Should Be "c"
-            $res[5] | Should Be ":"
-            $res[6] | Should Be "d"
+            $res.count | Should -Be 7
+            $res[0] | Should -Be "a"
+            $res[1] | Should -Be ":"
+            $res[2] | Should -Be "b"
+            $res[3] | Should -Be ":"
+            $res[4] | Should -Be "c"
+            $res[5] | Should -Be ":"
+            $res[6] | Should -Be "d"
         }
 
         It "Binary split operator can be case-insensitive and case-sensitive" {
             $res = "abcBd" -split "B"
-            $res.count | Should Be 3
-            $res[0] | Should Be "a"
-            $res[1] | Should Be "c"
-            $res[2] | Should Be "d"
+            $res.count | Should -Be 3
+            $res[0] | Should -Be "a"
+            $res[1] | Should -Be "c"
+            $res[2] | Should -Be "d"
 
             $res = "abcBd" -isplit "B"
-            $res.count | Should Be 3
-            $res[0] | Should Be "a"
-            $res[1] | Should Be "c"
-            $res[2] | Should Be "d"
+            $res.count | Should -Be 3
+            $res[0] | Should -Be "a"
+            $res[1] | Should -Be "c"
+            $res[2] | Should -Be "d"
 
             $res = "abcBd" -csplit "B"
-            $res.count | Should Be 2
-            $res[0] | Should Be "abc"
-            $res[1] | Should Be "d"
+            $res.count | Should -Be 2
+            $res[0] | Should -Be "abc"
+            $res[1] | Should -Be "d"
 
             $res = "abcBd" -csplit "B", 0 , 'IgnoreCase'
-            $res.count | Should Be 3
-            $res[0] | Should Be "a"
-            $res[1] | Should Be "c"
-            $res[2] | Should Be "d"
+            $res.count | Should -Be 3
+            $res[0] | Should -Be "a"
+            $res[1] | Should -Be "c"
+            $res[2] | Should -Be "d"
         }
 
         It "Binary split operator can works with script block" {
             $res = "a::b::c::d" -split {$_ -eq "b" -or $_ -eq "C"}
-            $res.count | Should Be 3
-            $res[0] | Should Be "a::"
-            $res[1] | Should Be "::"
-            $res[2] | Should Be "::d"
+            $res.count | Should -Be 3
+            $res[0] | Should -Be "a::"
+            $res[1] | Should -Be "::"
+            $res[2] | Should -Be "::d"
         }
 
     }
@@ -120,93 +120,93 @@ Describe "Split Operator" -Tags CI {
             param($testText, $testText2, $newLine)
             # Multiline isn't default
             $res = $testText -split '^b'
-            $res.count | Should Be 1
+            $res.count | Should -Be 1
 
             # Singleline isn't default
             $res = $testText -split 'b.+c'
-            $res.count | Should Be 1
+            $res.count | Should -Be 1
         }
 
         It "Binary split operator works with Singleline (new line = '<Name>')" -TestCases $testCases {
             param($testText, $testText2, $newLine)
             $res = $testText -split 'b.+c', 0, 'Singleline'
-            $res.count | Should Be 2
-            $res[0] | Should Be "a12a$($newLine)"
-            $res[1] | Should Be "$($newLine)d78d"
+            $res.count | Should -Be 2
+            $res[0] | Should -Be "a12a$($newLine)"
+            $res[1] | Should -Be "$($newLine)d78d"
 
             $res = $testText2 -split 'b.+c', 0, 'Singleline'
-            $res.count | Should Be 2
-            $res[0] | Should Be "a12a$($newLine)%"
-            $res[1] | Should Be "$($newLine)d78d"
+            $res.count | Should -Be 2
+            $res[0] | Should -Be "a12a$($newLine)%"
+            $res[1] | Should -Be "$($newLine)d78d"
         }
 
         It "Binary split operator works with Multiline (new line = '<Name>')" -TestCases $testCases {
             param($testText, $testText2, $newLine)
             $res = $testText -split '^b', 0, 'Multiline'
-            $res.count | Should Be 2
-            $res[0] | Should Be "a12a$($newLine)"
-            $res[1] | Should Be "34b$($newLine)c56c$($newLine)d78d"
+            $res.count | Should -Be 2
+            $res[0] | Should -Be "a12a$($newLine)"
+            $res[1] | Should -Be "34b$($newLine)c56c$($newLine)d78d"
         }
 
         It "Binary split operator works with Singleline,Multiline (new line = '<Name>')" -TestCases $testCases {
             param($testText, $testText2, $newLine)
             $res = $testText -split 'b.+c', 0, 'Singleline,Multiline'
-            $res.count | Should Be 2
-            $res[0] | Should Be "a12a$($newLine)"
-            $res[1] | Should Be "$($newLine)d78d"
+            $res.count | Should -Be 2
+            $res[0] | Should -Be "a12a$($newLine)"
+            $res[1] | Should -Be "$($newLine)d78d"
 
             $res = $testText2 -split 'b.+c', 0, 'Singleline,Multiline'
-            $res.count | Should Be 2
-            $res[0] | Should Be "a12a$($newLine)%"
-            $res[1] | Should Be "$($newLine)d78d"
+            $res.count | Should -Be 2
+            $res[0] | Should -Be "a12a$($newLine)%"
+            $res[1] | Should -Be "$($newLine)d78d"
 
             $res = $testText -split '^b.+c', 0, 'Singleline,Multiline'
-            $res.count | Should Be 2
-            $res[0] | Should Be "a12a$($newLine)"
-            $res[1] | Should Be "$($newLine)d78d"
+            $res.count | Should -Be 2
+            $res[0] | Should -Be "a12a$($newLine)"
+            $res[1] | Should -Be "$($newLine)d78d"
 
             $res = $testText2 -split '^b.+c', 0, 'Singleline,Multiline'
-            $res.count | Should Be 1
+            $res.count | Should -Be 1
         }
 
         It "Binary split operator works with IgnorePatternWhitespace" {
             $res = "a: b:c" -split ': '
-            $res.count | Should Be 2
-            $res[0] | Should Be "a"
-            $res[1] | Should Be "b:c"
+            $res.count | Should -Be 2
+            $res[0] | Should -Be "a"
+            $res[1] | Should -Be "b:c"
 
             $res = "a: b:c" -split ': ',0,'IgnorePatternWhitespace'
-            $res.count | Should Be 3
-            $res[0] | Should Be "a"
-            $res[1] | Should Be " b"
-            $res[2] | Should Be "c"
+            $res.count | Should -Be 3
+            $res[0] | Should -Be "a"
+            $res[1] | Should -Be " b"
+            $res[2] | Should -Be "c"
         }
 
         It "Binary split operator works with ExplicitCapture" {
             $res = "a:b" -split "(:)"
-            $res.count | Should Be 3
-            $res[0] | Should Be "a"
-            $res[1] | Should Be ":"
-            $res[2] | Should Be "b"
+            $res.count | Should -Be 3
+            $res[0] | Should -Be "a"
+            $res[1] | Should -Be ":"
+            $res[2] | Should -Be "b"
 
             $res = "a:b" -split "(:)", 0, 'ExplicitCapture'
-            $res.count | Should Be 2
-            $res[0] | Should Be "a"
-            $res[1] | Should Be "b"
+            $res.count | Should -Be 2
+            $res[0] | Should -Be "a"
+            $res[1] | Should -Be "b"
         }
 
         It "Binary split operator works with SimpleMatch" {
             $res = "abc" -split "B", 0, 'SimpleMatch,IgnoreCase'
-            $res.count | Should Be 2
-            $res[0] | Should Be "a"
-            $res[1] | Should Be "c"
+            $res.count | Should -Be 2
+            $res[0] | Should -Be "a"
+            $res[1] | Should -Be "c"
         }
 
         It "Binary split operator works with RegexMatch" {
             $res = "abc" -split "B", 0, 'RegexMatch,Singleline'
-            $res.count | Should Be 2
-            $res[0] | Should Be "a"
-            $res[1] | Should Be "c"
+            $res.count | Should -Be 2
+            $res[0] | Should -Be "a"
+            $res[1] | Should -Be "c"
         }
 
         It "Binary split operator doesn't works with RegexMatch,SimpleMatch" {
@@ -217,28 +217,28 @@ Describe "Split Operator" -Tags CI {
     Context "Unary split operator" {
         It "Unary split operator has higher precedence than a comma" {
             $res = -split "a b", "c d"
-            $res.count | Should Be 2
-            $res[0][0] | Should Be "a"
-            $res[0][1] | Should Be "b"
-            $res[1] | Should Be "c d"
+            $res.count | Should -Be 2
+            $res[0][0] | Should -Be "a"
+            $res[0][1] | Should -Be "b"
+            $res[1] | Should -Be "c d"
         }
 
         It "Unary split operator can split array of values" {
             $res = -split ("a b", "c d")
-            $res.count | Should Be 4
-            $res[0] | Should Be "a"
-            $res[1] | Should Be "b"
-            $res[2] | Should Be "c"
-            $res[3] | Should Be "d"
+            $res.count | Should -Be 4
+            $res[0] | Should -Be "a"
+            $res[1] | Should -Be "b"
+            $res[2] | Should -Be "c"
+            $res[3] | Should -Be "d"
         }
 
         It "Unary split operator can split a string" {
             $res = -split "a b c d"
-            $res.count | Should Be 4
-            $res[0] | Should Be "a"
-            $res[1] | Should Be "b"
-            $res[2] | Should Be "c"
-            $res[3] | Should Be "d"
+            $res.count | Should -Be 4
+            $res[0] | Should -Be "a"
+            $res[1] | Should -Be "b"
+            $res[2] | Should -Be "c"
+            $res[3] | Should -Be "d"
         }
     }
 }
diff --git a/test/powershell/Language/Parser/Ast.Tests.ps1 b/test/powershell/Language/Parser/Ast.Tests.ps1
index ca87e3b500..1f8ee598e0 100644
--- a/test/powershell/Language/Parser/Ast.Tests.ps1
+++ b/test/powershell/Language/Parser/Ast.Tests.ps1
@@ -7,36 +7,23 @@ Describe "The SafeGetValue method on AST returns safe values" -Tags "CI" {
         $HtAst = {
             @{ one = 1 }
             }.ast.Find({$args[0] -is $HashtableAstType}, $true)
-        $HtAst | Should Not BeNullOrEmpty
-        $HtAst.SafeGetValue() | Should BeOfType "Hashtable"
+        $HtAst | Should -Not -BeNullOrEmpty
+        $HtAst.SafeGetValue() | Should -BeOfType "Hashtable"
     }
     It "An Array is returned from a LiteralArrayAst" {
         $ArrayAstType = [ArrayLiteralAst]
         $ArrayAst = {
             @( 1,2,3,4)
             }.ast.Find({$args[0] -is $ArrayAstType}, $true)
-        $ArrayAst | Should Not BeNullOrEmpty
-        ,$ArrayAst.SafeGetValue() | Should BeOfType "Object[]"
+        $ArrayAst | Should -Not -BeNullOrEmpty
+        ,$ArrayAst.SafeGetValue() | Should -BeOfType "Object[]"
     }
     It "The proper error is returned when a variable is referenced" {
         $ast = { $a }.Ast.Find({$args[0] -is "VariableExpressionAst"},$true)
-        try {
-            $ast.SafeGetValue() | out-null
-            throw "No Exception!"
-        }
-        catch {
-            $_.FullyQualifiedErrorId | Should be "InvalidOperationException"
-            $_.ToString() | Should Match '\$a'
-        }
+        { $ast.SafeGetValue() } | Should -Throw -ErrorId "InvalidOperationException"
     }
     It "A ScriptBlock AST fails with the proper error" {
-        try {
-            { 1 }.Ast.SafeGetValue()
-            throw "No Exception!"
-        }
-        catch {
-            $_.FullyQualifiedErrorId | Should be "InvalidOperationException"
-        }
+        { { 1 }.Ast.SafeGetValue() } | Should -Throw -ErrorId "InvalidOperationException"
     }
 
 }
diff --git a/test/powershell/Language/Parser/AutomaticVariables.Tests.ps1 b/test/powershell/Language/Parser/AutomaticVariables.Tests.ps1
index 40e4752091..8265178de5 100644
--- a/test/powershell/Language/Parser/AutomaticVariables.Tests.ps1
+++ b/test/powershell/Language/Parser/AutomaticVariables.Tests.ps1
@@ -9,15 +9,15 @@ Describe 'Automatic variable $input' -Tags "CI" {
         function from_process { [cmdletbinding()]param() process { Write-Output -NoEnumerate $input } }
         function from_end { [cmdletbinding()]param() end { Write-Output -NoEnumerate $input } }
 
-        (from_begin) -is [System.Collections.IEnumerator] | Should Be $true
-        (from_process) -is [System.Collections.IEnumerator] | Should Be $true
-        (from_end) -is [System.Collections.IEnumerator] | Should Be $true
+        (from_begin) -is [System.Collections.IEnumerator] | Should -BeTrue
+        (from_process) -is [System.Collections.IEnumerator] | Should -BeTrue
+        (from_end) -is [System.Collections.IEnumerator] | Should -BeTrue
     }
 
     It 'Empty $input really is empty' {
-        & { @($input).Count } | Should Be 0
-        & { [cmdletbinding()]param() begin { @($input).Count } } | Should Be 0
-        & { [cmdletbinding()]param() process { @($input).Count } } | Should Be 0
-        & { [cmdletbinding()]param() end { @($input).Count } } | Should Be 0
+        & { @($input).Count } | Should -Be 0
+        & { [cmdletbinding()]param() begin { @($input).Count } } | Should -Be 0
+        & { [cmdletbinding()]param() process { @($input).Count } } | Should -Be 0
+        & { [cmdletbinding()]param() end { @($input).Count } } | Should -Be 0
     }
 }
diff --git a/test/powershell/Language/Parser/BNotOperator.Tests.ps1 b/test/powershell/Language/Parser/BNotOperator.Tests.ps1
index 3dc9be6c14..0b5e4c1bbd 100644
--- a/test/powershell/Language/Parser/BNotOperator.Tests.ps1
+++ b/test/powershell/Language/Parser/BNotOperator.Tests.ps1
@@ -39,26 +39,26 @@ Describe "bnot on enums" -Tags "CI" {
         Context $enumType.Name {
             It "max - 1" {
                 $res = -bnot $enumType::MaxMinus1
-                $res | Should Be $enumType::MinPlus1
-                $res | Should BeOfType $enumType
+                $res | Should -Be $enumType::MinPlus1
+                $res | Should -BeOfType $enumType
             }
 
             It "min + 1" {
                 $res = -bnot $enumType::MinPlus1
-                $res | Should Be $enumType::MaxMinus1
-                $res | Should BeOfType $enumType
+                $res | Should -Be $enumType::MaxMinus1
+                $res | Should -BeOfType $enumType
             }
 
             It "Max" {
                 $res = -bnot $enumType::Max
-                $res | Should Be $enumType::Min
-                $res | Should BeOfType $enumType
+                $res | Should -Be $enumType::Min
+                $res | Should -BeOfType $enumType
             }
 
             It "Min" {
                 $res = -bnot $enumType::Min
-                $res | Should Be $enumType::Max
-                $res | Should BeOfType $enumType
+                $res | Should -Be $enumType::Max
+                $res | Should -BeOfType $enumType
             }
         }
     }
@@ -90,52 +90,52 @@ Describe "bnot on integral types" -Tags "CI" {
                 # tests are a little different.
                 It "max - 1" {
                     $res = -bnot $maxMinus1
-                    $res | Should Be (-bnot [int]$maxMinus1)
-                    $res | Should BeOfType $expectedResultType
+                    $res | Should -Be (-bnot [int]$maxMinus1)
+                    $res | Should -BeOfType $expectedResultType
                 }
 
                 It "min + 1" {
                     $res = -bnot $minPlus1
-                    $res | Should Be (-bnot [int]$minPlus1)
-                    $res | Should BeOfType $expectedResultType
+                    $res | Should -Be (-bnot [int]$minPlus1)
+                    $res | Should -BeOfType $expectedResultType
                 }
 
                 It "max" {
                     $res = -bnot $max
-                    $res | Should Be (-bnot [int]$max)
-                    $res | Should BeOfType $expectedResultType
+                    $res | Should -Be (-bnot [int]$max)
+                    $res | Should -BeOfType $expectedResultType
                 }
 
                 It "min" {
                     $res = -bnot $min
-                    $res | Should Be (-bnot [int]$min)
-                    $res | Should BeOfType $expectedResultType
+                    $res | Should -Be (-bnot [int]$min)
+                    $res | Should -BeOfType $expectedResultType
                 }
                 return
             }
 
             It "max - 1" {
                 $res = -bnot $maxMinus1
-                $res | Should Be $minPlus1
-                $res | Should BeOfType $expectedResultType
+                $res | Should -Be $minPlus1
+                $res | Should -BeOfType $expectedResultType
             }
 
             It "min + 1" {
                 $res = -bnot $minPlus1
-                $res | Should Be $maxMinus1
-                $res | Should BeOfType $expectedResultType
+                $res | Should -Be $maxMinus1
+                $res | Should -BeOfType $expectedResultType
             }
 
             It "max" {
                 $res = -bnot $max
-                $res | Should Be $min
-                $res | Should BeOfType $expectedResultType
+                $res | Should -Be $min
+                $res | Should -BeOfType $expectedResultType
             }
 
             It "min" {
                 $res = -bnot $min
-                $res | Should Be $max
-                $res | Should BeOfType $expectedResultType
+                $res | Should -Be $max
+                $res | Should -BeOfType $expectedResultType
             }
         }
     }
diff --git a/test/powershell/Language/Parser/Conversions.Tests.ps1 b/test/powershell/Language/Parser/Conversions.Tests.ps1
index 5cade9d22e..fbc0aee7eb 100644
--- a/test/powershell/Language/Parser/Conversions.Tests.ps1
+++ b/test/powershell/Language/Parser/Conversions.Tests.ps1
@@ -6,21 +6,21 @@ Describe 'conversion syntax' -Tags "CI" {
 
     It 'converts array of single enum to bool' {
         # This test relies on the fact that [ConsoleColor]::Black is 0 and all other values are non-zero
-        [bool]@([ConsoleColor]::Black) | Should Be $false
-        [bool]@([ConsoleColor]::Yellow) | Should Be $true
+        [bool]@([ConsoleColor]::Black) | Should -BeFalse
+        [bool]@([ConsoleColor]::Yellow) | Should -BeTrue
     }
 
     It 'calls virtual method non-virtually' {
-        ([object]"abc").ToString() | Should Be "System.String"
+        ([object]"abc").ToString() | Should -Be "System.String"
 
         # generate random string to avoid JIT optimization
         $r = [guid]::NewGuid().Guid
-        ([object]($r + "a")).Equals(($r + "a")) | Should Be $false
+        ([object]($r + "a")).Equals(($r + "a")) | Should -BeFalse
     }
 
     It 'calls method on a super-type, when conversion syntax used' {
         # This test relies on the fact that there are overloads (at least 2) for ToString method.
-        ([System.Management.Automation.ActionPreference]"Stop").ToString() | Should Be "Stop"
+        ([System.Management.Automation.ActionPreference]"Stop").ToString() | Should -Be "Stop"
     }
 
     Context "Cast object[] to more narrow generic collection" {
@@ -63,15 +63,15 @@ Describe 'conversion syntax' -Tags "CI" {
             $result = $null
             . $Command
 
-            $result | Should Not BeNullOrEmpty
-            $result.GetType().Name | Should Be $CollectionType
+            $result | Should -Not -BeNullOrEmpty
+            $result.GetType().Name | Should -Be $CollectionType
 
             $genericArgs = $result.GetType().GetGenericArguments()
-            $genericArgs.Length | Should Be 1
-            $genericArgs[0].Name | Should Be $ElementType
+            $genericArgs.Length | Should -Be 1
+            $genericArgs[0].Name | Should -Be $ElementType
 
-            $result.Count | Should Be $Elements.Length
-            $result -join ";" | Should Be ($Elements -join ";")
+            $result.Count | Should -Be $Elements.Length
+            $result -join ";" | Should -Be ($Elements -join ";")
         }
     }
 }
@@ -126,7 +126,7 @@ namespace TestTypeResolution {
             [TestTypeResolution.TestTypeFoo].Assembly.Location
 "@
         $location = & $powershell -noprofile -command $command
-        $location | Should Be $cmdletDllPath
+        $location | Should -Be $cmdletDllPath
     }
 }
 
@@ -221,179 +221,179 @@ Describe 'method conversion' -Tags 'CI' {
     }
 
     It 'converts static method as Func does not throw' {
-        {[Func[int, int]] [M]::Thrice} | Should Not Throw
+        {[Func[int, int]] [M]::Thrice} | Should -Not -Throw
     }
 
     It 'converts static method as Func is non null' {
-        ([Func[int, int]] [M]::Thrice) | Should Not BeNullOrEmpty
+        ([Func[int, int]] [M]::Thrice) | Should -Not -BeNullOrEmpty
     }
 
     It 'calls static method as Func' {
         $f = [Func[int, int]] [M]::Thrice
-        [M]::Apply(1, $f) | Should be 3
+        [M]::Apply(1, $f) | Should -Be 3
     }
 
     It 'calls static method as Func' {
         $f = [Func[int, int16, int]] [M]::Add
-        [M]::Apply(3, 4, $f) | Should be 7
+        [M]::Apply(3, 4, $f) | Should -Be 7
     }
 
     It 'calls static method as Func no cast' {
-        [M]::Apply(3, 4, [M]::Add) | Should be 7
+        [M]::Apply(3, 4, [M]::Add) | Should -Be 7
     }
 
     It 'converts instance psmethodinfo to Func' {
         $m = [M]::new()
-        {[Func[int, int]] $m.Twice} | Should Not Throw
+        {[Func[int, int]] $m.Twice} | Should -Not -Throw
 
         $f = [Func[int, int16, int]] [M]::Add
-        $f.Invoke(2, 6) | Should be 8
+        $f.Invoke(2, 6) | Should -Be 8
     }
     It "can call all overloads of M::Foo" {
         [Func[char, char]] $f1 = [M]::Foo
-        $f1.Invoke(10) | Should BE 10
+        $f1.Invoke(10) | Should -Be 10
         [Func[char, char, char]] $f2 = [M]::Foo
-        $f2.Invoke(10, 1) | Should BE 10
+        $f2.Invoke(10, 1) | Should -Be 10
         [Func[char, char, char, char]] $f3 = [M]::Foo
-        $f3.Invoke(10, 1, 2) | Should BE 10
+        $f3.Invoke(10, 1, 2) | Should -Be 10
         [Func[char, char, char, char, char]] $f4 = [M]::Foo
-        $f4.Invoke(10, 1, 2, 3) | Should BE 10
+        $f4.Invoke(10, 1, 2, 3) | Should -Be 10
         [Func[char, char, char, char, char, char]] $f5 = [M]::Foo
-        $f5.Invoke(10, 1, 2, 3, 4) | Should BE 10
+        $f5.Invoke(10, 1, 2, 3, 4) | Should -Be 10
         [Func[char, char, char, char, char, char, char]] $f6 = [M]::Foo
-        $f6.Invoke(10, 1, 2, 3, 4, 5) | Should BE 10
+        $f6.Invoke(10, 1, 2, 3, 4, 5) | Should -Be 10
         [Func[char, char, char, char, char, char, char, char]] $f7 = [M]::Foo
-        $f7.Invoke(10, 1, 2, 3, 4, 5, 6) | Should BE 10
+        $f7.Invoke(10, 1, 2, 3, 4, 5, 6) | Should -Be 10
         [Func[char, char, char, char, char, char, char, char, char]] $f8 = [M]::Foo
-        $f8.Invoke(10, 1, 2, 3, 4, 5, 6, 7) | Should BE 10
+        $f8.Invoke(10, 1, 2, 3, 4, 5, 6, 7) | Should -Be 10
         [Func[int16, int16]] $f9 = [M]::Foo
-        $f9.Invoke(10) | Should BE 10
+        $f9.Invoke(10) | Should -Be 10
         [Func[int16, int16, int16]] $f10 = [M]::Foo
-        $f10.Invoke(10, 1) | Should BE 10
+        $f10.Invoke(10, 1) | Should -Be 10
         [Func[int16, int16, int16, int16]] $f11 = [M]::Foo
-        $f11.Invoke(10, 1, 2) | Should BE 10
+        $f11.Invoke(10, 1, 2) | Should -Be 10
         [Func[int16, int16, int16, int16, int16]] $f12 = [M]::Foo
-        $f12.Invoke(10, 1, 2, 3) | Should BE 10
+        $f12.Invoke(10, 1, 2, 3) | Should -Be 10
         [Func[int16, int16, int16, int16, int16, int16]] $f13 = [M]::Foo
-        $f13.Invoke(10, 1, 2, 3, 4) | Should BE 10
+        $f13.Invoke(10, 1, 2, 3, 4) | Should -Be 10
         [Func[int16, int16, int16, int16, int16, int16, int16]] $f14 = [M]::Foo
-        $f14.Invoke(10, 1, 2, 3, 4, 5) | Should BE 10
+        $f14.Invoke(10, 1, 2, 3, 4, 5) | Should -Be 10
         [Func[int16, int16, int16, int16, int16, int16, int16, int16]] $f15 = [M]::Foo
-        $f15.Invoke(10, 1, 2, 3, 4, 5, 6) | Should BE 10
+        $f15.Invoke(10, 1, 2, 3, 4, 5, 6) | Should -Be 10
         [Func[int16, int16, int16, int16, int16, int16, int16, int16, int16]] $f16 = [M]::Foo
-        $f16.Invoke(10, 1, 2, 3, 4, 5, 6, 7) | Should BE 10
+        $f16.Invoke(10, 1, 2, 3, 4, 5, 6, 7) | Should -Be 10
         [Func[int, int]] $f17 = [M]::Foo
-        $f17.Invoke(10) | Should BE 10
+        $f17.Invoke(10) | Should -Be 10
         [Func[int, int, int]] $f18 = [M]::Foo
-        $f18.Invoke(10, 1) | Should BE 10
+        $f18.Invoke(10, 1) | Should -Be 10
         [Func[int, int, int, int]] $f19 = [M]::Foo
-        $f19.Invoke(10, 1, 2) | Should BE 10
+        $f19.Invoke(10, 1, 2) | Should -Be 10
         [Func[int, int, int, int, int]] $f20 = [M]::Foo
-        $f20.Invoke(10, 1, 2, 3) | Should BE 10
+        $f20.Invoke(10, 1, 2, 3) | Should -Be 10
         [Func[int, int, int, int, int, int]] $f21 = [M]::Foo
-        $f21.Invoke(10, 1, 2, 3, 4) | Should BE 10
+        $f21.Invoke(10, 1, 2, 3, 4) | Should -Be 10
         [Func[int, int, int, int, int, int, int]] $f22 = [M]::Foo
-        $f22.Invoke(10, 1, 2, 3, 4, 5) | Should BE 10
+        $f22.Invoke(10, 1, 2, 3, 4, 5) | Should -Be 10
         [Func[int, int, int, int, int, int, int, int]] $f23 = [M]::Foo
-        $f23.Invoke(10, 1, 2, 3, 4, 5, 6) | Should BE 10
+        $f23.Invoke(10, 1, 2, 3, 4, 5, 6) | Should -Be 10
         [Func[int, int, int, int, int, int, int, int, int]] $f24 = [M]::Foo
-        $f24.Invoke(10, 1, 2, 3, 4, 5, 6, 7) | Should BE 10
+        $f24.Invoke(10, 1, 2, 3, 4, 5, 6, 7) | Should -Be 10
         [Func[UInt32, UInt32]] $f25 = [M]::Foo
-        $f25.Invoke(10) | Should BE 10
+        $f25.Invoke(10) | Should -Be 10
         [Func[UInt32, UInt32, UInt32]] $f26 = [M]::Foo
-        $f26.Invoke(10, 1) | Should BE 10
+        $f26.Invoke(10, 1) | Should -Be 10
         [Func[UInt32, UInt32, UInt32, UInt32]] $f27 = [M]::Foo
-        $f27.Invoke(10, 1, 2) | Should BE 10
+        $f27.Invoke(10, 1, 2) | Should -Be 10
         [Func[UInt32, UInt32, UInt32, UInt32, UInt32]] $f28 = [M]::Foo
-        $f28.Invoke(10, 1, 2, 3) | Should BE 10
+        $f28.Invoke(10, 1, 2, 3) | Should -Be 10
         [Func[UInt32, UInt32, UInt32, UInt32, UInt32, UInt32]] $f29 = [M]::Foo
-        $f29.Invoke(10, 1, 2, 3, 4) | Should BE 10
+        $f29.Invoke(10, 1, 2, 3, 4) | Should -Be 10
         [Func[UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32]] $f30 = [M]::Foo
-        $f30.Invoke(10, 1, 2, 3, 4, 5) | Should BE 10
+        $f30.Invoke(10, 1, 2, 3, 4, 5) | Should -Be 10
         [Func[UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32]] $f31 = [M]::Foo
-        $f31.Invoke(10, 1, 2, 3, 4, 5, 6) | Should BE 10
+        $f31.Invoke(10, 1, 2, 3, 4, 5, 6) | Should -Be 10
         [Func[UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32, UInt32]] $f32 = [M]::Foo
-        $f32.Invoke(10, 1, 2, 3, 4, 5, 6, 7) | Should BE 10
+        $f32.Invoke(10, 1, 2, 3, 4, 5, 6, 7) | Should -Be 10
         [Func[UInt64, UInt64]] $f33 = [M]::Foo
-        $f33.Invoke(10) | Should BE 10
+        $f33.Invoke(10) | Should -Be 10
         [Func[UInt64, UInt64, UInt64]] $f34 = [M]::Foo
-        $f34.Invoke(10, 1) | Should BE 10
+        $f34.Invoke(10, 1) | Should -Be 10
         [Func[UInt64, UInt64, UInt64, UInt64]] $f35 = [M]::Foo
-        $f35.Invoke(10, 1, 2) | Should BE 10
+        $f35.Invoke(10, 1, 2) | Should -Be 10
         [Func[UInt64, UInt64, UInt64, UInt64, UInt64]] $f36 = [M]::Foo
-        $f36.Invoke(10, 1, 2, 3) | Should BE 10
+        $f36.Invoke(10, 1, 2, 3) | Should -Be 10
         [Func[UInt64, UInt64, UInt64, UInt64, UInt64, UInt64]] $f37 = [M]::Foo
-        $f37.Invoke(10, 1, 2, 3, 4) | Should BE 10
+        $f37.Invoke(10, 1, 2, 3, 4) | Should -Be 10
         [Func[UInt64, UInt64, UInt64, UInt64, UInt64, UInt64, UInt64]] $f38 = [M]::Foo
-        $f38.Invoke(10, 1, 2, 3, 4, 5) | Should BE 10
+        $f38.Invoke(10, 1, 2, 3, 4, 5) | Should -Be 10
         [Func[UInt64, UInt64, UInt64, UInt64, UInt64, UInt64, UInt64, UInt64]] $f39 = [M]::Foo
-        $f39.Invoke(10, 1, 2, 3, 4, 5, 6) | Should BE 10
+        $f39.Invoke(10, 1, 2, 3, 4, 5, 6) | Should -Be 10
         [Func[UInt64, UInt64, UInt64, UInt64, UInt64, UInt64, UInt64, UInt64, UInt64]] $f40 = [M]::Foo
-        $f40.Invoke(10, 1, 2, 3, 4, 5, 6, 7) | Should BE 10
+        $f40.Invoke(10, 1, 2, 3, 4, 5, 6, 7) | Should -Be 10
         [Func[float, float]] $f41 = [M]::Foo
-        $f41.Invoke(10) | Should BE 10
+        $f41.Invoke(10) | Should -Be 10
         [Func[float, float, float]] $f42 = [M]::Foo
-        $f42.Invoke(10, 1) | Should BE 10
+        $f42.Invoke(10, 1) | Should -Be 10
         [Func[float, float, float, float]] $f43 = [M]::Foo
-        $f43.Invoke(10, 1, 2) | Should BE 10
+        $f43.Invoke(10, 1, 2) | Should -Be 10
         [Func[float, float, float, float, float]] $f44 = [M]::Foo
-        $f44.Invoke(10, 1, 2, 3) | Should BE 10
+        $f44.Invoke(10, 1, 2, 3) | Should -Be 10
         [Func[float, float, float, float, float, float]] $f45 = [M]::Foo
-        $f45.Invoke(10, 1, 2, 3, 4) | Should BE 10
+        $f45.Invoke(10, 1, 2, 3, 4) | Should -Be 10
         [Func[float, float, float, float, float, float, float]] $f46 = [M]::Foo
-        $f46.Invoke(10, 1, 2, 3, 4, 5) | Should BE 10
+        $f46.Invoke(10, 1, 2, 3, 4, 5) | Should -Be 10
         [Func[float, float, float, float, float, float, float, float]] $f47 = [M]::Foo
-        $f47.Invoke(10, 1, 2, 3, 4, 5, 6) | Should BE 10
+        $f47.Invoke(10, 1, 2, 3, 4, 5, 6) | Should -Be 10
         [Func[float, float, float, float, float, float, float, float, float]] $f48 = [M]::Foo
-        $f48.Invoke(10, 1, 2, 3, 4, 5, 6, 7) | Should BE 10
+        $f48.Invoke(10, 1, 2, 3, 4, 5, 6, 7) | Should -Be 10
         [Func[double, double]] $f49 = [M]::Foo
-        $f49.Invoke(10) | Should BE 10
+        $f49.Invoke(10) | Should -Be 10
         [Func[double, double, double]] $f50 = [M]::Foo
-        $f50.Invoke(10, 1) | Should BE 10
+        $f50.Invoke(10, 1) | Should -Be 10
         [Func[double, double, double, double]] $f51 = [M]::Foo
-        $f51.Invoke(10, 1, 2) | Should BE 10
+        $f51.Invoke(10, 1, 2) | Should -Be 10
         [Func[double, double, double, double, double]] $f52 = [M]::Foo
-        $f52.Invoke(10, 1, 2, 3) | Should BE 10
+        $f52.Invoke(10, 1, 2, 3) | Should -Be 10
         [Func[double, double, double, double, double, double]] $f53 = [M]::Foo
-        $f53.Invoke(10, 1, 2, 3, 4) | Should BE 10
+        $f53.Invoke(10, 1, 2, 3, 4) | Should -Be 10
         [Func[double, double, double, double, double, double, double]] $f54 = [M]::Foo
-        $f54.Invoke(10, 1, 2, 3, 4, 5) | Should BE 10
+        $f54.Invoke(10, 1, 2, 3, 4, 5) | Should -Be 10
         [Func[double, double, double, double, double, double, double, double]] $f55 = [M]::Foo
-        $f55.Invoke(10, 1, 2, 3, 4, 5, 6) | Should BE 10
+        $f55.Invoke(10, 1, 2, 3, 4, 5, 6) | Should -Be 10
         [Func[double, double, double, double, double, double, double, double, double]] $f56 = [M]::Foo
-        $f56.Invoke(10, 1, 2, 3, 4, 5, 6, 7) | Should BE 10
+        $f56.Invoke(10, 1, 2, 3, 4, 5, 6, 7) | Should -Be 10
         [Func[IntPtr, IntPtr]] $f57 = [M]::Foo
-        $f57.Invoke(10) | Should BE 10
+        $f57.Invoke(10) | Should -Be 10
         [Func[IntPtr, IntPtr, IntPtr]] $f58 = [M]::Foo
-        $f58.Invoke(10, 1) | Should BE 10
+        $f58.Invoke(10, 1) | Should -Be 10
         [Func[IntPtr, IntPtr, IntPtr, IntPtr]] $f59 = [M]::Foo
-        $f59.Invoke(10, 1, 2) | Should BE 10
+        $f59.Invoke(10, 1, 2) | Should -Be 10
         [Func[IntPtr, IntPtr, IntPtr, IntPtr, IntPtr]] $f60 = [M]::Foo
-        $f60.Invoke(10, 1, 2, 3) | Should BE 10
+        $f60.Invoke(10, 1, 2, 3) | Should -Be 10
         [Func[IntPtr, IntPtr, IntPtr, IntPtr, IntPtr, IntPtr]] $f61 = [M]::Foo
-        $f61.Invoke(10, 1, 2, 3, 4) | Should BE 10
+        $f61.Invoke(10, 1, 2, 3, 4) | Should -Be 10
         [Func[IntPtr, IntPtr, IntPtr, IntPtr, IntPtr, IntPtr, IntPtr]] $f62 = [M]::Foo
-        $f62.Invoke(10, 1, 2, 3, 4, 5) | Should BE 10
+        $f62.Invoke(10, 1, 2, 3, 4, 5) | Should -Be 10
         [Func[IntPtr, IntPtr, IntPtr, IntPtr, IntPtr, IntPtr, IntPtr, IntPtr]] $f63 = [M]::Foo
-        $f63.Invoke(10, 1, 2, 3, 4, 5, 6) | Should BE 10
+        $f63.Invoke(10, 1, 2, 3, 4, 5, 6) | Should -Be 10
         [Func[IntPtr, IntPtr, IntPtr, IntPtr, IntPtr, IntPtr, IntPtr, IntPtr, IntPtr]] $f64 = [M]::Foo
-        $f64.Invoke(10, 1, 2, 3, 4, 5, 6, 7) | Should BE 10
+        $f64.Invoke(10, 1, 2, 3, 4, 5, 6, 7) | Should -Be 10
         $timespan = [timespan]::FromMinutes(62)
         [Func[timespan, timespan]] $f65 = [M]::Foo
-        $f65.Invoke($timeSpan) | Should BE $timeSpan
+        $f65.Invoke($timeSpan) | Should -Be $timeSpan
         [Func[timespan, timespan, timespan]] $f66 = [M]::Foo
-        $f66.Invoke($timeSpan, [Timespan]::Zero) | Should BE $timeSpan
+        $f66.Invoke($timeSpan, [Timespan]::Zero) | Should -Be $timeSpan
         [Func[timespan, timespan, timespan, timespan]] $f67 = [M]::Foo
-        $f67.Invoke($timeSpan, [Timespan]::Zero, [Timespan]::Zero) | Should BE $timeSpan
+        $f67.Invoke($timeSpan, [Timespan]::Zero, [Timespan]::Zero) | Should -Be $timeSpan
         [Func[timespan, timespan, timespan, timespan, timespan]] $f68 = [M]::Foo
-        $f68.Invoke($timeSpan, [Timespan]::Zero, [Timespan]::Zero, [Timespan]::Zero) | Should BE $timeSpan
+        $f68.Invoke($timeSpan, [Timespan]::Zero, [Timespan]::Zero, [Timespan]::Zero) | Should -Be $timeSpan
         [Func[timespan, timespan, timespan, timespan, timespan, timespan]] $f69 = [M]::Foo
-        $f69.Invoke($timeSpan, [Timespan]::Zero, [Timespan]::Zero, [Timespan]::Zero, [Timespan]::Zero) | Should BE $timeSpan
+        $f69.Invoke($timeSpan, [Timespan]::Zero, [Timespan]::Zero, [Timespan]::Zero, [Timespan]::Zero) | Should -Be $timeSpan
         [Func[timespan, timespan, timespan, timespan, timespan, timespan, timespan]] $f70 = [M]::Foo
-        $f70.Invoke($timeSpan, [Timespan]::Zero, [Timespan]::Zero, [Timespan]::Zero, [Timespan]::Zero, [Timespan]::Zero) | Should BE $timeSpan
+        $f70.Invoke($timeSpan, [Timespan]::Zero, [Timespan]::Zero, [Timespan]::Zero, [Timespan]::Zero, [Timespan]::Zero) | Should -Be $timeSpan
         [Func[timespan, timespan, timespan, timespan, timespan, timespan, timespan, timespan]] $f71 = [M]::Foo
-        $f71.Invoke($timeSpan, [Timespan]::Zero, [Timespan]::Zero, [Timespan]::Zero, [Timespan]::Zero, [Timespan]::Zero, [Timespan]::Zero) | Should BE $timeSpan
+        $f71.Invoke($timeSpan, [Timespan]::Zero, [Timespan]::Zero, [Timespan]::Zero, [Timespan]::Zero, [Timespan]::Zero, [Timespan]::Zero) | Should -Be $timeSpan
         [Func[timespan, timespan, timespan, timespan, timespan, timespan, timespan, timespan, timespan]] $f72 = [M]::Foo
-        $f72.Invoke($timeSpan, [Timespan]::Zero, [Timespan]::Zero, [Timespan]::Zero, [Timespan]::Zero, [Timespan]::Zero, [Timespan]::Zero, [Timespan]::Zero) | Should BE $timeSpan
+        $f72.Invoke($timeSpan, [Timespan]::Zero, [Timespan]::Zero, [Timespan]::Zero, [Timespan]::Zero, [Timespan]::Zero, [Timespan]::Zero, [Timespan]::Zero) | Should -Be $timeSpan
     }
 }
diff --git a/test/powershell/Language/Parser/ExtensibleCompletion.Tests.ps1 b/test/powershell/Language/Parser/ExtensibleCompletion.Tests.ps1
index 1284faaf16..42785fc555 100644
--- a/test/powershell/Language/Parser/ExtensibleCompletion.Tests.ps1
+++ b/test/powershell/Language/Parser/ExtensibleCompletion.Tests.ps1
@@ -107,9 +107,9 @@ function Test-Completions
                 foreach ($expected in $test.ExpectedResults)
                 {
                     $skip = $false
-                    if ( $expected.CompletionText -match "System.Management.Automation.PerformanceData|System.Management.Automation.Security" ) { $skip = $true }
+                    if ( $expected.CompletionText -Match "System.Management.Automation.PerformanceData|System.Management.Automation.Security" ) { $skip = $true }
                     It ($expected.CompletionText) -skip:$skip {
-                        $expected.Found | Should Be $true
+                        $expected.Found | Should -BeTrue
                     }
                 }
 
@@ -118,7 +118,7 @@ function Test-Completions
                     It "Not expected: $notExpected" {
                         foreach ($result in $results.CompletionMatches)
                         {
-                            ($result.CompletionText -ceq $notExpected) | Should Be $False
+                            $result.CompletionText | Should -Not -Be $notExpected
                         }
                     }
                 }
@@ -237,7 +237,7 @@ Describe "Test completion of parameters for native commands" -Tags "CI" {
 
         @("-dir", "-verbose", "-help", "-version") |
         Where-Object {
-            $_ -match "$wordToComplete*"
+            $_ -Match "$wordToComplete*"
         } |
         ForEach-Object {
             [CompletionResult]::new($_, $_, [CompletionResultType]::ParameterName, $_)
@@ -436,9 +436,9 @@ Describe "ArgumentCompletionsAttribute tests" -Tags "CI" {
 
         $line = "$cmdletName -Alpha val"
         $res = TaBexpansion2 -inputScript $line -cursorColumn $line.Length
-        $res.CompletionMatches.Count | Should Be 3
-        $res.CompletionMatches.CompletionText -join " " | Should Be "value1 value2 value3"
-        { TestArgumentCompletionsAttribute -Alpha unExpectedValue } | Should Not Throw
+        $res.CompletionMatches.Count | Should -Be 3
+        $res.CompletionMatches.CompletionText -join " " | Should -BeExactly "value1 value2 value3"
+        { TestArgumentCompletionsAttribute -Alpha unExpectedValue } | Should -Not -Throw
     }
 
     It "<attributeName> works in C#" -TestCases $testCasesCSharp {
@@ -446,8 +446,8 @@ Describe "ArgumentCompletionsAttribute tests" -Tags "CI" {
 
         $line = "$cmdletName -Param1 val"
         $res = TaBexpansion2 -inputScript $line -cursorColumn $line.Length
-        $res.CompletionMatches.Count | Should Be 3
-        $res.CompletionMatches.CompletionText -join " " | Should Be "value1 value2 value3"
-        { TestArgumentCompletionsAttribute -Param1 unExpectedValue } | Should Not Throw
+        $res.CompletionMatches.Count | Should -Be 3
+        $res.CompletionMatches.CompletionText -join " " | Should -BeExactly "value1 value2 value3"
+        { TestArgumentCompletionsAttribute -Param1 unExpectedValue } | Should -Not -Throw
     }
 }
diff --git a/test/powershell/Language/Parser/LanguageAndParser.TestFollowup.Tests.ps1 b/test/powershell/Language/Parser/LanguageAndParser.TestFollowup.Tests.ps1
index 20f041a3ba..39d9d23eaa 100644
--- a/test/powershell/Language/Parser/LanguageAndParser.TestFollowup.Tests.ps1
+++ b/test/powershell/Language/Parser/LanguageAndParser.TestFollowup.Tests.ps1
@@ -4,17 +4,17 @@ $powershellexe = (get-process -id $PID).mainmodule.filename
 
 Describe "Clone array" -Tags "CI" {
     It "Cast in target expr" {
-        (([int[]](42)).clone()) | Should Be 42
-        (([int[]](1..5)).clone()).Length | Should Be 5
-        (([int[]](1..5)).clone()).GetType() | Should Be ([int[]])
+        (([int[]](42)).clone()) | Should -Be 42
+        (([int[]](1..5)).clone()).Length | Should -Be 5
+        (([int[]](1..5)).clone()).GetType() | Should -Be ([int[]])
 
     }
     It "Cast not in target expr" {
         $e = [int[]](42)
-        $e.Clone() | Should Be 42
+        $e.Clone() | Should -Be 42
         $e = [int[]](1..5)
-        $e.Clone().Length | Should Be 5
-        $e.Clone().GetType() | Should Be ([int[]])
+        $e.Clone().Length | Should -Be 5
+        $e.Clone().GetType() | Should -Be ([int[]])
     }
 }
 
@@ -24,15 +24,15 @@ Describe "Set fields through PSMemberInfo" -Tags "CI" {
 "@
 
     It "via cast" {
-        ([AStruct]@{s = "abc" }).s | Should Be "abc"
+        ([AStruct]@{s = "abc" }).s | Should -BeExactly "abc"
     }
     It "via new-object" {
-        (new-object AStruct -prop @{s="abc"}).s | Should Be "abc"
+        (new-object AStruct -prop @{s="abc"}).s | Should -BeExactly "abc"
     }
     It "via PSObject" {
         $x = [AStruct]::new()
         $x.psobject.properties['s'].Value = 'abc'
-        $x.s | Should Be "abc"
+        $x.s | Should -Be "abc"
     }
 }
 
@@ -41,12 +41,12 @@ Describe "MSFT:3309783" -Tags "CI" {
     It "Run in another process" {
         # For a reliable test, we must run this in a new process because an earlier binding in this process
         # could mask the bug/fix.
-        & $powershellexe -noprofile -command "[psobject] | ForEach-Object FullName" | Should Be System.Management.Automation.PSObject
+        & $powershellexe -noprofile -command "[psobject] | ForEach-Object FullName" | Should -Be System.Management.Automation.PSObject
     }
 
     It "Run in current process" {
         # For good measure, do the same thing in this process
-        [psobject] | ForEach-Object FullName | Should Be System.Management.Automation.PSObject
+        [psobject] | ForEach-Object FullName | Should -Be System.Management.Automation.PSObject
     }
 
     It "Pipe objects derived from PSObject" {
@@ -60,8 +60,8 @@ Describe "MSFT:3309783" -Tags "CI" {
             }
         }
 
-        [MyPsObj]::new("abc").psobject.ToString() | Should Be "MyObj: abc"
-        [MyPsObj]::new("def") | Out-String | ForEach-Object Trim | Should Be "MyObj: def"
+        [MyPsObj]::new("abc").psobject.ToString() | Should -Be "MyObj: abc"
+        [MyPsObj]::new("def") | Out-String | ForEach-Object Trim | Should -Be "MyObj: def"
     }
 }
 
@@ -71,14 +71,14 @@ Describe "ScriptBlockAst.GetScriptBlock throws on error" -Tags "CI" {
 
     It "with parse error" {
         $ast = [System.Management.Automation.Language.Parser]::ParseInput('function ', [ref]$null, [ref]$e)
-        { $ast.GetScriptBlock() } | Should Throw
+        { $ast.GetScriptBlock() } | Should -Throw -ErrorId "PSInvalidOperationException"
     }
 
     It "with semantic errors" {
         $ast = [System.Management.Automation.Language.Parser]::ParseInput('function foo{param()begin{}end{[ref][ref]1}dynamicparam{}}', [ref]$null, [ref]$e)
 
-        { $ast.GetScriptBlock() } | Should Throw
-        { $ast.EndBlock.Statements[0].Body.GetScriptBlock() } | Should Throw
+        { $ast.GetScriptBlock() } | Should -Throw -ErrorId "PSInvalidOperationException"
+        { $ast.EndBlock.Statements[0].Body.GetScriptBlock() } | Should -Throw -ErrorId "PSInvalidOperationException"
     }
 }
 
@@ -97,13 +97,13 @@ Describe "Hashtable key property syntax" -Tags "CI" {
     It "In current process" {
         # Run in current process, but something that ran earlier could influence
         # the result
-        Invoke-Expression $script | Should Be Hello
+        Invoke-Expression $script | Should -BeExactly 'Hello'
     }
 
     It "In different process" {
         # So also run in a fresh process
         $bytes = [System.Text.Encoding]::Unicode.GetBytes($script)
-        & $powershellexe -noprofile -encodedCommand ([Convert]::ToBase64String($bytes)) | Should Be Hello
+        & $powershellexe -noprofile -encodedCommand ([Convert]::ToBase64String($bytes)) | Should -BeExactly 'Hello'
     }
 }
 
@@ -114,32 +114,32 @@ Describe "Assign automatic variables" -Tags "CI" {
     foreach ($auto in $autos)
     {
         It "Assign auto w/ invalid type constraint - $auto" {
-            { & ([ScriptBlock]::Create("[datetime]`$$auto = 1")) } | Should Throw $auto
-            { . ([ScriptBlock]::Create("[datetime]`$$auto = 1")) } | Should Throw $auto
-            { & ([ScriptBlock]::Create("[runspace]`$$auto = 1")) } | Should Throw $auto
-            { . ([ScriptBlock]::Create("[runspace]`$$auto = 1")) } | Should Throw $auto
-            { & ([ScriptBlock]::Create("[notexist]`$$auto = 1")) } | Should Throw $auto
-            { . ([ScriptBlock]::Create("[notexist]`$$auto = 1")) } | Should Throw $auto
+            { & ([ScriptBlock]::Create("[datetime]`$$auto = 1")) } | Should -Throw $auto
+            { . ([ScriptBlock]::Create("[datetime]`$$auto = 1")) } | Should -Throw $auto
+            { & ([ScriptBlock]::Create("[runspace]`$$auto = 1")) } | Should -Throw $auto
+            { . ([ScriptBlock]::Create("[runspace]`$$auto = 1")) } | Should -Throw $auto
+            { & ([ScriptBlock]::Create("[notexist]`$$auto = 1")) } | Should -Throw $auto
+            { . ([ScriptBlock]::Create("[notexist]`$$auto = 1")) } | Should -Throw $auto
         }
     }
 
     foreach ($auto in $autos)
     {
         It "Assign auto w/o type constraint - $auto" {
-            & ([ScriptBlock]::Create("`$$auto = 1; `$$auto")) | Should Be 1
-            . ([ScriptBlock]::Create("`$$auto = 1; `$$auto")) | Should Be 1
+            & ([ScriptBlock]::Create("`$$auto = 1; `$$auto")) | Should -Be 1
+            . ([ScriptBlock]::Create("`$$auto = 1; `$$auto")) | Should -Be 1
         }
     }
 
     It "Assign auto w/ correct type constraint" {
-        & { [object]$_ = 1; $_ } | Should Be 1
-        & { [object[]]$args = 1; $args } | Should Be 1
-        & { [object]$this = 1; $this } | Should Be 1
-        & { [object]$input = 1; $input } | Should Be 1
+        & { [object]$_ = 1; $_ } | Should -Be 1
+        & { [object[]]$args = 1; $args } | Should -Be 1
+        & { [object]$this = 1; $this } | Should -Be 1
+        & { [object]$input = 1; $input } | Should -Be 1
         # Can't test PSCmdlet or PSBoundParameters, they use an internal type
-        & { [System.Management.Automation.InvocationInfo]$myInvocation = $myInvocation; $myInvocation.Line } | Should Match Automation.InvocationInfo
-        & { [string]$PSScriptRoot = 'abc'; $PSScriptRoot } | Should Be abc
-        & { [string]$PSCommandPath = 'abc'; $PSCommandPath } | Should Be abc
+        & { [System.Management.Automation.InvocationInfo]$myInvocation = $myInvocation; $myInvocation.Line } | Should -Match Automation.InvocationInfo
+        & { [string]$PSScriptRoot = 'abc'; $PSScriptRoot } | Should -BeExactly 'abc'
+        & { [string]$PSCommandPath = 'abc'; $PSCommandPath } | Should -BeExactly 'abc'
     }
 }
 
@@ -153,8 +153,8 @@ Describe "Assign readonly/constant variables" -Tags "CI" {
 
     It "Assign readonly/constant variables w/o type constraint - '<name>'" -TestCases $testCase {
         param($sb_wo_conversion)
-        { & $sb_wo_conversion } | Should Throw
-        { . $sb_wo_conversion } | Should Throw
+        { & $sb_wo_conversion } | Should -Throw -ErrorId "VariableNotWritable"
+        { . $sb_wo_conversion } | Should -Throw -ErrorId "VariableNotWritable"
     }
 
     $testCase = @(
@@ -165,8 +165,8 @@ Describe "Assign readonly/constant variables" -Tags "CI" {
 
     It "Assign readonly/constant variables w/ type constraint - '<name>'" -TestCases $testCase {
         param($sb_w_conversion)
-        { & $sb_w_conversion } | Should Throw
-        { . $sb_w_conversion } | Should Throw
+        { & $sb_w_conversion } | Should -Throw -ErrorId "VariableNotWritable"
+        { . $sb_w_conversion } | Should -Throw -ErrorId "VariableNotWritable"
     }
 }
 
@@ -184,8 +184,8 @@ Describe "Attribute error position" -Tags "CI" {
         }
         catch
         {
-            $_.InvocationInfo.Line | Should Match ValidateNotNull
-            $_.FullyQualifiedErrorId | Should Be MethodCountCouldNotFindBest
+            $_.InvocationInfo.Line | Should -Match ValidateNotNull
+            $_.FullyQualifiedErrorId | Should -Be MethodCountCouldNotFindBest
         }
     }
 }
@@ -201,9 +201,9 @@ Describe "Multiple alias attributes" -Tags "CI" {
             $cc
         }
 
-        foo -aa 1 | Should Be 1
-        foo -bb 2 | Should Be 2
-        foo -cc 3 | Should Be 3
+        foo -aa 1 | Should -Be 1
+        foo -bb 2 | Should -Be 2
+        foo -cc 3 | Should -Be 3
     }
 }
 
@@ -214,7 +214,7 @@ Describe "Members of System.Type" -Tags "CI" {
             [System.Collections.IEnumerator] GetEnumerator() { return $null }
         }
 
-        [type] | Get-Member ImplementedInterfaces | Should Be 'System.Collections.Generic.IEnumerable[type] ImplementedInterfaces {get;}'
-        [MyType].ImplementedInterfaces | Should Be System.Collections.IEnumerable
+        [type] | Get-Member ImplementedInterfaces | Should -Be 'System.Collections.Generic.IEnumerable[type] ImplementedInterfaces {get;}'
+        [MyType].ImplementedInterfaces | Should -Be System.Collections.IEnumerable
     }
 }
diff --git a/test/powershell/Language/Parser/MethodInvocation.Tests.ps1 b/test/powershell/Language/Parser/MethodInvocation.Tests.ps1
index c894460dcc..69a6cdca9c 100644
--- a/test/powershell/Language/Parser/MethodInvocation.Tests.ps1
+++ b/test/powershell/Language/Parser/MethodInvocation.Tests.ps1
@@ -70,14 +70,14 @@ namespace MSFT_716893
     }
 
     It "Direct invocation" {
-        $proxy.Operation("a") | Should Be "1 - a"
-        $proxy.Operation("a", "b") | Should Be "2 - a b"
-        $proxy.BaseOperation(42) | Should Be "3 - 42"
+        $proxy.Operation("a") | Should -Be "1 - a"
+        $proxy.Operation("a", "b") | Should -Be "2 - a b"
+        $proxy.BaseOperation(42) | Should -Be "3 - 42"
     }
 
     It "Invocation via method constraints" {
-        ([MSFT_716893.IInterface2]$proxy).Operation("c") | Should Be "1 - c"
-        ([MSFT_716893.IInterface2]$proxy).Operation("d", "e") | Should Be "2 - d e"
-        ([MSFT_716893.IInterface1]$proxy).BaseOperation(22) | Should Be "3 - 22"
+        ([MSFT_716893.IInterface2]$proxy).Operation("c") | Should -Be "1 - c"
+        ([MSFT_716893.IInterface2]$proxy).Operation("d", "e") | Should -Be "2 - d e"
+        ([MSFT_716893.IInterface1]$proxy).BaseOperation(22) | Should -Be "3 - 22"
     }
 }
diff --git a/test/powershell/Language/Parser/ParameterBinding.Tests.ps1 b/test/powershell/Language/Parser/ParameterBinding.Tests.ps1
index 7ae9e3564b..ad4d539d5c 100644
--- a/test/powershell/Language/Parser/ParameterBinding.Tests.ps1
+++ b/test/powershell/Language/Parser/ParameterBinding.Tests.ps1
@@ -70,32 +70,32 @@ Describe 'Argument transformation attribute on optional argument with explicit $
     }
 
     It "There was no error importing the in-memory module" {
-        $ErrorImportingModule | Should Be $null
+        $ErrorImportingModule | Should -BeNullOrEmpty
     }
 
     It "Script function takes object" {
-        Invoke-ScriptFunctionTakesObject | Should Be 42
+        Invoke-ScriptFunctionTakesObject | Should -Be 42
     }
     It "Script function takes uint64" {
-        Invoke-ScriptFunctionTakesUInt64 | Should Be 42
+        Invoke-ScriptFunctionTakesUInt64 | Should -Be 42
     }
     it "csharp cmdlet takes object" {
-        Invoke-CSharpCmdletTakesObject | Should Be "passed in null"
+        Invoke-CSharpCmdletTakesObject | Should -Be "passed in null"
     }
     it "csharp cmdlet takes uint64" {
-        Invoke-CSharpCmdletTakesUInt64 | Should Be 0
+        Invoke-CSharpCmdletTakesUInt64 | Should -Be 0
     }
 
     it "script function takes object when parameter is null" {
-        Invoke-ScriptFunctionTakesObject -Address $null | Should Be 42
+        Invoke-ScriptFunctionTakesObject -Address $null | Should -Be 42
     }
     it "script function takes unit64 when parameter is null" {
-        Invoke-ScriptFunctionTakesUInt64 -Address $null | Should Be 42
+        Invoke-ScriptFunctionTakesUInt64 -Address $null | Should -Be 42
     }
     it "script csharp cmdlet takes object when parameter is null" {
-        Invoke-CSharpCmdletTakesObject -Address $null | Should Be 42
+        Invoke-CSharpCmdletTakesObject -Address $null | Should -Be 42
     }
     it "script csharp cmdlet takes uint64 when parameter is null" {
-        Invoke-CSharpCmdletTakesUInt64 -Address $null | Should Be 42
+        Invoke-CSharpCmdletTakesUInt64 -Address $null | Should -Be 42
     }
 }
diff --git a/test/powershell/Language/Parser/Parser.Tests.ps1 b/test/powershell/Language/Parser/Parser.Tests.ps1
index 0edc62fda6..3b012dd3b3 100644
--- a/test/powershell/Language/Parser/Parser.Tests.ps1
+++ b/test/powershell/Language/Parser/Parser.Tests.ps1
@@ -90,11 +90,11 @@ Describe "ParserTests (admin\monad\tests\monad\src\engine\core\ParserTests.cs)"
 		$shellfile = Join-Path -Path $TestDrive -ChildPath "testfile.cmd"
 		$testfolder1 = Join-Path -Path $TestDrive -ChildPath "dir1"
 		$testfolder2 = Join-Path -Path $testfolder1 -ChildPath "dir2"
-		if(-not(Test-Path $testfolder1))
+		if(-Not(Test-Path $testfolder1))
 		{
 			New-Item $testfolder1 -Type Directory
 		}
-		if(-not(Test-Path $testfolder2))
+		if(-Not(Test-Path $testfolder2))
 		{
 			New-Item $testfolder2 -Type Directory
 		}
@@ -143,7 +143,7 @@ Describe "ParserTests (admin\monad\tests\monad\src\engine\core\ParserTests.cs)"
             throw "Execution OK"
         }
         catch {
-            $_.FullyQualifiedErrorId | Should be "IncompleteParseException"
+            $_.FullyQualifiedErrorId | Should -Be "IncompleteParseException"
         }
 	}
 
@@ -153,7 +153,7 @@ Describe "ParserTests (admin\monad\tests\monad\src\engine\core\ParserTests.cs)"
             throw "Execution OK"
         }
         catch {
-            $_.FullyQualifiedErrorId | should be "IncompleteParseException"
+            $_.FullyQualifiedErrorId | Should -Be "IncompleteParseException"
         }
     }
 
@@ -163,15 +163,15 @@ Describe "ParserTests (admin\monad\tests\monad\src\engine\core\ParserTests.cs)"
             throw "Execution OK"
         }
         catch {
-            $_.FullyQualifiedErrorId | should be "ParseException"
+            $_.FullyQualifiedErrorId | Should -Be "ParseException"
         }
     }
 
 	It "Throws an CommandNotFoundException exception if using a label in front of an if statement is not allowed. (line 225)"{
         $PowerShell.Streams.Error.Clear()
         ExecuteCommand ":foo if ($x -eq 3) { 1 }"
-		$PowerShell.HadErrors | should be $true
-        $PowerShell.Streams.Error.FullyQualifiedErrorId | should be "CommandNotFoundException"
+		$PowerShell.HadErrors | Should -BeTrue
+        $PowerShell.Streams.Error.FullyQualifiedErrorId | Should -Be "CommandNotFoundException"
     }
 
 	It "Pipe an expression into a value expression. (line 237)" {
@@ -180,7 +180,7 @@ Describe "ParserTests (admin\monad\tests\monad\src\engine\core\ParserTests.cs)"
             throw "Execution OK"
         }
         catch {
-            $_.FullyQualifiedErrorId | should be "ParseException"
+            $_.FullyQualifiedErrorId | Should -Be "ParseException"
         }
 
 		try {
@@ -188,7 +188,7 @@ Describe "ParserTests (admin\monad\tests\monad\src\engine\core\ParserTests.cs)"
             throw "Execution OK"
         }
         catch {
-            $_.FullyQualifiedErrorId | should be "ParseException"
+            $_.FullyQualifiedErrorId | Should -Be "ParseException"
         }
 
 		try {
@@ -196,7 +196,7 @@ Describe "ParserTests (admin\monad\tests\monad\src\engine\core\ParserTests.cs)"
             throw "Execution OK"
         }
         catch {
-            $_.FullyQualifiedErrorId | should be "ParseException"
+            $_.FullyQualifiedErrorId | Should -Be "ParseException"
         }
     }
 
@@ -207,7 +207,7 @@ Describe "ParserTests (admin\monad\tests\monad\src\engine\core\ParserTests.cs)"
                 throw "Execution OK"
             }
             catch {
-                $_.FullyQualifiedErrorId | Should be "ParseException"
+                $_.FullyQualifiedErrorId | Should -Be "ParseException"
             }
         }
     }
@@ -218,57 +218,57 @@ Describe "ParserTests (admin\monad\tests\monad\src\engine\core\ParserTests.cs)"
             throw "Execution OK"
         }
         catch {
-            $_.FullyQualifiedErrorId | Should be "IncompleteParseException"
+            $_.FullyQualifiedErrorId | Should -Be "IncompleteParseException"
         }
     }
 
 	It "Test that invoke has a higher precedence for a script than for an executable. (line 279)" {
 		"1">$testfile
         $result = ExecuteCommand ". $testfile"
-		$result | should be 1
+		$result | Should -Be 1
     }
 
 	It "This test will check that a path is correctly interpreted when using '..' and '.'  (line 364)" {
         $result = ExecuteCommand "set-location $TestDrive; get-childitem dir1\.\.\.\..\dir1\.\dir2\..\..\dir1\.\dir2"
-		$result.Count | should be 2
-		$result[0].Name | should be "testdirfile1.txt"
-		$result[1].Name | should be "testdirfile2.txt"
+		$result.Count | Should -Be 2
+		$result[0].Name | Should -BeExactly "testdirfile1.txt"
+		$result[1].Name | Should -BeExactly "testdirfile2.txt"
     }
 
 	It "This test will check that the parser can handle a mix of forward slashes and back slashes in the path (line 417)" {
         $result = ExecuteCommand "get-childitem $TestDrive/dir1/./.\.\../dir1/.\dir2\../..\dir1\.\dir2"
-		$result.Count | should be 2
-		$result[0].Name | should be "testdirfile1.txt"
-		$result[1].Name | should be "testdirfile2.txt"
+		$result.Count | Should -Be 2
+		$result[0].Name | Should -BeExactly "testdirfile1.txt"
+		$result[1].Name | Should -BeExactly "testdirfile2.txt"
     }
 
 	It "This test checks that the asterisk globs as expected. (line 545)" {
         $result = ExecuteCommand "get-childitem $TestDrive/dir1\dir2\*.txt"
-		$result.Count | should be 2
-		$result[0].Name | should be "testdirfile1.txt"
-		$result[1].Name | should be "testdirfile2.txt"
+		$result.Count | Should -Be 2
+		$result[0].Name | Should -BeExactly "testdirfile1.txt"
+		$result[1].Name | Should -BeExactly "testdirfile2.txt"
     }
 
 	It "This test checks that we can use a range for globbing: [1-2] (line 557)" {
         $result = ExecuteCommand "get-childitem $TestDrive/dir1\dir2\testdirfile[1-2].txt"
-		$result.Count | should be 2
-		$result[0].Name | should be "testdirfile1.txt"
-		$result[1].Name | should be "testdirfile2.txt"
+		$result.Count | Should -Be 2
+		$result[0].Name | Should -BeExactly "testdirfile1.txt"
+		$result[1].Name | Should -BeExactly "testdirfile2.txt"
     }
 
 	It "This test will check that escaping the $ sigil inside single quotes simply returns the $ character. (line 583)" {
         $result = ExecuteCommand "'`$'"
-		$result | should be "`$"
+		$result | Should -BeExactly "`$"
     }
 
 	It "Test that escaping a space just returns that space. (line 593)" {
         $result = ExecuteCommand '"foo` bar"'
-		$result | should be "foo bar"
+		$result | Should -BeExactly "foo bar"
     }
 
     It "Test that escaping the character 'e' returns the ESC character (0x1b)." {
         $result = ExecuteCommand '"`e"'
-        $result | should be ([char]0x1b)
+        $result | Should -BeExactly ([char]0x1b)
     }
 
     Context "Test Unicode escape sequences." {
@@ -276,38 +276,38 @@ Describe "ParserTests (admin\monad\tests\monad\src\engine\core\ParserTests.cs)"
         # PowerShell without a BOM, the file is incorrectly interpreted as ASCII.
         It 'Test that the bracketed Unicode escape sequence `u{0} returns minimum char.' {
             $result = ExecuteCommand '"`u{0}"'
-            [int]$result[0] | should be 0
+            [int]$result[0] | Should -Be 0
         }
 
         It 'Test that the bracketed Unicode escape sequence `u{10FFFF} returns maximum surrogate char pair.' {
             $result = ExecuteCommand '"`u{10FFFF}"'
-            [int]$result[0] | should be 0xDBFF # max value for high surrogate of surrogate pair
-            [int]$result[1] | should be 0xDFFF # max value for low surrogate of surrogate pair
+            [int]$result[0] | Should -BeExactly 0xDBFF # max value for high surrogate of surrogate pair
+            [int]$result[1] | Should -BeExactly 0xDFFF # max value for low surrogate of surrogate pair
         }
 
         It 'Test that the bracketed Unicode escape sequence `u{a9} returns the © character.' {
             $result = ExecuteCommand '"`u{a9}"'
-            $result | should be '©'
+            $result | Should -BeExactly '©'
         }
 
         It 'Test that Unicode escape sequence `u{2195} in string returns the ↕ character.' {
             $result = ExecuteCommand '"foo`u{2195}abc"'
-            $result | should be "foo↕abc"
+            $result | Should -BeExactly "foo↕abc"
         }
 
         It 'Test that the bracketed Unicode escape sequence `u{1f44d} returns surrogate pair for emoji 👍 character.' {
             $result = ExecuteCommand '"`u{1f44d}"'
-            $result | should be "👍"
+            $result | Should -BeExactly "👍"
         }
 
         It 'Test that Unicode escape sequence `u{2195} in here string returns the ↕ character.' {
             $result = ExecuteCommand ("@`"`n`n" + 'foo`u{2195}abc' + "`n`n`"@")
-            $result | should be "`nfoo↕abc`n"
+            $result | Should -BeExactly "`nfoo↕abc`n"
         }
 
         It 'Test that Unicode escape sequence in single quoted is not processed.' {
             $result = ExecuteCommand '''foo`u{2195}abc'''
-            $result | should be 'foo`u{2195}abc'
+            $result | Should -BeExactly 'foo`u{2195}abc'
         }
 
         It 'Test that Unicode escape sequence in single quoted here string is not processed.' {
@@ -318,38 +318,38 @@ foo``u{2195}abc
 
 '@
 "@
-            $result | should match "\r?\nfoo``u\{2195\}abc\r?\n"
+            $result | Should -Match "\r?\nfoo``u\{2195\}abc\r?\n"
         }
 
         It "Test that two consecutive Unicode escape sequences are tokenized correctly." {
             $result = ExecuteCommand '"`u{007b}`u{007d}"'
-            $result | should be '{}'
+            $result | Should -Be '{}'
         }
 
         It "Test that a Unicode escape sequence can be used in a command name." {
             function xyzzy`u{2195}($p) {$p}
             $cmd = Get-Command xyzzy`u{2195} -ErrorAction SilentlyContinue
-            $cmd | should not BeNullOrEmpty
-            $cmd.Name | should be 'xyzzy↕'
-            xyzzy`u{2195} 42 | should be 42
+            $cmd | Should -Not -BeNullOrEmpty
+            $cmd.Name | Should -BeExactly 'xyzzy↕'
+            xyzzy`u{2195} 42 | Should -Be 42
         }
 
         It "Test that a Unicode escape sequence can be used in a variable name." {
             ${fooxyzzy`u{2195}} = 42
             $var = Get-Variable -Name fooxyzzy* -ErrorAction SilentlyContinue
-            $var | should not BeNullOrEmpty
-            $var.Name | should be "fooxyzzy↕"
-            $var.Value | should be 42
+            $var | Should -Not -BeNullOrEmpty
+            $var.Name | Should -BeExactly "fooxyzzy↕"
+            $var.Value | Should -Be 42
         }
 
         It "Test that a Unicode escape sequence can be used in an argument." {
-            Write-Output `u{a9}` Acme` Inc | should be "© Acme Inc"
+            Write-Output `u{a9}` Acme` Inc | Should -BeExactly "© Acme Inc"
         }
     }
 
 	It "Test that escaping any character with no special meaning just returns that char. (line 602)" {
         $result = ExecuteCommand '"fo`obar"'
-		$result | should be "foobar"
+		$result | Should -BeExactly "foobar"
     }
 
 	Context "Test that we support all of the C# escape sequences. We use the ` instead of \. (line 613)" {
@@ -371,39 +371,39 @@ foo``u{2195}abc
 		It "C# escape sequence <sequence> is supported using `` instead of \. (line 613)" -TestCases $tests {
 			param ( $sequence, $expected )
 			$result = ExecuteCommand $sequence
-			$result | should be $expected
+			$result | Should -BeExactly $expected
 		}
     }
 
 	It "This test checks that array substitution occurs inside double quotes. (line 646)" {
         $result = ExecuteCommand '$MyArray = "a","b";"Hello $MyArray"'
-		$result | should be "Hello a b"
+		$result | Should -BeExactly "Hello a b"
     }
 
 	It "This tests declaring an array in nested variable tables. (line 761)" {
         $result = ExecuteCommand "`$Variable:vtbl1:vtbl2:b=@(5,6);`$Variable:vtbl1:vtbl2:b"
-		$result.Count | should be 2
-		$result[0] | should be 5
-		$result[1] | should be 6
+		$result.Count | Should -Be 2
+		$result[0] | Should -Be 5
+		$result[1] | Should -Be 6
     }
 
 	It "Test a simple multiple assignment. (line 773)" {
         $result = ExecuteCommand '$one,$two = 1,2,3; "One = $one"; "Two = $two"'
-		$result.Count | should be 2
-		$result[0] | should be "One = 1"
-		$result[1] | should be "Two = 2 3"
+		$result.Count | Should -Be 2
+		$result[0] | Should -Be "One = 1"
+		$result[1] | Should -Be "Two = 2 3"
     }
 
 	It "Tests script, global and local scopes from a function inside a script. (line 824)" {
 		"`$var = 'script';function func { `$var; `$var = 'local'; `$local:var; `$script:var; `$global:var };func;`$var;">$testfile
 		ExecuteCommand "`$var = 'global'"
         $result = ExecuteCommand "$testfile"
-		$result.Count | should be 5
-		$result[0] | should be "script"
-		$result[1] | should be "local"
-		$result[2] | should be "script"
-		$result[3] | should be "global"
-		$result[4] | should be "script"
+		$result.Count | Should -Be 5
+		$result[0] | Should -BeExactly "script"
+		$result[1] | Should -BeExactly "local"
+		$result[2] | Should -BeExactly "script"
+		$result[3] | Should -BeExactly "global"
+		$result[4] | Should -BeExactly "script"
     }
 
 	It "Use break inside of a loop that is inside another loop. (line 945)" {
@@ -415,7 +415,7 @@ foo``u{2195}abc
 		for(;$i -lt $commands.Count;$i++)
 		{
 			$result = ExecuteCommand $commands[$i]
-			$result | should be $results
+			$result | Should -Be $results
 		}
     }
 
@@ -428,7 +428,7 @@ foo``u{2195}abc
 		for(;$i -lt $commands.Count;$i++)
 		{
 			$result = ExecuteCommand $commands[$i]
-			$result | should be $results
+			$result | Should -Be $results
 		}
     }
 
@@ -437,11 +437,11 @@ foo``u{2195}abc
                 " for (`$a = 0;`$a -lt 2; `$a += 1) { 9; continue; 3; } ",
                 " foreach(`$a in 0,1) { `$a; continue; 2; } "
 		$result = ExecuteCommand $commands[0]
-		$result | should be "0", "1"
+		$result | Should -Be "0", "1"
 		$result = ExecuteCommand $commands[1]
-		$result | should be "9", "9"
+		$result | Should -Be "9", "9"
 		$result = ExecuteCommand $commands[2]
-		$result | should be "0", "1"
+		$result | Should -Be "0", "1"
     }
 
 	It "Use a label to continue an inner loop. (line 1059)" {
@@ -449,11 +449,11 @@ foo``u{2195}abc
                 " for (`$x = 0;`$x -lt 1;`$x += 1) { 1; :foo for(`$a = 0; `$a -lt 2; `$a += 1) { `$a; continue foo; 3; }; 4; continue; 5; } ",
                 " foreach(`$a in 1) { 1; :foo foreach( `$b in 1,2 ) { `$b; continue foo; 3; }; 4; continue; 5; } "
 		$result = ExecuteCommand $commands[0]
-		$result | should be "1", "1", "2", "4"
+		$result | Should -Be "1", "1", "2", "4"
 		$result = ExecuteCommand $commands[1]
-		$result | should be "1", "0", "1", "4"
+		$result | Should -Be "1", "0", "1", "4"
 		$result = ExecuteCommand $commands[2]
-		$result | should be "1", "1", "2", "4"
+		$result | Should -Be "1", "1", "2", "4"
     }
 
 	It "Use continue with a label on a nested loop. (line 1059)" {
@@ -461,11 +461,11 @@ foo``u{2195}abc
                 " :foo for (`$x = 0;`$x -lt 2;`$x += 1) { 1; :bar for(;;) { 2; continue foo; 3; }; 4; continue; 5; } ",
                 " :foo foreach(`$a in 1,2) { 1; :bar foreach( `$b in 1,2,3 ) { 2; continue foo; 3; }; 4; continue; 5; } "
 		$result = ExecuteCommand $commands[0]
-		$result | should be "0", "2", "1", "2"
+		$result | Should -Be "0", "2", "1", "2"
 		$result = ExecuteCommand $commands[1]
-		$result | should be "1", "2", "1", "2"
+		$result | Should -Be "1", "2", "1", "2"
 		$result = ExecuteCommand $commands[2]
-		$result | should be "1", "2", "1", "2"
+		$result | Should -Be "1", "2", "1", "2"
     }
 
 	It "This test will check that it is a syntax error to use if without a code block. (line 1141)" {
@@ -474,7 +474,7 @@ foo``u{2195}abc
             throw "Execution OK"
         }
         catch {
-            $_.FullyQualifiedErrorId | Should be "IncompleteParseException"
+            $_.FullyQualifiedErrorId | Should -Be "IncompleteParseException"
         }
     }
 
@@ -484,7 +484,7 @@ foo``u{2195}abc
             throw "Execution OK"
         }
         catch {
-            $_.FullyQualifiedErrorId | Should be "IncompleteParseException"
+            $_.FullyQualifiedErrorId | Should -Be "IncompleteParseException"
         }
     }
 
@@ -494,7 +494,7 @@ foo``u{2195}abc
             throw "Execution OK"
         }
         catch {
-            $_.FullyQualifiedErrorId | Should be "ParseException"
+            $_.FullyQualifiedErrorId | Should -Be "ParseException"
         }
     }
 
@@ -504,7 +504,7 @@ foo``u{2195}abc
             throw "Execution OK"
         }
         catch {
-            $_.FullyQualifiedErrorId | Should be "ParseException"
+            $_.FullyQualifiedErrorId | Should -Be "ParseException"
         }
     }
 
@@ -514,7 +514,7 @@ foo``u{2195}abc
             throw "Execution OK"
         }
         catch {
-            $_.FullyQualifiedErrorId | Should be "IncompleteParseException"
+            $_.FullyQualifiedErrorId | Should -Be "IncompleteParseException"
         }
     }
 
@@ -524,7 +524,7 @@ foo``u{2195}abc
             throw "Execution OK"
         }
         catch {
-            $_.FullyQualifiedErrorId | Should be "ParseException"
+            $_.FullyQualifiedErrorId | Should -Be "ParseException"
         }
     }
 
@@ -534,7 +534,7 @@ foo``u{2195}abc
             throw "Execution OK"
         }
         catch {
-            $_.FullyQualifiedErrorId | Should be "ParseException"
+            $_.FullyQualifiedErrorId | Should -Be "ParseException"
         }
     }
 
@@ -544,60 +544,60 @@ foo``u{2195}abc
             throw "Execution OK"
         }
         catch {
-            $_.FullyQualifiedErrorId | Should be "ParseException"
+            $_.FullyQualifiedErrorId | Should -Be "ParseException"
         }
     }
 
 	It "Test that if an exception is thrown from the try block it will be caught in the appropropriate catch block and that the finally block will run regardless of whether an exception is thrown. (line 1317)" {
         $result = ExecuteCommand 'try { try { throw (new-object System.ArgumentException) } catch [System.DivideByZeroException] { } finally { "Finally" } } catch { $_.Exception.GetType().FullName }'
-		$result | should be "Finally", "System.ArgumentException"
+		$result | Should -Be "Finally", "System.ArgumentException"
     }
 
 	It "Test that null can be passed to a method that expects a reference type. (line 1439)" {
         $result = ExecuteCommand '$test = "String";$test.CompareTo($())'
-		$result | should be 1
+		$result | Should -Be 1
     }
 
 	It "Tests that command expansion operators can be used as a parameter to an object method. (line 1507)" {
         $result = ExecuteCommand '$test = "String";$test.SubString($("hello" | foreach-object { $_.length - 2 } ))'
-		$result | should be "ing"
+		$result | Should -Be "ing"
     }
 
 	It "Test that & can be used as a parameter as long as it is quoted. (line 1606)" {
         $result = ExecuteCommand 'testcmd-parserbvt `&get-childitem'
-		$result | should be "&get-childitem;unset;unset"
+		$result | Should -Be "&get-childitem;unset;unset"
 		$result = ExecuteCommand 'testcmd-parserbvt `&*'
-		$result | should be "&*;unset;unset"
+		$result | Should -Be "&*;unset;unset"
     }
 
 	It "Run a command with parameters. (line 1621)" {
         $result = ExecuteCommand 'testcmd-parserBVT -Property1 set'
-		$result | should be "set;unset;unset"
+		$result | Should -Be "set;unset;unset"
     }
 
 	It "Test that typing a number at the command line will return that number. (line 1630)" {
         $result = ExecuteCommand '3'
-		$result | should be "3"
-		$result.gettype() |should be ([int])
+		$result | Should -Be "3"
+		$result.gettype() |should -Be ([int])
     }
 
 	It "This test will check that an msh script can be run without invoking. (line 1641)" {
         "1">$testfile
         $result = ExecuteCommand ". $testfile"
-		$result | should be 1
+		$result | Should -Be 1
     }
 
 	It "Test that an alias is resolved before a function. (line 1657)" {
         $result = ExecuteCommand 'set-alias parserInvokeTest testcmd-parserBVT;function parserInvokeTest { 3 };parserInvokeTest'
-		$result | should be "unset;unset;unset"
+		$result | Should -Be "unset;unset;unset"
     }
 
 	It "Test that functions are resolved before cmdlets. (line 1678)"{
         $result_cmdlet = $PowerShell.AddScript('function test-parserfunc { [CmdletBinding()] Param() PROCESS { "cmdlet" } };test-parserfunc').Invoke()
         $result_func = ExecuteCommand 'function test-parserfunc { "func" };test-parserfunc'
         $PowerShell.Commands.Clear()
-        $result_cmdlet | should be "cmdlet"
-        $result_func | should be "func"
+        $result_cmdlet | Should -Be "cmdlet"
+        $result_func | Should -Be "func"
     }
 
 	It "Check that a command that uses shell execute can be run from the command line and that no exception is thrown. (line 1702)" {
@@ -610,7 +610,7 @@ foo``u{2195}abc
         else {
             "@echo Hello, I'm a Cmd script!">$shellfile
         }
-        { ExecuteCommand "$shellfile" } | Should Not Throw
+        { ExecuteCommand "$shellfile" } | Should -Not -Throw
     }
 
 	Context "Boolean Tests (starting at line 1723 to line 1772)" {
@@ -627,7 +627,7 @@ foo``u{2195}abc
 		)
         It "<Script> should return <Expected>" -TestCases $testData {
             param ( $Script, $Expected )
-            ExecuteCommand $Script | Should be $Expected
+            ExecuteCommand $Script | Should -Be $Expected
         }
     }
 
@@ -667,7 +667,7 @@ foo``u{2195}abc
 		)
         It "<Script> should return <Expected>" -TestCases $testData {
             param ( $Script, $Expected )
-            ExecuteCommand $Script | Should be $Expected
+            ExecuteCommand $Script | Should -Be $Expected
         }
     }
 
@@ -698,7 +698,7 @@ foo``u{2195}abc
         )
         It "<Script> should return <Expected>" -TestCases $testData {
             param ( $Script, $Expected )
-            ExecuteCommand $Script | Should be $Expected
+            ExecuteCommand $Script | Should -Be $Expected
         }
     }
 
@@ -713,25 +713,25 @@ foo``u{2195}abc
         )
         It "<Script> should return <Expected>" -TestCases $testData {
             param ( $Script, $Expected )
-            ExecuteCommand $Script | Should be $Expected
+            ExecuteCommand $Script | Should -Be $Expected
         }
     }
 
 	It "A simple test for trapping a specific exception. Expected Result: The exception is caught and ignored. (line 2265)" {
-        { ExecuteCommand "trap [InvalidCastException] { continue;  }; [int] 'abc'" } | Should Not Throw
+        { ExecuteCommand "trap [InvalidCastException] { continue;  }; [int] 'abc'" } | Should -Not -Throw
     }
 
 	It "Test that assign to input var and use then execute a script block with piped input. (line 2297)"{
         $result = ExecuteCommand '$input = 1,2,3;4,-5,6 | & { $input }'
-		 $result -join "" | should be (4,-5,6 -join "")
+		 $result -join "" | Should -Be (4,-5,6 -join "")
     }
 
 	It "Test that pipe objects into a script and use arguments. (line 2313)"{
 		"`$input; `$args;">$testfile
         $result = ExecuteCommand "1,2,3 | $testfile"
-		$result -join "" | should be (1, 2, 3 -join "")
+		$result -join "" | Should -Be (1, 2, 3 -join "")
 		$result = ExecuteCommand "$testfile 4 -5 6 -blah -- foo -bar"
-		$result | should be "4", "-5", "6", "-blah", "foo", "-bar"
+		$result | Should -BeExactly "4", "-5", "6", "-blah", "foo", "-bar"
     }
 
 	Context "Numerical Notations Tests (starting at line 2374 to line 2452)" {
@@ -772,13 +772,13 @@ foo``u{2195}abc
         )
         It "<Script> should return <Expected>" -TestCases $testData {
             param ( $Script, $Expected )
-            ExecuteCommand $Script | Should be $Expected
+            ExecuteCommand $Script | Should -Be $Expected
         }
     }
 
 	It "This is a simple test of the concatenation of two arrays. (line 2460)"{
         $result = ExecuteCommand '1,2,3 + 4,5,6'
-		$result -join "" | should be (1, 2, 3, 4, 5, 6 -join "")
+		$result -join "" | Should -Be (1, 2, 3, 4, 5, 6 -join "")
     }
 
 	It "Test that an incomplete parse exception is thrown if the array is unfinished. (line 2473)"{
@@ -787,7 +787,7 @@ foo``u{2195}abc
             throw "Execution OK"
         }
         catch {
-            $_.FullyQualifiedErrorId | Should be "IncompleteParseException"
+            $_.FullyQualifiedErrorId | Should -Be "IncompleteParseException"
         }
     }
 
@@ -797,7 +797,7 @@ foo``u{2195}abc
             throw "Execution OK"
         }
         catch {
-            $_.FullyQualifiedErrorId | Should be "ParseException"
+            $_.FullyQualifiedErrorId | Should -Be "ParseException"
         }
     }
 
@@ -807,20 +807,20 @@ foo``u{2195}abc
             throw "Execution OK"
         }
         catch {
-            $_.FullyQualifiedErrorId | Should be "ParseException"
+            $_.FullyQualifiedErrorId | Should -Be "ParseException"
         }
     }
 
 	It "Tests the assignment to a read-only property (line 2593)"{
 		$result = ExecuteCommand '$A=$(testcmd-parserBVT -returntype array); $A.rank =5;$A.rank'
-        $result | Should be "1"
+        $result | Should -Be "1"
     }
 
 	It 'Tests accessing using null as index. (line 2648)'{
         $PowerShell.Streams.Error.Clear()
 		ExecuteCommand '$A=$(testcmd-parserBVT -returntype array); $A[$NONEXISTING_VARIABLE];'
-        $PowerShell.HadErrors | should be $true
-        $PowerShell.Streams.Error.FullyQualifiedErrorId | should be "NullArrayIndex"
+        $PowerShell.HadErrors | Should -BeTrue
+        $PowerShell.Streams.Error.FullyQualifiedErrorId | Should -Be "NullArrayIndex"
     }
 
 	It 'Tests the parser response to ArrayName[. (line 2678)'{
@@ -829,7 +829,7 @@ foo``u{2195}abc
             throw "Execution OK"
         }
         catch {
-            $_.FullyQualifiedErrorId | Should be "ParseException"
+            $_.FullyQualifiedErrorId | Should -Be "ParseException"
         }
     }
 
@@ -839,7 +839,7 @@ foo``u{2195}abc
             throw "Execution OK"
         }
         catch {
-            $_.FullyQualifiedErrorId | Should be "ParseException"
+            $_.FullyQualifiedErrorId | Should -Be "ParseException"
         }
     }
 
@@ -851,31 +851,31 @@ foo``u{2195}abc
                 " script:func; " +
                 " global:func; ">$testfile
         $result = ExecuteCommand "function func { 'notcalled' };. $testfile"
-		$result -join "" | should be ("default", "default", "global" -join "")
+		$result -join "" | Should -Be ("default", "default", "global" -join "")
 		$result = ExecuteCommand "func"
-		$result | should be "global"
+		$result | Should -Be "global"
     }
 
 	It 'Test piping arguments to a script block. The objects should be accessible from "$input". (line 2870)'{
 		ExecuteCommand '$script = { $input; };$results = @(0,0),-1 | &$script'
 		$result = ExecuteCommand '$results[0][0]'
-        $result | Should be "0"
+        $result | Should -Be "0"
 		$result = ExecuteCommand '$results[0][1]'
-        $result | Should be "0"
+        $result | Should -Be "0"
 		$result = ExecuteCommand '$results[1]'
-        $result | Should be "-1"
+        $result | Should -Be "-1"
     }
 
 	It 'Test piping null into a scriptblock. The script block should not be passed anything. (line 2903)'{
 		$result = ExecuteCommand '$() | &{ $count = 0; foreach ($i in $input) { $count++ }; $count }'
-        $result | Should be "1"
+        $result | Should -Be "1"
 		$result = ExecuteCommand '$() | &{ $input }'
-        $result | Should BeNullOrEmpty
+        $result | Should -BeNullOrEmpty
     }
 
 	It 'Test that types in System.dll are found automatically. (line 2951)'{
 		$result = ExecuteCommand '[   System.IO.FileInfo]'
-        $result | Should be "System.IO.FileInfo"
+        $result | Should -Be "System.IO.FileInfo"
     }
 
 	Context "Mathematical Operations Tests (starting at line 2975 to line 3036)" {
@@ -892,13 +892,13 @@ foo``u{2195}abc
         )
         It "<Script> should return <Expected>" -TestCases $testData {
             param ( $Script, $Expected )
-            ExecuteCommand $Script | Should be $Expected
+            ExecuteCommand $Script | Should -Be $Expected
         }
     }
 
 	It 'This test will call a cmdlet that returns an array and assigns it to a variable.  Then it will concatenate this array with itself and check that what results is an array of double the size of the original. (line 3148)'{
 		$result = ExecuteCommand '$list=$(testcmd-parserBVT -ReturnType "array"); $list = $list + $list;$list.length'
-        $result | Should be 6
+        $result | Should -Be 6
     }
 
     It "A here string must have one line (line 3266)" {
@@ -907,12 +907,12 @@ foo``u{2195}abc
             throw "Execution OK"
         }
         catch {
-            $_.FullyQualifiedErrorId | should be "ParseException"
+            $_.FullyQualifiedErrorId | Should -Be "ParseException"
         }
     }
 
     It "A here string should not throw on '`$herestr=@`"``n'`"'``n`"@'" {
         # Issue #2780
-        { ExecuteCommand "`$herestr=@`"`n'`"'`n`"@" } | Should Not Throw
+        { ExecuteCommand "`$herestr=@`"`n'`"'`n`"@" } | Should -Not -Throw
     }
 }
diff --git a/test/powershell/Language/Parser/RedirectionOperator.Tests.ps1 b/test/powershell/Language/Parser/RedirectionOperator.Tests.ps1
index d393a03ea8..a19da65a30 100644
--- a/test/powershell/Language/Parser/RedirectionOperator.Tests.ps1
+++ b/test/powershell/Language/Parser/RedirectionOperator.Tests.ps1
@@ -39,9 +39,9 @@ Describe "Redirection operator now supports encoding changes" -Tags "CI" {
         $TXT = $encoding.GetBytes($asciiString)
         $CR  = $encoding.GetBytes($asciiCR)
         $expectedBytes = .{ $TXT; $CR }
-        $bytes.Count | should be $expectedBytes.count
+        $bytes.Count | Should -Be $expectedBytes.count
         for($i = 0; $i -lt $bytes.count; $i++) {
-            $bytes[$i] | Should be $expectedBytes[$i]
+            $bytes[$i] | Should -Be $expectedBytes[$i]
         }
     }
 
@@ -75,9 +75,9 @@ Describe "Redirection operator now supports encoding changes" -Tags "CI" {
             $observedBytes = Get-Content -AsByteStream TESTDRIVE:/file.txt
             # THE TEST
             It $msg -Skip:$skipTest {
-                $observedBytes.Count | Should be $expectedBytes.Count
+                $observedBytes.Count | Should -Be $expectedBytes.Count
                 for($i = 0;$i -lt $observedBytes.Count; $i++) {
-                    $observedBytes[$i] | Should be $expectedBytes[$i]
+                    $observedBytes[$i] | Should -Be $expectedBytes[$i]
                 }
             }
 
@@ -88,10 +88,10 @@ Describe "Redirection operator now supports encoding changes" -Tags "CI" {
 Describe "File redirection mixed with Out-Null" -Tags CI {
     It "File redirection before Out-Null should work" {
         "some text" > $TestDrive\out.txt | Out-Null
-        Get-Content $TestDrive\out.txt | Should Be "some text"
+        Get-Content $TestDrive\out.txt | Should -BeExactly "some text"
 
         echo "some more text" > $TestDrive\out.txt | Out-Null
-        Get-Content $TestDrive\out.txt | Should Be "some more text"
+        Get-Content $TestDrive\out.txt | Should -BeExactly "some more text"
     }
 }
 
@@ -106,7 +106,7 @@ Describe "File redirection should have 'DoComplete' called on the underlying pip
 
         $redirectFileContent = Get-Content $redirectFile -Raw
         $outFileContent = Get-Content $outFile -Raw
-        $redirectFileContent | Should Be $outFileContent
+        $redirectFileContent | Should -BeExactly $outFileContent
     }
 
     It "File redirection should not mess up the original pipe" {
@@ -114,13 +114,13 @@ Describe "File redirection should have 'DoComplete' called on the underlying pip
         $otherStreamFile = Join-Path $TestDrive otherstream.txt
 
         $result = & { $(Get-Command NonExist; 1234) > $outputFile *> $otherStreamFile; "Hello" }
-        $result | Should Be "Hello"
+        $result | Should -BeExactly "Hello"
 
         $outputContent = Get-Content $outputFile -Raw
-        $outputContent.Trim() | Should Be '1234'
+        $outputContent.Trim() | Should -BeExactly '1234'
 
         $errorContent = Get-Content $otherStreamFile | ForEach-Object { $_.Trim() }
         $errorContent = $errorContent -join ""
-        $errorContent | Should Match "CommandNotFoundException,Microsoft.PowerShell.Commands.GetCommandCommand"
+        $errorContent | Should -Match "CommandNotFoundException,Microsoft.PowerShell.Commands.GetCommandCommand"
     }
 }
diff --git a/test/powershell/Language/Parser/TypeAccelerator.Tests.ps1 b/test/powershell/Language/Parser/TypeAccelerator.Tests.ps1
index 217b440208..0f5c4a1a10 100644
--- a/test/powershell/Language/Parser/TypeAccelerator.Tests.ps1
+++ b/test/powershell/Language/Parser/TypeAccelerator.Tests.ps1
@@ -406,17 +406,17 @@ Describe "Type accelerators" -Tags "CI" {
         }
 
         It 'Should have all the type accelerators' {
-            $TypeAccelerators.Count | Should be $totalAccelerators
+            $TypeAccelerators.Count | Should -Be $totalAccelerators
         }
 
         It 'Should have a type accelerator for: <Accelerator>' -TestCases $TypeAcceleratorTestCases {
             param($Accelerator, $Type)
-            $TypeAcceleratorsType::Get[$Accelerator] | Should be ($Type)
+            $TypeAcceleratorsType::Get[$Accelerator] | Should -Be ($Type)
         }
     
         It 'Should have a type accelerator for non-dotnet-core type: <Accelerator>' -Skip:$IsCoreCLR -TestCases $extraFullPSAcceleratorTestCases {
             param($Accelerator, $Type)
-            $TypeAcceleratorsType::Get[$Accelerator] | Should be ($Type)
+            $TypeAcceleratorsType::Get[$Accelerator] | Should -Be ($Type)
         }
     }
     
@@ -432,13 +432,13 @@ Describe "Type accelerators" -Tags "CI" {
         }
 
         It "Basic type accelerator usage" {
-            [userDefinedAcceleratorType] | Should Be ([int])
+            [userDefinedAcceleratorType] | Should -Be ([int])
         }
 
         It "Can remove type accelerator" {
-            $TypeAcceleratorsType::Get['userDefinedAcceleratorTypeToRemove'] | Should Be ([int])
+            $TypeAcceleratorsType::Get['userDefinedAcceleratorTypeToRemove'] | Should -Be ([int])
             $TypeAcceleratorsType::Remove('userDefinedAcceleratorTypeToRemove')
-            $TypeAcceleratorsType::Get['userDefinedAcceleratorTypeToRemove'] | Should Be $null
+            $TypeAcceleratorsType::Get['userDefinedAcceleratorTypeToRemove'] | Should -BeNullOrEmpty
         }
     }
 }
diff --git a/test/powershell/Language/Parser/UsingAssembly.Tests.ps1 b/test/powershell/Language/Parser/UsingAssembly.Tests.ps1
index 3018088c16..42b33d9ea2 100644
--- a/test/powershell/Language/Parser/UsingAssembly.Tests.ps1
+++ b/test/powershell/Language/Parser/UsingAssembly.Tests.ps1
@@ -16,56 +16,56 @@ public class ABC {}
             $err = $null
             $ast = [System.Management.Automation.Language.Parser]::ParseInput("using assembly foo.dll", [ref]$null, [ref]$err)
 
-            $err.Count | Should Be 1
-            $err[0].ErrorId | Should Be ErrorLoadingAssembly
+            $err.Count | Should -Be 1
+            $err[0].ErrorId | Should -Be ErrorLoadingAssembly
         }
 
         It 'parse reports error on assembly with non-existing fully qualified name' {
             $err = $null
             $ast = [System.Management.Automation.Language.Parser]::ParseInput("using assembly 'System.Management.Automation, Version=99.0.0.0'", [ref]$null, [ref]$err)
 
-            $err.Count | Should Be 1
-            $err[0].ErrorId | Should Be ErrorLoadingAssembly
+            $err.Count | Should -Be 1
+            $err[0].ErrorId | Should -Be ErrorLoadingAssembly
         }
 
         It 'not allow UNC path' {
             $err = $null
             $ast = [System.Management.Automation.Language.Parser]::ParseInput("using assembly \\networkshare\foo.dll", [ref]$null, [ref]$err)
 
-            $err.Count | Should Be 1
-            $err[0].ErrorId | Should Be CannotLoadAssemblyFromUncPath
+            $err.Count | Should -Be 1
+            $err[0].ErrorId | Should -Be CannotLoadAssemblyFromUncPath
         }
 
         It 'not allow http path' {
             $err = $null
             $ast = [System.Management.Automation.Language.Parser]::ParseInput("using assembly http://microsoft.com/foo.dll", [ref]$null, [ref]$err)
 
-            $err.Count | Should Be 1
-            $err[0].ErrorId | Should Be CannotLoadAssemblyWithUriSchema
+            $err.Count | Should -Be 1
+            $err[0].ErrorId | Should -Be CannotLoadAssemblyWithUriSchema
         }
 
         It "parse does not load the assembly" -pending {
             $assemblies = [Appdomain]::CurrentDomain.GetAssemblies().GetName().Name
-            $assemblies -contains "UsingAssemblyTest$guid" | Should Be $false
+            $assemblies -contains "UsingAssemblyTest$guid" | Should -BeFalse
 
             $err = $null
             $ast = [System.Management.Automation.Language.Parser]::ParseInput("using assembly .\UsingAssemblyTest$guid.dll", [ref]$null, [ref]$err)
 
             $assemblies = [Appdomain]::CurrentDomain.GetAssemblies().GetName().Name
-            $assemblies -contains "UsingAssemblyTest$guid" | Should Be $false
-            $err.Count | Should Be 0
+            $assemblies -contains "UsingAssemblyTest$guid" | Should -BeFalse
+            $err.Count | Should -Be 0
 
             $ast = [System.Management.Automation.Language.Parser]::ParseInput("using assembly '$PSScriptRoot\UsingAssemblyTest$guid.dll'", [ref]$null, [ref]$err)
 
             $assemblies = [Appdomain]::CurrentDomain.GetAssemblies().GetName().Name
-            $assemblies -contains "UsingAssemblyTest$guid" | Should Be $false
-            $err.Count | Should Be 0
+            $assemblies -contains "UsingAssemblyTest$guid" | Should -BeFalse
+            $err.Count | Should -Be 0
 
             $ast = [System.Management.Automation.Language.Parser]::ParseInput("using assembly `"$PSScriptRoot\UsingAssemblyTest$guid.dll`"", [ref]$null, [ref]$err)
 
             $assemblies = [Appdomain]::CurrentDomain.GetAssemblies().GetName().Name
-            $assemblies -contains "UsingAssemblyTest$guid" | Should Be $false
-            $err.Count | Should Be 0
+            $assemblies -contains "UsingAssemblyTest$guid" | Should -BeFalse
+            $err.Count | Should -Be 0
         }
 
         It "reports runtime error about non-existing assembly with relative path" {
@@ -74,10 +74,10 @@ public class ABC {}
                 [scriptblock]::Create("using assembly .\NonExistingAssembly.dll")
                 $failed = $false
             } catch {
-                $_.FullyQualifiedErrorId | Should be 'ParseException'
-                $_.Exception.InnerException.ErrorRecord.FullyQualifiedErrorId | Should be 'ErrorLoadingAssembly'
+                $_.FullyQualifiedErrorId | Should -Be 'ParseException'
+                $_.Exception.InnerException.ErrorRecord.FullyQualifiedErrorId | Should -Be 'ErrorLoadingAssembly'
             }
-            $failed | Should be $true
+            $failed | Should -BeTrue
         }
 #>
         It "Assembly loaded at runtime" -pending {
@@ -85,25 +85,25 @@ public class ABC {}
     using assembly .\UsingAssemblyTest$guid.dll
     [Appdomain]::CurrentDomain.GetAssemblies().GetName().Name
 "@
-            $assemblies -contains "UsingAssemblyTest$guid" | Should Be $true
+            $assemblies -contains "UsingAssemblyTest$guid" | Should -BeTrue
 
             $assemblies = pwsh -noprofile -command @"
     using assembly $PSScriptRoot\UsingAssemblyTest$guid.dll
     [Appdomain]::CurrentDomain.GetAssemblies().GetName().Name
 "@
-            $assemblies -contains "UsingAssemblyTest$guid" | Should Be $true
+            $assemblies -contains "UsingAssemblyTest$guid" | Should -BeTrue
 
             $assemblies = pwsh -noprofile -command @"
     using assembly System.Drawing
     [Appdomain]::CurrentDomain.GetAssemblies().GetName().Name
 "@
-            $assemblies -contains "System.Drawing" | Should Be $true
+            $assemblies -contains "System.Drawing" | Should -BeTrue
 
             $assemblies = pwsh -noprofile -command @"
     using assembly 'System.Drawing, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a'
     [Appdomain]::CurrentDomain.GetAssemblies().GetName().Name
 "@
-            $assemblies -contains "System.Drawing" | Should Be $true
+            $assemblies -contains "System.Drawing" | Should -BeTrue
         }
     }
     finally
diff --git a/test/powershell/Language/Parser/UsingNamespace.Tests.ps1 b/test/powershell/Language/Parser/UsingNamespace.Tests.ps1
index 2167560661..caeb570013 100644
--- a/test/powershell/Language/Parser/UsingNamespace.Tests.ps1
+++ b/test/powershell/Language/Parser/UsingNamespace.Tests.ps1
@@ -42,22 +42,22 @@ class C2
 
 Describe "Using Namespace" -Tags "CI" {
     It "Type literals w/ using namespace" {
-        [Thread].FullName | Should Be System.Threading.Thread
-        [Int32].FullName | Should Be System.Int32
+        [Thread].FullName | Should -Be System.Threading.Thread
+        [Int32].FullName | Should -Be System.Int32
         #[ElapsedEventHandler].FullName | Should Be System.Timers.ElapsedEventHandler
 
-        [C1].GetProperty("Thread").PropertyType.FullName | Should Be System.Threading.Thread
-        [C1].GetProperty("Int").PropertyType.FullName | Should Be System.Int32
+        [C1].GetProperty("Thread").PropertyType.FullName | Should -Be System.Threading.Thread
+        [C1].GetProperty("Int").PropertyType.FullName | Should -Be System.Int32
         # [C1].GetProperty("EventHandler").PropertyType.FullName | Should Be System.Timers.ElapsedEventHandler
     }
 
     It "Covert string to Type w/ using namespace" {
-        ("Thread" -as [Type]).FullName | Should Be System.Threading.Thread
-        ("Int32" -as [Type]).FullName | Should Be System.Int32
+        ("Thread" -as [Type]).FullName | Should -Be System.Threading.Thread
+        ("Int32" -as [Type]).FullName | Should -Be System.Int32
         # ("ElapsedEventHandler" -as [Type]).FullName | Should Be System.Timers.ElapsedEventHandler
 
-        New-Object Int32 | Should Be 0
-        New-Object CompilerGeneratedAttribute | Should Be System.Runtime.CompilerServices.CompilerGeneratedAttribute
+        New-Object Int32 | Should -Be 0
+        New-Object CompilerGeneratedAttribute | Should -Be System.Runtime.CompilerServices.CompilerGeneratedAttribute
     }
 
     It "Attributes w/ using namespace" -pending {
@@ -75,24 +75,24 @@ Describe "Using Namespace" -Tags "CI" {
             "OK"
         }
 
-        foo | Should Be OK
+        foo | Should -Be OK
         $cmdInfo = gcm foo
-        $cmdInfo.ScriptBlock.Attributes[0] | Should Be System.Diagnostics.DebuggerStepThroughAttribute
-        $cmdInfo.Parameters['a'].Attributes[1] | Should Be System.Runtime.CompilerServices.CompilerGeneratedAttribute
-        $cmdInfo.Parameters['b'].Attributes[1] | Should Be System.Runtime.CompilerServices.CompilerGeneratedAttribute
+        $cmdInfo.ScriptBlock.Attributes[0] | Should -Be System.Diagnostics.DebuggerStepThroughAttribute
+        $cmdInfo.Parameters['a'].Attributes[1] | Should -Be System.Runtime.CompilerServices.CompilerGeneratedAttribute
+        $cmdInfo.Parameters['b'].Attributes[1] | Should -Be System.Runtime.CompilerServices.CompilerGeneratedAttribute
 
-        [C1].GetProperty("Thread").GetCustomAttributesData()[0].AttributeType.FullName | Should Be System.Runtime.CompilerServices.CompilerGeneratedAttribute
-        [C1].GetProperty("Int").GetCustomAttributesData()[0].AttributeType.FullName | Should Be System.Runtime.CompilerServices.CompilerGeneratedAttribute
+        [C1].GetProperty("Thread").GetCustomAttributesData()[0].AttributeType.FullName | Should -Be System.Runtime.CompilerServices.CompilerGeneratedAttribute
+        [C1].GetProperty("Int").GetCustomAttributesData()[0].AttributeType.FullName | Should -Be System.Runtime.CompilerServices.CompilerGeneratedAttribute
         # [C1].GetProperty("EventHandler").GetCustomAttributesData()[0].AttributeType.FullName | Should Be System.Runtime.CompilerServices.CompilerGeneratedAttribute
 
-        [C2].GetProperty("Thread").GetCustomAttributesData()[0].AttributeType.FullName | Should Be System.Runtime.CompilerServices.CompilerGeneratedAttribute
-        [C2].GetProperty("Int").GetCustomAttributesData()[0].AttributeType.FullName | Should Be System.Runtime.CompilerServices.CompilerGeneratedAttribute
+        [C2].GetProperty("Thread").GetCustomAttributesData()[0].AttributeType.FullName | Should -Be System.Runtime.CompilerServices.CompilerGeneratedAttribute
+        [C2].GetProperty("Int").GetCustomAttributesData()[0].AttributeType.FullName | Should -Be System.Runtime.CompilerServices.CompilerGeneratedAttribute
         # [C2].GetProperty("EventHandler").GetCustomAttributesData()[0].AttributeType.FullName | Should Be System.Runtime.CompilerServices.CompilerGeneratedAttribute
 
-        [C1].GetCustomAttributesData()[0].AttributeType.FullName | Should Be System.Runtime.CompilerServices.CompilerGeneratedAttribute
-        [C2].GetCustomAttributesData()[0].AttributeType.FullName | Should Be System.Runtime.CompilerServices.CompilerGeneratedAttribute
+        [C1].GetCustomAttributesData()[0].AttributeType.FullName | Should -Be System.Runtime.CompilerServices.CompilerGeneratedAttribute
+        [C2].GetCustomAttributesData()[0].AttributeType.FullName | Should -Be System.Runtime.CompilerServices.CompilerGeneratedAttribute
 
-        [E1].GetCustomAttributesData()[0].AttributeType.FullName | Should Be System.FlagsAttribute
+        [E1].GetCustomAttributesData()[0].AttributeType.FullName | Should -Be System.FlagsAttribute
     }
 
     It "Ambiguous type reference" {
@@ -102,7 +102,7 @@ Describe "Using Namespace" -Tags "CI" {
     It "Parameters" {
         function foo([Thread]$t = $null) { 42 }
 
-        foo | Should Be 42
+        foo | Should -Be 42
 
         $mod = New-Module -Name UsingNamespaceModule -ScriptBlock {
             function Set-Thread([Thread]$t = $null)
@@ -111,14 +111,14 @@ Describe "Using Namespace" -Tags "CI" {
             }
         }
         Import-Module $mod
-        Set-Thread | Should Be 44
+        Set-Thread | Should -Be 44
         Remove-Module $mod
     }
 
     It "Generics" {
         function foo([List[string]]$l)
         {
-            $l | Should Be "a string"
+            $l | Should -Be "a string"
         }
 
         $l = [List[string]]::new()
diff --git a/test/powershell/Language/Scripting/ActionPreference.Tests.ps1 b/test/powershell/Language/Scripting/ActionPreference.Tests.ps1
index bdb1938e48..f9fbf3f5e2 100644
--- a/test/powershell/Language/Scripting/ActionPreference.Tests.ps1
+++ b/test/powershell/Language/Scripting/ActionPreference.Tests.ps1
@@ -19,18 +19,18 @@ Describe "Tests for (error, warning, etc) action preference" -Tags "CI" {
             }
             catch {}
 
-            It '$err.Count' { $err.Count | Should Be 1 }
-            It '$err[0] should not be $null' { $err[0] | Should Not Be $null }
-            It '$err[0].GetType().Name' { $err[0] | Should BeOfType "System.Management.Automation.ActionPreferenceStopException" }
-            It '$err[0].ErrorRecord' { $err[0].ErrorRecord | Should not BeNullOrEmpty }
-            It '$err[0].ErrorRecord.Exception.GetType().Name' { $err[0].ErrorRecord.Exception | Should BeOfType "System.Management.Automation.ItemNotFoundException" }
+            It '$err.Count' { $err.Count | Should -Be 1 }
+            It '$err[0] should not be $null' { $err[0] | Should -Not -BeNullOrEmpty }
+            It '$err[0].GetType().Name' { $err[0] | Should -BeOfType "System.Management.Automation.ActionPreferenceStopException" }
+            It '$err[0].ErrorRecord' { $err[0].ErrorRecord | Should -Not -BeNullOrEmpty }
+            It '$err[0].ErrorRecord.Exception.GetType().Name' { $err[0].ErrorRecord.Exception | Should -BeOfType "System.Management.Automation.ItemNotFoundException" }
         }
 
         It 'ActionPreference Ignore Works' {
             $errorCount = $error.Count
             Get-Process -Name asdfasdfsadfsadf -ErrorAction Ignore
 
-            $error.Count | Should Be $errorCount
+            $error.Count | Should -BeExactly $errorCount
         }
 
         It 'action preference of Ignore cannot be set as a preference variable' {
@@ -39,7 +39,7 @@ Describe "Tests for (error, warning, etc) action preference" -Tags "CI" {
                 Get-Process -Name asdfasdfasdf
                 Throw "Exception expected, execution should not have reached here"
              } catch {
-                     $_.CategoryInfo.Reason | Should Be NotSupportedException
+                     $_.CategoryInfo.Reason | Should -BeExactly 'NotSupportedException'
              } finally {
                 $GLOBAL:errorActionPreference = $orgin
              }
@@ -52,7 +52,7 @@ Describe "Tests for (error, warning, etc) action preference" -Tags "CI" {
                     Get-Process -Name asdfasdfasdf
                     Throw "Exception expected, execution should not have reached here"
                 } catch {
-                    $_.CategoryInfo.Reason | Should Be ArgumentTransformationMetadataException
+                    $_.CategoryInfo.Reason | Should -BeExactly 'ArgumentTransformationMetadataException'
                 }
                 finally {
                     $GLOBAL:errorActionPreference = $orgin
@@ -63,7 +63,7 @@ Describe "Tests for (error, warning, etc) action preference" -Tags "CI" {
             $errorCount = $error.Count
             Get-Process -Name asdfasdfsadfsadf -ErrorAction Ig
 
-            $error.Count | Should Be $errorCount
+            $error.Count | Should -BeExactly $errorCount
         }
 
         It 'ErrorAction = Suspend works on Workflow' -Skip:$IsCoreCLR {
@@ -83,7 +83,7 @@ Describe "Tests for (error, warning, etc) action preference" -Tags "CI" {
                 MyHelperFunction -ErrorAction Suspend
                 Throw "Exception expected, execution should not have reached here"
             } catch {
-                $_.FullyQualifiedErrorId | Should Be "ParameterBindingFailed,MyHelperFunction"
+                $_.FullyQualifiedErrorId | Should -BeExactly "ParameterBindingFailed,MyHelperFunction"
             }
         }
 
@@ -94,7 +94,7 @@ Describe "Tests for (error, warning, etc) action preference" -Tags "CI" {
                 Throw "Exception expected, execution should not have reached here"
             }
             catch {
-                $_.FullyQualifiedErrorId | Should Be "ParameterBindingFailed,Microsoft.PowerShell.Commands.GetProcessCommand"
+                $_.FullyQualifiedErrorId | Should -BeExactly "ParameterBindingFailed,Microsoft.PowerShell.Commands.GetProcessCommand"
             }
         }
 
@@ -105,7 +105,7 @@ Describe "Tests for (error, warning, etc) action preference" -Tags "CI" {
                 Throw "Exception expected, execution should not have reached here"
             }
             catch {
-                $_.FullyQualifiedErrorId | Should Be "ParameterBindingFailed,Microsoft.PowerShell.Commands.GetProcessCommand"
+                $_.FullyQualifiedErrorId | Should -BeExactly "ParameterBindingFailed,Microsoft.PowerShell.Commands.GetProcessCommand"
             }
         }
 
@@ -122,11 +122,11 @@ Describe "Tests for (error, warning, etc) action preference" -Tags "CI" {
                         try {
                             Write-Output @input
                             } catch {
-                                $_.FullyQualifiedErrorId | Should Be "ParameterBindingFailed,Microsoft.PowerShell.Commands.WriteOutputCommand"
+                                $_.FullyQualifiedErrorId | Should -BeExactly "ParameterBindingFailed,Microsoft.PowerShell.Commands.WriteOutputCommand"
                                 $num++
                             }
                     }
-            $num | Should Be 2
+            $num | Should -Be 2
         }
 
         It '<switch> does not take precedence over $ErrorActionPreference' -TestCases @(
@@ -142,7 +142,7 @@ Describe "Tests for (error, warning, etc) action preference" -Tags "CI" {
             }
             New-Item @params > $null
             $params += @{$switch=$true}
-            { New-Item @params } | Should Not Throw
+            { New-Item @params } | Should -Not -Throw
             $ErrorActionPreference = "Stop"
             { New-Item @params } | ShouldBeErrorId "NewItemIOError,Microsoft.PowerShell.Commands.NewItemCommand"
             Remove-Item "$testdrive\test.txt" -Force
diff --git a/test/powershell/Language/Scripting/Array.Tests.ps1 b/test/powershell/Language/Scripting/Array.Tests.ps1
index d2d2013b78..35d099c8dc 100644
--- a/test/powershell/Language/Scripting/Array.Tests.ps1
+++ b/test/powershell/Language/Scripting/Array.Tests.ps1
@@ -3,76 +3,76 @@
 Describe "ArrayExpression Tests" -Tags "CI" {
     It "@([object[]](1,2,3)) should return a 3-element array of object[]" {
         $result = @([object[]](1,2,3))
-        $result.GetType().FullName | Should Be "System.Object[]"
-        $result.Length | Should Be 3
+        $result.GetType().FullName | Should -BeExactly "System.Object[]"
+        $result.Length | Should -Be 3
     }
 
     It "@([int[]](1,2,3)) should return a 3-element array of object[]" {
         $result = @([int[]](1,2,3))
-        $result.GetType().FullName | Should Be "System.Object[]"
-        $result.Length | Should Be 3
+        $result.GetType().FullName | Should -BeExactly "System.Object[]"
+        $result.Length | Should -Be 3
     }
 
     It "@([object[]]`$null) should return a 1-element(`$null) array of object[]" {
         $result = @([object[]]$null)
-        $result.GetType().FullName | Should Be "System.Object[]"
-        $result.Length | Should Be 1
-        $result[0] | Should Be $null
+        $result.GetType().FullName | Should -BeExactly "System.Object[]"
+        $result.Length | Should -Be 1
+        $result[0] | Should -BeNullOrEmpty
     }
 
     It "@([int[]]`$null) should return a 1-element(`$null) array of object[]" {
         $result = @([int[]]$null)
-        $result.GetType().FullName | Should Be "System.Object[]"
-        $result.Length | Should Be 1
-        $result[0] | Should Be $null
+        $result.GetType().FullName | Should -BeExactly "System.Object[]"
+        $result.Length | Should -Be 1
+        $result[0] | Should -BeNullOrEmpty
     }
 
     It "@([object[]][System.Management.Automation.Internal.AutomationNull]::Value) should return a 1-element(`$null) array of object[]" {
         $result = @([object[]][System.Management.Automation.Internal.AutomationNull]::Value)
-        $result.GetType().FullName | Should Be "System.Object[]"
-        $result.Length | Should Be 1
-        $result[0] | Should Be $null
+        $result.GetType().FullName | Should -BeExactly "System.Object[]"
+        $result.Length | Should -Be 1
+        $result[0] | Should -BeNullOrEmpty
     }
 
     It "@([int[]][System.Management.Automation.Internal.AutomationNull]::Value) should return a 1-element(`$null) array of object[]" {
         $result = @([int[]][System.Management.Automation.Internal.AutomationNull]::Value)
-        $result.GetType().FullName | Should Be "System.Object[]"
-        $result.Length | Should Be 1
-        $result[0] | Should Be $null
+        $result.GetType().FullName | Should -BeExactly "System.Object[]"
+        $result.Length | Should -Be 1
+        $result[0] | Should -BeNullOrEmpty
     }
 
     It "@(`$null) should return a 1-element(`$null) array of object[]" {
         $result = @($null)
-        $result.GetType().FullName | Should Be "System.Object[]"
-        $result.Length | Should Be 1
-        $result[0] | Should Be $null
+        $result.GetType().FullName | Should -BeExactly "System.Object[]"
+        $result.Length | Should -Be 1
+        $result[0] | Should -BeNullOrEmpty
     }
 
     It "@([System.Management.Automation.Internal.AutomationNull]::Value) should return an empty array of object[]" {
         $result = @([System.Management.Automation.Internal.AutomationNull]::Value)
-        $result.GetType().FullName | Should Be "System.Object[]"
-        $result.Length | Should Be 0
+        $result.GetType().FullName | Should -BeExactly "System.Object[]"
+        $result.Length | Should -Be 0
     }
 
     It "@([object[]]`$a) should return a new array" {
         $a = 1,2,3
         $result = @([object[]]$a)
-        $result.GetType().FullName | Should Be "System.Object[]"
-        $result.Length | Should Be 3
+        $result.GetType().FullName | Should -BeExactly "System.Object[]"
+        $result.Length | Should -Be 3
     }
 
     It "@([int[]]`$a) should return a new array" {
         $a = 1,2,3
         $result = @([int[]]$a)
-        $result.GetType().FullName | Should Be "System.Object[]"
-        $result.Length | Should Be 3
+        $result.GetType().FullName | Should -BeExactly "System.Object[]"
+        $result.Length | Should -Be 3
     }
 
     It "@([System.Collections.Generic.List[object]]`$null) should return a 1-element(`$null) array of object[]" {
         $result = @([System.Collections.Generic.List[object]]$null)
-        $result.GetType().FullName | Should Be "System.Object[]"
-        $result.Length | Should Be 1
-        $result[0] | Should Be $null
+        $result.GetType().FullName | Should -BeExactly "System.Object[]"
+        $result.Length | Should -Be 1
+        $result[0] | Should -BeNullOrEmpty
     }
 
     It "@([void](New-Item)) should create file" {
@@ -80,9 +80,9 @@ Describe "ArrayExpression Tests" -Tags "CI" {
             $testFile = Join-Path $TestDrive (New-Guid)
             $result = @([void](New-Item $testFile -ItemType File))
             ## file should be created
-            $testFile | Should Exist
+            $testFile | Should -Exist
             ## the array should be empty
-            $result.Count | Should Be 0
+            $result.Count | Should -Be 0
         } finally {
             Remove-Item $testFile -Force -ErrorAction SilentlyContinue
         }
@@ -95,13 +95,13 @@ Describe "ArrayLiteral Tests" -Tags "CI" {
             $testFile = Join-Path $TestDrive (New-Guid)
             $result = [void](New-Item $testFile -ItemType File), 2, 3
             ## file should be created
-            $testFile | Should Exist
+            $testFile | Should -Exist
             ## the array should contain 3 items
-            $result.Count | Should Be 3
+            $result.Count | Should -Be 3
 
             ## the first item should be AutomationNull
-            $result[0] | ForEach-Object { "YES" } | Should Be $null
-            $result | Measure-Object | ForEach-Object -MemberName Count | Should Be 2
+            $result[0] | ForEach-Object { "YES" } | Should -BeNullOrEmpty
+            $result | Measure-Object | ForEach-Object -MemberName Count | Should -Be 2
         } finally{
             Remove-Item $testFile -Force -ErrorAction SilentlyContinue
         }
@@ -112,12 +112,12 @@ Describe "ArrayLiteral Tests" -Tags "CI" {
             $testFile = Join-Path $TestDrive (New-Guid)
             $result = [void]1, [void](New-Item $testFile -ItemType File), [void]2
             ## file should be created
-            $testFile | Should Exist
+            $testFile | Should -Exist
             ## the array should contain 3 items
-            $result.Count | Should Be 3
+            $result.Count | Should -Be 3
 
             ## all items should be AutomationNull
-            $result | ForEach-Object { "YES" } | Should Be $null
+            $result | ForEach-Object { "YES" } | Should -BeNullOrEmpty
         } finally {
             Remove-Item $testFile -Force -ErrorAction SilentlyContinue
         }
@@ -128,17 +128,17 @@ Describe "ArrayLiteral Tests" -Tags "CI" {
         $arraylist2 = [System.Collections.ArrayList]::new()
 
         $arraylist2.Add(2) > $null
-        $arraylist2.Count | Should Be 1
+        $arraylist2.Count | Should -Be 1
 
         ## first item is a non-void method call
         ## second item is a void method call
         $result = [void]$arraylist1.Add(1), $arraylist2.Clear()
-        $result.Count | Should Be 2
-        $result | ForEach-Object { "YES" } | Should Be $null
+        $result.Count | Should -Be 2
+        $result | ForEach-Object { "YES" } | Should -BeNullOrEmpty
 
-        $arraylist1.Count | Should Be 1
-        $arraylist1[0] | Should Be 1
+        $arraylist1.Count | Should -Be 1
+        $arraylist1[0] | Should -Be 1
 
-        $arraylist2.Count | Should Be 0
+        $arraylist2.Count | Should -Be 0
     }
 }
diff --git a/test/powershell/Language/Scripting/CheckRestrictedlanguage.Tests.ps1 b/test/powershell/Language/Scripting/CheckRestrictedlanguage.Tests.ps1
index 93fdf966c7..11c988af65 100644
--- a/test/powershell/Language/Scripting/CheckRestrictedlanguage.Tests.ps1
+++ b/test/powershell/Language/Scripting/CheckRestrictedlanguage.Tests.ps1
@@ -16,12 +16,12 @@ Describe "Test restricted language check method on scriptblocks" -Tags "CI" {
 
         It 'Check basic expressions' {
 
-            {{2+2}.CheckRestrictedLanguage($null, $null, $false) } | Should Not Throw  # Succeed with no variables
+            {{2+2}.CheckRestrictedLanguage($null, $null, $false) } | Should -Not -Throw  # Succeed with no variables
         }
 
         It 'Check default variables' {
 
-            {{ $PSCulture, $PSUICulture, $true, $false, $null}.CheckRestrictedLanguage($null, $null, $false) } | Should Not Throw
+            {{ $PSCulture, $PSUICulture, $true, $false, $null}.CheckRestrictedLanguage($null, $null, $false) } | Should -Not -Throw
         }
 
         It 'Check default variables' {
@@ -33,24 +33,24 @@ Describe "Test restricted language check method on scriptblocks" -Tags "CI" {
             }
             catch
             {
-                $_.FullyQualifiedErrorId | Should Be 'ParseException'
+                $_.FullyQualifiedErrorId | Should -BeExactly 'ParseException'
             }
 
         }
 
         It 'Check union of default + one allowed variables' {
 
-            { { 2 + $a }.CheckRestrictedLanguage($null, (list a), $false) }| Should Not Throw  # succeed
+            { { 2 + $a }.CheckRestrictedLanguage($null, (list a), $false) }| Should -Not -Throw  # succeed
         }
 
         It 'Check union of default + two allowed variables' {
 
-            { { $a + $b }.CheckRestrictedLanguage($null, (list a b), $false) } | Should Not Throw  # succeed
+            { { $a + $b }.CheckRestrictedLanguage($null, (list a b), $false) } | Should -Not -Throw  # succeed
         }
 
         It 'Check union of default + allowed variables' {
 
-            { { $PSCulture, $PSUICulture, $true, $false, $null,  $a, $b}.CheckRestrictedLanguage($null, (list a b), $false) }| Should Not Throw
+            { { $PSCulture, $PSUICulture, $true, $false, $null,  $a, $b}.CheckRestrictedLanguage($null, (list a b), $false) }| Should -Not -Throw
         }
 
         It 'Check union of default + one disallowed variables' {
@@ -62,7 +62,7 @@ Describe "Test restricted language check method on scriptblocks" -Tags "CI" {
             }
             catch
             {
-                $_.FullyQualifiedErrorId | Should Be 'ParseException'
+                $_.FullyQualifiedErrorId | Should -BeExactly 'ParseException'
             }
         }
 
@@ -75,18 +75,18 @@ Describe "Test restricted language check method on scriptblocks" -Tags "CI" {
             }
             catch
             {
-                $_.FullyQualifiedErrorId | Should Be 'ParseException'
+                $_.FullyQualifiedErrorId | Should -BeExactly 'ParseException'
             }
         }
 
         It 'Check union of default + one allowed variable name and allow environment variable ' {
 
-            {{ 2 + $a + $env:foo }.CheckRestrictedLanguage($null, (list a), $true)}   | Should Not Throw # succeed
+            {{ 2 + $a + $env:foo }.CheckRestrictedLanguage($null, (list a), $true)}   | Should -Not -Throw # succeed
         }
 
         It 'Check that wildcard allows env even if the flag is set to false' {
 
-            { { 2 + $a + $b + $c + $env:foo }.CheckRestrictedLanguage($null, (list *), $false)} | Should Not Throw   # succeed
+            { { 2 + $a + $b + $c + $env:foo }.CheckRestrictedLanguage($null, (list *), $false)} | Should -Not -Throw   # succeed
         }
 
         It 'Check for restricted commands' {
@@ -98,15 +98,15 @@ Describe "Test restricted language check method on scriptblocks" -Tags "CI" {
             }
             catch
             {
-                $_.FullyQualifiedErrorId | Should Be 'MethodNotFound'
+                $_.FullyQualifiedErrorId | Should -BeExactly 'MethodNotFound'
             }
         }
 
         It 'Check for allowed commands and variables' {
 
-            { { get-process | where name -match $pattern | foreach $prop }.CheckRestrictedLanguage(
+            { { get-process | where name -Match $pattern | foreach $prop }.CheckRestrictedLanguage(
                 (list get-process where foreach),
                 (list prop pattern)
-                , $false) }| Should Not Throw
+                , $false) }| Should -Not -Throw
         }
 }
diff --git a/test/powershell/Language/Scripting/CmdletDeclaration.Tests.ps1 b/test/powershell/Language/Scripting/CmdletDeclaration.Tests.ps1
index 732d47a702..1ede3b76d8 100644
--- a/test/powershell/Language/Scripting/CmdletDeclaration.Tests.ps1
+++ b/test/powershell/Language/Scripting/CmdletDeclaration.Tests.ps1
@@ -116,7 +116,7 @@ Describe "Cmdlet declaration statement" -Tags "CI" {
             $null = [system.management.automation.psparser]::tokenize($script, [ref] $syntaxerrors)
 
             #Error should not be reported
-            $syntaxerrors.Count | Should Be 0
+            $syntaxerrors.Count | Should -Be 0
         }
 }
 
diff --git a/test/powershell/Language/Scripting/CommonParameters.Tests.ps1 b/test/powershell/Language/Scripting/CommonParameters.Tests.ps1
index 51c88a9c0c..955e922786 100644
--- a/test/powershell/Language/Scripting/CommonParameters.Tests.ps1
+++ b/test/powershell/Language/Scripting/CommonParameters.Tests.ps1
@@ -32,8 +32,8 @@ Describe "Common parameters support for script cmdlets" -Tags "CI" {
             $asyncResult = $ps.BeginInvoke()
             $output = $ps.EndInvoke($asyncResult)
 
-            $output[0] | Should be "output foo"
-            $ps.Streams.Debug.Count | Should Be 0
+            $output[0] | Should -BeExactly "output foo"
+            $ps.Streams.Debug.Count | Should -Be 0
         }
 
         It 'get-foo -debug' {
@@ -42,9 +42,9 @@ Describe "Common parameters support for script cmdlets" -Tags "CI" {
             $asyncResult = $ps.BeginInvoke()
             $output = $ps.EndInvoke($asyncResult)
 
-            $output[0] | Should Be "output foo"
-            $ps.Streams.Debug[0].Message | Should Be "debug foo"
-            $ps.InvocationStateInfo.State | Should Be 'Completed'
+            $output[0] | Should -BeExactly "output foo"
+            $ps.Streams.Debug[0].Message | Should -BeExactly "debug foo"
+            $ps.InvocationStateInfo.State | Should -BeExactly 'Completed'
         }
     }
 
@@ -67,8 +67,8 @@ Describe "Common parameters support for script cmdlets" -Tags "CI" {
             $asyncResult = $ps.BeginInvoke()
             $output = $ps.EndInvoke($asyncResult)
 
-            $output[0] | Should Be "output foo"
-            $ps.streams.verbose.Count | Should Be 0
+            $output[0] | Should -BeExactly "output foo"
+            $ps.streams.verbose.Count | Should -Be 0
         }
 
         It 'get-foo -verbose' {
@@ -78,9 +78,9 @@ Describe "Common parameters support for script cmdlets" -Tags "CI" {
             $asyncResult = $ps.BeginInvoke()
             $output = $ps.EndInvoke($asyncResult)
 
-            $output[0] | Should Be "output foo"
-            $ps.Streams.verbose[0].Message | Should Be "verbose foo"
-            $ps.InvocationStateInfo.State | Should Be 'Completed'
+            $output[0] | Should -BeExactly "output foo"
+            $ps.Streams.verbose[0].Message | Should -BeExactly "verbose foo"
+            $ps.InvocationStateInfo.State | Should -BeExactly 'Completed'
         }
     }
 
@@ -104,8 +104,8 @@ Describe "Common parameters support for script cmdlets" -Tags "CI" {
             $asyncResult = $ps.BeginInvoke()
             $output = $ps.EndInvoke($asyncResult)
 
-            $output[0] | Should Be "output foo"
-            $ps.Streams.error[0].ToString() | Should match "error foo"
+            $output[0] | Should -BeExactly "output foo"
+            $ps.Streams.error[0].ToString() | Should -Match "error foo"
         }
 
         It 'erroraction continue' {
@@ -115,8 +115,8 @@ Describe "Common parameters support for script cmdlets" -Tags "CI" {
             $asyncResult = $ps.BeginInvoke()
             $output = $ps.EndInvoke($asyncResult)
 
-            $output[0] | Should Be "output foo"
-            $ps.Streams.error[0].ToString() | Should match "error foo"
+            $output[0] | Should -BeExactly "output foo"
+            $ps.Streams.error[0].ToString() | Should -Match "error foo"
         }
 
         It 'erroraction SilentlyContinue' {
@@ -126,8 +126,8 @@ Describe "Common parameters support for script cmdlets" -Tags "CI" {
             $asyncResult = $ps.BeginInvoke()
             $output = $ps.EndInvoke($asyncResult)
 
-            $output[0] | Should Be "output foo"
-            $ps.streams.error.count | Should Be 0
+            $output[0] | Should -BeExactly "output foo"
+            $ps.streams.error.count | Should -Be 0
         }
 
         It 'erroraction Stop' {
@@ -143,13 +143,13 @@ Describe "Common parameters support for script cmdlets" -Tags "CI" {
                 Throw "Exception expected, execution should not have reached here"
             }
             catch {
-                $_.FullyQualifiedErrorId | Should Be "ActionPreferenceStopException"
+                $_.FullyQualifiedErrorId | Should -BeExactly "ActionPreferenceStopException"
             } # Exception: "Command execution stopped because the preference variable "ErrorActionPreference" or common parameter is set to Stop: error foo"
 
             # BUG in runspace api.
             #$ps.error.count | Should Be 1
 
-            $ps.InvocationStateInfo.State | Should Be 'Failed'
+            $ps.InvocationStateInfo.State | Should -BeExactly 'Failed'
         }
     }
 
@@ -175,7 +175,7 @@ Describe "Common parameters support for script cmdlets" -Tags "CI" {
             $asyncResult = $ps.BeginInvoke()
             $output = $ps.EndInvoke($asyncResult)
 
-            $output[0] | Should Be 'foo action'
+            $output[0] | Should -BeExactly 'foo action'
         }
 
         It 'shouldprocess support -whatif' {
@@ -187,7 +187,7 @@ Describe "Common parameters support for script cmdlets" -Tags "CI" {
             $asyncResult = $ps.BeginInvoke()
             $output = $ps.EndInvoke($asyncResult)
 
-            $ps.InvocationStateInfo.State | Should Be 'Completed'
+            $ps.InvocationStateInfo.State | Should -BeExactly 'Completed'
         }
 
         It 'shouldprocess support -confirm under the non-interactive host' {
@@ -198,8 +198,8 @@ Describe "Common parameters support for script cmdlets" -Tags "CI" {
             $asyncResult = $ps.BeginInvoke()
             $ps.EndInvoke($asyncResult)
 
-            $ps.Streams.Error.Count | Should Be 1 # the host does not implement it.
-            $ps.InvocationStateInfo.State | Should Be 'Completed'
+            $ps.Streams.Error.Count | Should -Be 1 # the host does not implement it.
+            $ps.InvocationStateInfo.State | Should -BeExactly 'Completed'
         }
     }
 
@@ -224,7 +224,7 @@ Describe "Common parameters support for script cmdlets" -Tags "CI" {
             $asyncResult = $ps.BeginInvoke()
             $output = $ps.EndInvoke($asyncResult)
 
-            $output[0] | Should Be 'foo action'
+            $output[0] | Should -BeExactly 'foo action'
         }
 
         It 'get-foo -confirm' {
@@ -233,7 +233,7 @@ Describe "Common parameters support for script cmdlets" -Tags "CI" {
             $asyncResult = $ps.BeginInvoke()
             $output = $ps.EndInvoke($asyncResult)
 
-            $output[0] | Should Be 'foo action'
+            $output[0] | Should -BeExactly 'foo action'
         }
     }
 
@@ -257,7 +257,7 @@ Describe "Common parameters support for script cmdlets" -Tags "CI" {
             $asyncResult = $ps.BeginInvoke()
             $output = $ps.EndInvoke($asyncResult)
 
-            $output[0] | Should Be 'foo action'
+            $output[0] | Should -BeExactly 'foo action'
         }
 
         It 'get-foo -confirm' {
@@ -267,8 +267,8 @@ Describe "Common parameters support for script cmdlets" -Tags "CI" {
             $asyncResult = $ps.BeginInvoke()
             $ps.EndInvoke($asyncResult)
 
-            $ps.Streams.Error.Count | Should Be 1  # the host does not implement it.
-            $ps.InvocationStateInfo.State | Should Be 'Completed'
+            $ps.Streams.Error.Count | Should -Be 1  # the host does not implement it.
+            $ps.InvocationStateInfo.State | Should -BeExactly 'Completed'
         }
     }
 
@@ -293,7 +293,7 @@ Describe "Common parameters support for script cmdlets" -Tags "CI" {
             $asyncResult = $ps.BeginInvoke()
             $output = $ps.EndInvoke($asyncResult)
 
-            $output[0] | Should Be 'foo action'
+            $output[0] | Should -BeExactly 'foo action'
         }
 
         It 'get-foo -confirm' {
@@ -303,8 +303,8 @@ Describe "Common parameters support for script cmdlets" -Tags "CI" {
             $asyncResult = $ps.BeginInvoke()
             $ps.EndInvoke($asyncResult)
 
-            $ps.Streams.Error.Count | Should Be 1  # the host does not implement it.
-            $ps.InvocationStateInfo.State | Should Be 'Completed'
+            $ps.Streams.Error.Count | Should -Be 1  # the host does not implement it.
+            $ps.InvocationStateInfo.State | Should -BeExactly 'Completed'
         }
     }
 
@@ -329,8 +329,8 @@ Describe "Common parameters support for script cmdlets" -Tags "CI" {
             $asyncResult = $ps.BeginInvoke()
             $ps.EndInvoke($asyncResult)
 
-            $ps.Streams.Error.Count | Should Be 1 # the host does not implement it.
-            $ps.InvocationStateInfo.State | Should Be 'Completed'
+            $ps.Streams.Error.Count | Should -Be 1 # the host does not implement it.
+            $ps.InvocationStateInfo.State | Should -BeExactly 'Completed'
         }
 
         It 'get-foo -confirm' {
@@ -339,8 +339,8 @@ Describe "Common parameters support for script cmdlets" -Tags "CI" {
             $asyncResult = $ps.BeginInvoke()
             $ps.EndInvoke($asyncResult)
 
-            $ps.Streams.Error.Count | Should Be 1 # the host does not implement it.
-            $ps.InvocationStateInfo.State | Should be 'Completed'
+            $ps.Streams.Error.Count | Should -Be 1 # the host does not implement it.
+            $ps.InvocationStateInfo.State | Should -BeExactly 'Completed'
         }
     }
 
@@ -366,8 +366,8 @@ Describe "Common parameters support for script cmdlets" -Tags "CI" {
             $asyncResult = $ps.BeginInvoke()
             $ps.EndInvoke($asyncResult)
 
-            $ps.Streams.Error.Count | Should Be 1   # the host does not implement it.
-            $ps.InvocationStateInfo.State | Should Be 'Completed'
+            $ps.Streams.Error.Count | Should -Be 1   # the host does not implement it.
+            $ps.InvocationStateInfo.State | Should -BeExactly 'Completed'
         }
     }
-}
\ No newline at end of file
+}
diff --git a/test/powershell/Language/Scripting/ConstrainedLanguageMode.Tests.ps1 b/test/powershell/Language/Scripting/ConstrainedLanguageMode.Tests.ps1
index 163f94ad7a..994e7c9cd1 100644
--- a/test/powershell/Language/Scripting/ConstrainedLanguageMode.Tests.ps1
+++ b/test/powershell/Language/Scripting/ConstrainedLanguageMode.Tests.ps1
@@ -23,7 +23,7 @@ Describe "Test constrained language mode" -Tags "CI" {
 "@
 
         $o = [powershell]::Create()
-        $t::Test($o) | Should Be $o
+        $t::Test($o) | Should -BeExactly $o
 
         try
         {
@@ -32,7 +32,7 @@ Describe "Test constrained language mode" -Tags "CI" {
             $null = $ps.AddScript('$ExecutionContext.SessionState.LanguageMode = "ConstrainedLanguage"')
             $null = $ps.Invoke()
 
-            $t::Test($o) | Should Be $o
+            $t::Test($o) | Should -BeExactly $o
         }
         finally
         {
diff --git a/test/powershell/Language/Scripting/Debugging/DebuggerScriptTests.Tests.ps1 b/test/powershell/Language/Scripting/Debugging/DebuggerScriptTests.Tests.ps1
index ee410b4ddb..bcac808cee 100644
--- a/test/powershell/Language/Scripting/Debugging/DebuggerScriptTests.Tests.ps1
+++ b/test/powershell/Language/Scripting/Debugging/DebuggerScriptTests.Tests.ps1
@@ -37,7 +37,7 @@ Describe "Breakpoints set on custom FileSystem provider files should work" -Tags
         & .\$scriptName
 
 	    It "Breakpoint hit count" {
-		    $breakpoint.HitCount | Should Be 1
+		    $breakpoint.HitCount | Should -Be 1
 	    }
     }
     finally
@@ -94,7 +94,7 @@ Describe "Tests line breakpoints on dot-sourced files" -Tags "CI" {
         & $scriptFile
 
 	    It "Breakpoint on recursive function hit count" {
-		    $breakpoint.HitCount | Should BeGreaterThan 0
+		    $breakpoint.HitCount | Should -BeGreaterThan 0
 	    }
     }
     finally
@@ -143,11 +143,11 @@ Describe "Function calls clear debugger cache too early" -Tags "CI" {
         & $scriptFile
 
 	    It "Breakpoint before function call count" {
-		    $breakpoint1.HitCount | Should Be 1
+		    $breakpoint1.HitCount | Should -Be 1
 	    }
 
 	    It "Breakpoint after function call count" {
-		    $breakpoint2.HitCount | Should Be 1
+		    $breakpoint2.HitCount | Should -Be 1
 	    }
     }
     finally
@@ -185,15 +185,15 @@ Describe "Line breakpoints on commands in multi-line pipelines" -Tags "CI" {
         $null = & $script
 
 	    It "Breakpoint on line 1 hit count" {
-		    $breakpoints[0].HitCount | Should Be 1
+		    $breakpoints[0].HitCount | Should -Be 1
 	    }
 
 	    It "Breakpoint on line 2 hit count" {
-		    $breakpoints[1].HitCount | Should Be 3
+		    $breakpoints[1].HitCount | Should -Be 3
 	    }
 
 	    It "Breakpoint on line 3 hit count" {
-		    $breakpoints[2].HitCount | Should Be 1
+		    $breakpoints[2].HitCount | Should -Be 1
 	    }
     }
     finally
@@ -228,15 +228,15 @@ Describe "Line breakpoints on commands in multi-line pipelines" -Tags "CI" {
         }
 
         It "Short path Breakpoint on line 1 hit count" -skip:$IsCoreCLR {
-            $breakpoints[0].HitCount | Should Be 1
+            $breakpoints[0].HitCount | Should -Be 1
         }
 
         It "Short path Breakpoint on line 2 hit count" -skip:$IsCoreCLR {
-            $breakpoints[1].HitCount | Should Be 3
+            $breakpoints[1].HitCount | Should -Be 3
         }
 
         It "Short path Breakpoint on line 3 hit count" -skip:$IsCoreCLR {
-            $breakpoints[2].HitCount | Should Be 1
+            $breakpoints[2].HitCount | Should -Be 1
         }
     }
 }
@@ -262,13 +262,13 @@ Describe "Unit tests for various script breakpoints" -Tags "CI" {
         $actual = @(& $command)
 
 	    It "Script breakpoint count '${command}'|${expected}" {
-		    $actual.Count | Should Be $expected.Count
+		    $actual.Count | Should -Be $expected.Count
 	    }
 
         foreach ($breakpoint in $actual)
         {
 	        It "Expected script breakpoints '${command}|${breakpoint}'" {
-		        ($expected -contains $breakpoint) | Should Be $true
+		        ($expected -contains $breakpoint) | Should -BeTrue
 	        }
         }
     }
@@ -287,7 +287,7 @@ Describe "Unit tests for various script breakpoints" -Tags "CI" {
         catch
         {
             It "Script failed expected exception '${command}'" {
-                $_.Exception.GetType().Name | Should Be $exception
+                $_.Exception.GetType().Name | Should -Be $exception
             }
         }
     }
@@ -470,15 +470,15 @@ Describe "Unit tests for line breakpoints on dot-sourced files" -Tags "CI" {
         Get-TestCmdlet
 
 	    It "Breakpoint on function hit count" {
-		    $breakpoint1.HitCount | Should Be 1
+		    $breakpoint1.HitCount | Should -Be 1
 	    }
 
 	    It "Breakpoint on uncalled function hit count" {
-		    $breakpoint2.HitCount | Should Be 0
+		    $breakpoint2.HitCount | Should -Be 0
 	    }
 
 	    It "Breakpoint on cmdlet hit count" {
-		    $breakpoint3.HitCount | Should Be 1
+		    $breakpoint3.HitCount | Should -Be 1
 	    }
     }
     finally
@@ -567,19 +567,19 @@ Describe "Unit tests for line breakpoints on modules" -Tags "CI" {
         Get-ModuleCmdlet
 
 	    It "Breakpoint1 on module function hit count" {
-		    $breakpoint1.HitCount | Should Be 1
+		    $breakpoint1.HitCount | Should -Be 1
 	    }
 
 	    It "Breakpoint2 on uncalled module function hit count" {
-		    $breakpoint2.HitCount | Should Be 0
+		    $breakpoint2.HitCount | Should -Be 0
 	    }
 
 	    It "Breakpoint3 on module cmdlet hit count" {
-		    $breakpoint3.HitCount | Should Be 1
+		    $breakpoint3.HitCount | Should -Be 1
 	    }
 
 	    It "Breakpoint4 on module cmdlet hit count" {
-		    $breakpoint4.HitCount | Should Be 1
+		    $breakpoint4.HitCount | Should -Be 1
 	    }
     }
     finally
@@ -634,14 +634,14 @@ Describe "Sometimes line breakpoints are ignored" -Tags "CI" {
         & $tempFileName1
 
 	    It "Breakpoint 1 hit count" {
-		    $bp1.HitCount | Should Be 6
+		    $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
+		    $bp2.HitCount | Should -Be 6
 	    }
     }
     finally
diff --git a/test/powershell/Language/Scripting/Debugging/Debugging.Tests.ps1 b/test/powershell/Language/Scripting/Debugging/Debugging.Tests.ps1
index d0c278646c..a3d6d05ccd 100644
--- a/test/powershell/Language/Scripting/Debugging/Debugging.Tests.ps1
+++ b/test/powershell/Language/Scripting/Debugging/Debugging.Tests.ps1
@@ -25,7 +25,7 @@ Describe "Breakpoints when set should be hit" -tag "CI" {
     It "A redirected breakpoint is hit" {
         & $path
         foreach ( $bp in $bps ) {
-            $bp.HitCount | should be 1
+            $bp.HitCount | Should -Be 1
         }
     }
 }
@@ -64,29 +64,29 @@ Describe "It should be possible to reset runspace debugging" -tag "Feature" {
         if ( $null -ne $ss ) { $rs.Dispose() }
     }
     It "2 breakpoints should have been set" {
-        $breakpoints.Count | Should be 2
+        $breakpoints.Count | Should -Be 2
     }
     It "The breakpoint Should have been hit" {
-        $completed | should be $true
+        $completed | Should -BeTrue
     }
     It "The reset debugger should not be in a breakpoint" {
-        $rs.Debugger.InBreakPoint | should be $false
+        $rs.Debugger.InBreakPoint | Should -BeFalse
     }
     It "The reset debugger should not be active" {
-        $rs.Debugger.IsActive | should be $false
+        $rs.Debugger.IsActive | Should -BeFalse
     }
     It "The reset debugger mode should be set to 'Default'" {
-        $rs.Debugger.DebugMode | should be "Default"
+        $rs.Debugger.DebugMode | Should -Be "Default"
     }
     It "The debugger should be the same before and after the reset" {
-        $rs.Debugger | Should be $debuggerBeforeReset
+        $rs.Debugger | Should -Be $debuggerBeforeReset
     }
     It "The breakpoints should be gone after reset" {
         $ps.Commands.clear()
-        $ps.AddCommand("Get-PSBreakpoint").Invoke() | Should BeNullOrEmpty
+        $ps.AddCommand("Get-PSBreakpoint").Invoke() | Should -BeNullOrEmpty
     }
     It "The script should run without a break" {
         $ps.Commands.Clear()
-        $ps.addscript("$testdrive/TestScript_2.ps1").Invoke().Count | should be 3
+        $ps.addscript("$testdrive/TestScript_2.ps1").Invoke().Count | Should -Be 3
     }
 }
diff --git a/test/powershell/Language/Scripting/Debugging/DebuggingInHost.Tests.ps1 b/test/powershell/Language/Scripting/Debugging/DebuggingInHost.Tests.ps1
index 1450708dfe..677f743cfe 100644
--- a/test/powershell/Language/Scripting/Debugging/DebuggingInHost.Tests.ps1
+++ b/test/powershell/Language/Scripting/Debugging/DebuggingInHost.Tests.ps1
@@ -18,8 +18,8 @@ Describe "Tests Debugger GetCallStack() on runspaces when attached to a WinRM ho
         $ps.Runspace = $rs
         $result = $ps.AddScript('$pid').Invoke()
         It "Verifies the WinRM host process Id was found" {
-            $result | Should Not Be $null
-            ($result.Count -eq 1) | Should Be $true
+            $result | Should -Not -BeNullOrEmpty
+            ($result.Count -eq 1) | Should -BeTrue
         }
         [int]$winRMHostProcId = $result[0]
 
@@ -33,8 +33,8 @@ Describe "Tests Debugger GetCallStack() on runspaces when attached to a WinRM ho
         # Get local remote runspace to attached process
         $hostRS = Get-Runspace -Name PSAttachRunspace
         It "Verifies that the attached-to host runspace was found" {
-            $hostRS | Should Not Be $null
-            ($hostRS.RunspaceStateInfo.State -eq 'Opened') | Should Be $true
+            $hostRS | Should -Not -BeNullOrEmpty
+            ($hostRS.RunspaceStateInfo.State -eq 'Opened') | Should -BeTrue
         }
 
         # Wait for host runspace to become available.
@@ -44,7 +44,7 @@ Describe "Tests Debugger GetCallStack() on runspaces when attached to a WinRM ho
             sleep -Milliseconds 500
         }
         It "Verifies that the attached-to host runspace is available" {
-            ($hostRS.RunspaceAvailability -eq 'Available') | Should Be $true
+            ($hostRS.RunspaceAvailability -eq 'Available') | Should -BeTrue
         }
 
         # Get call stack from default runspace.
@@ -62,8 +62,8 @@ Describe "Tests Debugger GetCallStack() on runspaces when attached to a WinRM ho
         Exit-PSHostProcess
 
         It "Verifies a call stack was returned from the attached-to host." {
-            $stack | Should Not Be $null
-            ($stack.Count -gt 0) | Should Be $true
+            $stack | Should -Not -BeNullOrEmpty
+            ($stack.Count -gt 0) | Should -BeTrue
         }
     }
     finally
diff --git a/test/powershell/Language/Scripting/Delegates.Tests.ps1 b/test/powershell/Language/Scripting/Delegates.Tests.ps1
index fe40314b0e..1b3b2e6e4c 100644
--- a/test/powershell/Language/Scripting/Delegates.Tests.ps1
+++ b/test/powershell/Language/Scripting/Delegates.Tests.ps1
@@ -42,8 +42,8 @@ Describe 'Test for conversion b/w script block and delegate' -Tags "CI" {
 
     #0 arg, no return
     It 'System.Action' {
-        ([System.Action]{ $script:gl=lineno; $args.Length | Should Be 0 }).Invoke()
-        ($gl + 1) | Should Be (lineno)
+        ([System.Action]{ $script:gl=lineno; $args.Length | Should -Be 0 }).Invoke()
+        ($gl + 1) | Should -BeExactly (lineno)
     }
     # multiple args, no return
     For($i = 1; $i -le 8; $i++)
@@ -58,26 +58,26 @@ Describe 'Test for conversion b/w script block and delegate' -Tags "CI" {
 
             $ct = $gt.MakeGenericType($argumentTypes)
 
-            $func = { $script:gl=lineno; $args.Length | Should Be $i } -as $ct
+            $func = { $script:gl=lineno; $args.Length | Should -BeExactly $i } -as $ct
             $func.DynamicInvoke($parameters)
-            It '$gl + 2' { ($gl + 2) | Should Be (lineno) }
+            It '$gl + 2' { ($gl + 2) | Should -BeExactly (lineno) }
         }
     }
 
     #0 arg with return value
     It 'System.Func[Int32]' {
-        ([System.Func[Int32]]{ $script:gl=lineno; $args.Length }).Invoke() | Should Be 0
-        ($gl + 1) | Should Be (lineno)
+        ([System.Func[Int32]]{ $script:gl=lineno; $args.Length }).Invoke() | Should -Be 0
+        ($gl + 1) | Should -BeExactly (lineno)
     }
 
     It 'System.Func[string]' {
-        ([System.Func[string]]{ $script:gl=lineno; 'hello' }).Invoke() | Should Be 'hello'
-        ($gl + 1) | Should Be (lineno)
+        ([System.Func[string]]{ $script:gl=lineno; 'hello' }).Invoke() | Should -BeExactly 'hello'
+        ($gl + 1) | Should -BeExactly (lineno)
     }
 
     It 'System.Func[hashtable]' {
-        (([System.Func[hashtable]]{ $script:gl=lineno; @{a = 'foo' }}).Invoke()).a | Should Be 'foo'
-        ($gl + 1) | Should Be (lineno)
+        (([System.Func[hashtable]]{ $script:gl=lineno; @{a = 'foo' }}).Invoke()).a | Should -BeExactly 'foo'
+        ($gl + 1) | Should -BeExactly (lineno)
     }
 
     #multiple args, differnt return type
@@ -92,17 +92,17 @@ Describe 'Test for conversion b/w script block and delegate' -Tags "CI" {
             Generate-ArgumentTypesAndParameters $i ([ref] $parameters) ([ref] $argumentTypes) $true
             $v= Get-Value($argumentTypes[$i-1])
             $ct = $gt.MakeGenericType($argumentTypes)
-            $func = { $script:gl=lineno; $null = ($args.Length | Should Be ($i-1)); $v } -as $ct
+            $func = { $script:gl=lineno; $null = ($args.Length | Should -BeExactly ($i-1)); $v } -as $ct
             $t = $func.DynamicInvoke($parameters)
-            It '$gl + 2' { ($gl + 2) | Should Be (lineno) }
+            It '$gl + 2' { ($gl + 2) | Should -BeExactly (lineno) }
             if ($argumentTypes[$i-1] -eq [Hashtable] )
             {
-                It '$t.a' { $t.a | Should Be $v.a }
+                It '$t.a' { $t.a | Should -BeExactly $v.a }
             }
             else
             {
-                It '$t' { $t | Should Be $v }
+                It '$t' { $t | Should -BeExactly $v }
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/test/powershell/Language/Scripting/DeserializedMethods.Tests.ps1 b/test/powershell/Language/Scripting/DeserializedMethods.Tests.ps1
index 393639b33c..4677c92cc2 100644
--- a/test/powershell/Language/Scripting/DeserializedMethods.Tests.ps1
+++ b/test/powershell/Language/Scripting/DeserializedMethods.Tests.ps1
@@ -16,6 +16,6 @@ Describe "DeserializedMethods" -Tags "CI" {
         $s = [System.Management.Automation.PSSerializer]::Serialize($x)
         $d = [System.Management.Automation.PSSerializer]::Deserialize($s)
 
-        $d | Get-Member -MemberType *Method* Add | Should Be $null
+        $d | Get-Member -MemberType *Method* Add | Should -BeNullOrEmpty
     }
 }
\ No newline at end of file
diff --git a/test/powershell/Language/Scripting/DeserializedTypeConversion.Tests.ps1 b/test/powershell/Language/Scripting/DeserializedTypeConversion.Tests.ps1
index 47e08ee6e1..c848028454 100644
--- a/test/powershell/Language/Scripting/DeserializedTypeConversion.Tests.ps1
+++ b/test/powershell/Language/Scripting/DeserializedTypeConversion.Tests.ps1
@@ -94,7 +94,7 @@ Describe "Tests conversion of deserialized types to original type using object p
         }
 
         It 'Type casts should succeed.' {
-            { $tc1 = [test1]$dst1 }| Should not Throw
+            { $tc1 = [test1]$dst1 }| Should -Not -Throw
         }
 
         It 'Parameter bindings should succeed.' {
@@ -108,7 +108,7 @@ Describe "Tests conversion of deserialized types to original type using object p
 
                 $test | Format-List | Out-String
             }
-            { test-1 $dst1 } | Should Not Throw
+            { test-1 $dst1 } | Should -Not -Throw
         }
     }
 
@@ -119,7 +119,7 @@ Describe "Tests conversion of deserialized types to original type using object p
             $dst2 = [System.Management.Automation.PSSerializer]::Deserialize($s)
         }
         It 'Type casts should succeed.' {
-            { $tc2 = [test2]$dst2 } | Should Not Throw
+            { $tc2 = [test2]$dst2 } | Should -Not -Throw
         }
 
         It 'Parameter bindings should succeed.' {
@@ -132,7 +132,7 @@ Describe "Tests conversion of deserialized types to original type using object p
 
                 $test | Format-List | Out-String
             }
-            { test-2 $dst2 } | Should Not Throw
+            { test-2 $dst2 } | Should -Not -Throw
         }
     }
 
@@ -151,7 +151,7 @@ Describe "Tests conversion of deserialized types to original type using object p
                 Throw "Exception expected, execution should not have reached here"
             }
             catch {
-                $_.FullyQualifiedErrorId | Should Be 'InvalidCastConstructorException'
+                $_.FullyQualifiedErrorId | Should -BeExactly 'InvalidCastConstructorException'
             }
         }
 
@@ -173,7 +173,7 @@ Describe "Tests conversion of deserialized types to original type using object p
                 Throw "Exception expected, execution should not have reached here"
             }
             catch {
-                $_.FullyQualifiedErrorId | Should Be 'ParameterArgumentTransformationError,test-3'
+                $_.FullyQualifiedErrorId | Should -BeExactly 'ParameterArgumentTransformationError,test-3'
             }
         }
     }
@@ -186,7 +186,7 @@ Describe "Tests conversion of deserialized types to original type using object p
         }
 
         It 'Type casts should succeed.' {
-            { $tc4 = [test4]$dst4 } | Should Not Throw
+            { $tc4 = [test4]$dst4 } | Should -Not -Throw
         }
 
         It 'Parameter bindings should succeed.' {
@@ -199,7 +199,7 @@ Describe "Tests conversion of deserialized types to original type using object p
 
                 $test | Format-List | Out-String
             }
-            { test-4 $dst4 } | Should Not Throw
+            { test-4 $dst4 } | Should -Not -Throw
         }
     }
 
@@ -218,7 +218,7 @@ Describe "Tests conversion of deserialized types to original type using object p
 
         It 'Type casts should succeed.' {
 
-            { $tc5 = [PSClass1]$dst5 } | Should Not Throw
+            { $tc5 = [PSClass1]$dst5 } | Should -Not -Throw
         }
 
         It 'Parameter bindings should succeed.' {
@@ -231,7 +231,7 @@ Describe "Tests conversion of deserialized types to original type using object p
 
                 $test | Format-List | Out-String
             }
-            { test-PSClass1 $dst5 } | Should Not Throw
+            { test-PSClass1 $dst5 } | Should -Not -Throw
         }
     }
 
@@ -255,7 +255,7 @@ Describe "Tests conversion of deserialized types to original type using object p
         }
 
         It 'Type casts should succeed.' {
-            { $tc6 = [PSClass2]$dst6 } | Should Not Throw
+            { $tc6 = [PSClass2]$dst6 } | Should -Not -Throw
         }
 
         It 'Parameter bindings should succeed.' {
@@ -268,7 +268,7 @@ Describe "Tests conversion of deserialized types to original type using object p
 
                 $test | Format-List | Out-String
             }
-            { test-PSClass2 $dst6 } | Should Not Throw
+            { test-PSClass2 $dst6 } | Should -Not -Throw
         }
     }
 }
diff --git a/test/powershell/Language/Scripting/Dynamicparameters.Tests.ps1 b/test/powershell/Language/Scripting/Dynamicparameters.Tests.ps1
index de3b28082e..525dcc7296 100644
--- a/test/powershell/Language/Scripting/Dynamicparameters.Tests.ps1
+++ b/test/powershell/Language/Scripting/Dynamicparameters.Tests.ps1
@@ -60,7 +60,7 @@ Describe "Dynamic parameter support in script cmdlets." -Tags "CI" {
     }
 
     It "The dynamic parameter is enabled and bound" {
-        foo-bar -path abc -dp1 42 | Should Be 42
+        foo-bar -path abc -dp1 42 | Should -Be 42
     }
 
     It "When the dynamic parameter is not available, and raises an error when specified" {
@@ -68,19 +68,19 @@ Describe "Dynamic parameter support in script cmdlets." -Tags "CI" {
             foo-bar -path def -dp1 42
             Throw "Exception expected, execution should not have reached here"
         } catch {
-            $_.FullyQualifiedErrorId | Should Be "NamedParameterNotFound,foo-bar"
+            $_.FullyQualifiedErrorId | Should -BeExactly "NamedParameterNotFound,foo-bar"
         }
     }
 
     It "No dynamic parameter shouldn't cause an errr " {
-        foo-bar -path def  | Should Be 'no dynamic parameters'
+        foo-bar -path def  | Should -BeExactly 'no dynamic parameters'
     }
 
     It "Not specifying dynamic parameter shouldn't cause an error" {
-        foo-bar -path abc | Should Be 'dynamic parameters not passed'
+        foo-bar -path abc | Should -BeExactly 'dynamic parameters not passed'
     }
 
     It "Parameter is defined in Class" {
-        foo-bar -path class -name "myName" | Should Be 'myName'
+        foo-bar -path class -name "myName" | Should -BeExactly 'myName'
     }
 }
diff --git a/test/powershell/Language/Scripting/ForeachParallel.Tests.ps1 b/test/powershell/Language/Scripting/ForeachParallel.Tests.ps1
index ec11d8732d..c0941a3626 100644
--- a/test/powershell/Language/Scripting/ForeachParallel.Tests.ps1
+++ b/test/powershell/Language/Scripting/ForeachParallel.Tests.ps1
@@ -6,8 +6,8 @@ Describe "Parallel foreach syntax" -Tags "CI" {
         $errors = @()
         $ast = [System.Management.Automation.Language.Parser]::ParseInput(
             'foreach -parallel ($foo in $bar) {}', [ref] $null, [ref] $errors)
-        It '$errors.Count' { $errors.Count | Should Be 1 }
-        It '$ast.EndBlock.Statements[0].Flags' { $ast.EndBlock.Statements[0].Flags | Should Be 'Parallel' }
+        It '$errors.Count' { $errors.Count | Should -Be 1 }
+        It '$ast.EndBlock.Statements[0].Flags' { $ast.EndBlock.Statements[0].Flags | Should -BeExactly 'Parallel' }
     }
 
     It 'Should be able to retrieve AST of parallel foreach, works in JobDefinition case' -Skip:$IsCoreCLR {
@@ -19,23 +19,23 @@ Describe "Parallel foreach syntax" -Tags "CI" {
         $errors = @()
         $ast = [System.Management.Automation.Language.Parser]::ParseInput(
             "foreach `n-parallel `n(`$foo in `$bar) {}", [ref] $null, [ref] $null)
-        It '$errors.Count' { $errors.Count | Should Be 0 }
-        It '$ast.EndBlock.Statements[0].Flags' { $ast.EndBlock.Statements[0].Flags | Should Be 'Parallel' }
+        It '$errors.Count' { $errors.Count | Should -Be 0 }
+        It '$ast.EndBlock.Statements[0].Flags' { $ast.EndBlock.Statements[0].Flags | Should -BeExactly 'Parallel' }
     }
 
     Context 'Generates an error on invalid parameter' {
         $errors = @()
         $ast = [System.Management.Automation.Language.Parser]::ParseInput(
             'foreach -bogus ($input in $bar) { }', [ref]$null, [ref]$errors)
-        It '$errors.Count' { $errors.Count | Should Be 1 }
-        It '$errors[0].ErrorId' { $errors[0].ErrorId | Should Be InvalidForeachFlag }
+        It '$errors.Count' { $errors.Count | Should -Be 1 }
+        It '$errors[0].ErrorId' { $errors[0].ErrorId | Should -BeExactly 'InvalidForeachFlag' }
     }
 
     Context 'Generate an error on -parallel that is not a workflow' {
         $errors = @()
         $ast = [System.Management.Automation.Language.Parser]::ParseInput(
             'foreach -parallel ($input in $bar) { }', [ref]$null, [ref]$errors)
-        It '$errors.Count' { $errors.Count | Should Be 1 }
-        It '$errors[0].ErrorId' { $errors[0].ErrorId | Should Be ParallelNotSupported }
+        It '$errors.Count' { $errors.Count | Should -Be 1 }
+        It '$errors[0].ErrorId' { $errors[0].ErrorId | Should -BeExactly 'ParallelNotSupported' }
     }
 }
\ No newline at end of file
diff --git a/test/powershell/Language/Scripting/Generics.Tests.ps1 b/test/powershell/Language/Scripting/Generics.Tests.ps1
index 44099722df..42af8395e2 100644
--- a/test/powershell/Language/Scripting/Generics.Tests.ps1
+++ b/test/powershell/Language/Scripting/Generics.Tests.ps1
@@ -10,48 +10,48 @@ Describe "Generics support" -Tags "CI" {
         $x = [list[int]]::New()
         $x.Add(42)
         $x.Add(40)
-        $x.count | Should Be 2
+        $x.count | Should -Be 2
     }
 
     It 'Type stack[Int] works properly' {
         $x = [stack[int]]::New()
         $x.Push(42)
         $x.Push(40)
-        $x.count | Should Be 2
+        $x.count | Should -Be 2
     }
 
     It 'Type dictionary[string, Int] works properly' {
         $x = [dictionary[string, int]]::New()
         $x.foo = 42
-        $x.foo | Should Be 42
+        $x.foo | Should -Be 42
     }
 
     It 'Type list[[Int]] works properly' {
         $x = [list[[int]]]::New()
         $x.Add(42)
         $x.Add(40)
-        $x.count | Should Be 2
+        $x.count | Should -Be 2
     }
 
     It 'Type stack[[Int]] works properly' {
         $x = [stack[[int]]]::New()
         $x.Push(42)
         $x.Push(40)
-        $x.count | Should Be 2
+        $x.count | Should -Be 2
     }
 
     It 'Type dictionary[[string], [Int]] works properly' {
         $x = [dictionary[[string], [int]]]::New()
         $x.foo = 42
-        $x.foo | Should Be 42
+        $x.foo | Should -Be 42
     }
 
     It 'Type dictionary[dictionary[list[int],string], stack[double]] works properly' {
         $x = [dictionary[dictionary[list[int],string], stack[double]]]::new()
-        $x.gettype().fullname | should match "double"
+        $x.gettype().fullname | Should -Match "double"
 
         $y = new-object "dictionary[dictionary[list[int],string], stack[double]]"
-        $y.gettype().fullname | should match "double"
+        $y.gettype().fullname | Should -Match "double"
     }
 
     It 'non-generic EventHandler works properly' {
@@ -66,14 +66,14 @@ Describe "Generics support" -Tags "CI" {
             [nullable[object]]
             Throw "Exception expected, execution should not have reached here"
         } catch {
-            $_.FullyQualifiedErrorId | Should be 'TypeNotFoundWithMessage'
-            $_ | should match "\[T\]"
+            $_.FullyQualifiedErrorId | Should -BeExactly 'TypeNotFoundWithMessage'
+            $_ | Should -Match "\[T\]"
         }
     }
 
     It 'Array type works properly' -skip:$IsCoreCLR{
         $x = [system.array]::ConvertAll.OverloadDefinitions
-        $x | Should match "static\s+TOutput\[\]\s+ConvertAll\[TInput,\s+TOutput\]\("
+        $x | Should -Match "static\s+TOutput\[\]\s+ConvertAll\[TInput,\s+TOutput\]\("
     }
 
    It 'Class type works properly' {
@@ -92,9 +92,9 @@ Describe "Generics support" -Tags "CI" {
 
         $x = [TestClass]::New("default1", 90, "1...5")
         $x.scriptText = "1...4"
-        $x.name | Should Be 'default1'
-        $x.port | Should Be 90
-        $x.scriptText | Should Be "1...4"
+        $x.name | Should -BeExactly 'default1'
+        $x.port | Should -Be 90
+        $x.scriptText | Should -BeExactly "1...4"
    }
 }
 
diff --git a/test/powershell/Language/Scripting/HashtableToPSCustomObjectConversion.Tests.ps1 b/test/powershell/Language/Scripting/HashtableToPSCustomObjectConversion.Tests.ps1
index 9a85a03560..745497c4c0 100644
--- a/test/powershell/Language/Scripting/HashtableToPSCustomObjectConversion.Tests.ps1
+++ b/test/powershell/Language/Scripting/HashtableToPSCustomObjectConversion.Tests.ps1
@@ -37,13 +37,13 @@ Describe "Tests for hashtable to PSCustomObject conversion" -Tags "CI" {
         param ($Name, $Cmd, $ExpectedType)
         Invoke-expression $Cmd -OutVariable a
         $a = Get-Variable -Name a -ValueOnly
-        $a | should BeOfType $ExpectedType
+        $a | Should -BeOfType $ExpectedType
     }
 
     It 'Hashtable conversion to PSCustomObject retains insertion order of hashtable keys when passed a hashliteral' {
 
         $x = [pscustomobject]@{one=1;two=2}
-        $x | should BeOfType "System.Management.automation.psobject"
+        $x | Should -BeOfType "System.Management.automation.psobject"
 
         $p = 0
         # Checks if the first property is One
@@ -52,7 +52,7 @@ Describe "Tests for hashtable to PSCustomObject conversion" -Tags "CI" {
                                     if ($p -eq 0)
                                     {
                                         $p++;
-                                        $_.Name | Should Be 'one'
+                                        $_.Name | Should -BeExactly 'one'
                                      }
                                 }
     }
@@ -60,7 +60,7 @@ Describe "Tests for hashtable to PSCustomObject conversion" -Tags "CI" {
     It 'Conversion of Ordered hashtable to PSCustomObject should succeed' {
 
        $x = [pscustomobject][ordered]@{one=1;two=2}
-       $x | should BeOfType "System.Management.automation.psobject"
+       $x | Should -BeOfType "System.Management.automation.psobject"
 
        $p = 0
        # Checks if the first property is One
@@ -69,7 +69,7 @@ Describe "Tests for hashtable to PSCustomObject conversion" -Tags "CI" {
                                     if ($p -eq 0)
                                     {
                                         $p++;
-                                        $_.Name | Should Be 'one'
+                                        $_.Name | Should -BeExactly 'one'
                                      }
                                 }
     }
@@ -107,36 +107,36 @@ Describe "Tests for hashtable to PSCustomObject conversion" -Tags "CI" {
 
            if($InnerException)
            {
-                $_.Exception.InnerException.ErrorRecord.FullyQualifiedErrorId | Should Be $ErrorID
+                $_.Exception.InnerException.ErrorRecord.FullyQualifiedErrorId | Should -BeExactly $ErrorID
            }
            else {
-                $_.FullyQualifiedErrorId | Should Be $ErrorID
+                $_.FullyQualifiedErrorId | Should -BeExactly $ErrorID
            }
        }
     }
 
     It  'Creating an object of an existing type from hashtable should succeed' {
         $result = [System.Management.Automation.Host.Coordinates]@{X=10;Y=33}
-        $result.X | should be 10
+        $result.X | Should -Be 10
     }
 
     It 'Creating an object of an existing type from hashtable should call the constructor taking a hashtable if such a constructor exists in the type' {
 
        $x = [SampleClass5]@{a=10;b=5}
-       $x.a | Should Be '100'
+       $x.a | Should -BeExactly '100'
     }
 
     It 'Add a new type name to PSTypeNames property' {
 
 	    $obj = [PSCustomObject] @{pstypename = 'Mytype'}
-	    $obj.PSTypeNames[0] | Should Be 'Mytype'
+	    $obj.PSTypeNames[0] | Should -BeExactly 'Mytype'
     }
 
     It 'Add an existing type name to PSTypeNames property' {
 
 	    $obj = [PSCustomObject] @{pstypename = 'System.Object'}
-	    $obj.PSTypeNames.Count | Should Be 3
-	    $obj.PSTypeNames[0] | Should Be 'System.Object'
+	    $obj.PSTypeNames.Count | Should -Be 3
+	    $obj.PSTypeNames[0] | Should -BeExactly 'System.Object'
     }
     It "new-object should fail to create object for System.Management.Automation.PSCustomObject" {
 
@@ -151,8 +151,8 @@ Describe "Tests for hashtable to PSCustomObject conversion" -Tags "CI" {
         {
             $errorObj = $_
         }
-        $obj | should be $null
-        $errorObj.FullyQualifiedErrorId | should be "CannotFindAppropriateCtor,Microsoft.PowerShell.Commands.NewObjectCommand"
+        $obj | Should -BeNullOrEmpty
+        $errorObj.FullyQualifiedErrorId | Should -BeExactly "CannotFindAppropriateCtor,Microsoft.PowerShell.Commands.NewObjectCommand"
     }
 }
 
diff --git a/test/powershell/Language/Scripting/I18n.Tests.ps1 b/test/powershell/Language/Scripting/I18n.Tests.ps1
index 3e4d1a46bb..144afdf199 100644
--- a/test/powershell/Language/Scripting/I18n.Tests.ps1
+++ b/test/powershell/Language/Scripting/I18n.Tests.ps1
@@ -24,84 +24,84 @@ Describe 'Testing of script internationalization' -Tags "CI" {
 '@
         }
 
-        $mydata.string1 | Should Be 'string1'
-        $mydata.string2 | Should Be 'string2'
+        $mydata.string1 | Should -BeExactly 'string1'
+        $mydata.string2 | Should -BeExactly 'string2'
     }
 
     It 'Import default culture is done correctly' {
 
         import-localizedData mydata;
 
-        $mydata.string1 | Should Be 'string1 for en-US'
-        $mydata.string2 | Should be 'string2 for en-US'
+        $mydata.string1 | Should -BeExactly 'string1 for en-US'
+        $mydata.string2 | Should -BeExactly 'string2 for en-US'
     }
 
     It 'Import specific culture(en-US)' {
 
         import-localizedData mydata -uiculture en-US
 
-        $mydata.string1 | Should Be 'string1 for en-US'
-        $mydata.string2 | Should Be 'string2 for en-US'
+        $mydata.string1 | Should -BeExactly 'string1 for en-US'
+        $mydata.string2 | Should -BeExactly 'string2 for en-US'
 
         import-localizedData mydata -uiculture fr-FR
 
-        $mydata.string1 | Should Be 'string1 for fr-FR'
-        $mydata.string2 | Should Be 'string2 for fr-FR'
+        $mydata.string1 | Should -BeExactly 'string1 for fr-FR'
+        $mydata.string2 | Should -BeExactly 'string2 for fr-FR'
     }
 
     It 'Import non existing culture is done correctly' {
 
         import-localizedData mydata -uiculture nl-NL -ea SilentlyContinue -ev ev
 
-        $ev | Should Not BeNullOrEmpty
-        $ev[0].Exception | Should BeOfType "System.Management.Automation.PSInvalidOperationException"
+        $ev | Should -Not -BeNullOrEmpty
+        $ev[0].Exception | Should -BeOfType "System.Management.Automation.PSInvalidOperationException"
     }
 
     It 'Import different file name is done correctly' {
 
         import-localizedData mydata -filename foo
 
-        $mydata.string1 | Should Be 'string1 from foo in en-US'
-        $mydata.string2 | Should Be 'string2 from foo in en-US'
+        $mydata.string1 | Should -BeExactly 'string1 from foo in en-US'
+        $mydata.string2 | Should -BeExactly 'string2 from foo in en-US'
 
         import-localizedData mydata -filename foo -uiculture fr-FR
 
-        $mydata.string1 | Should Be 'string1 from foo in fr-FR'
-        $mydata.string2 | Should Be 'string2 from foo in fr-FR'
+        $mydata.string1 | Should -BeExactly 'string1 from foo in fr-FR'
+        $mydata.string2 | Should -BeExactly 'string2 from foo in fr-FR'
     }
 
     It 'Import different file base is done correctly' {
 
         import-localizedData mydata -basedirectory "${dir}\newbase"
 
-        $mydata.string1 | Should Be 'string1 for en-US under newbase'
-        $mydata.string2 | Should Be 'string2 for en-US under newbase'
+        $mydata.string1 | Should -BeExactly 'string1 for en-US under newbase'
+        $mydata.string2 | Should -BeExactly 'string2 for en-US under newbase'
 
         import-localizedData mydata -basedirectory "${dir}\newbase" -uiculture fr-FR
 
-        $mydata.string1 | Should Be 'string1 for fr-FR under newbase'
-        $mydata.string2 | Should Be 'string2 for fr-FR under newbase'
+        $mydata.string1 | Should -BeExactly 'string1 for fr-FR under newbase'
+        $mydata.string2 | Should -BeExactly 'string2 for fr-FR under newbase'
     }
 
     It 'Import different file base and file name' {
 
         import-localizedData mydata -basedirectory "${dir}\newbase" -filename foo
 
-        $mydata.string1 | Should Be 'string1 for en-US from foo under newbase'
-        $mydata.string2 | Should Be 'string2 for en-US from foo under newbase'
+        $mydata.string1 | Should -BeExactly 'string1 for en-US from foo under newbase'
+        $mydata.string2 | Should -BeExactly 'string2 for en-US from foo under newbase'
 
         import-localizedData mydata -basedirectory "${dir}\newbase" -filename foo -uiculture fr-FR
 
-        $mydata.string1 | Should Be 'string1 for fr-FR from foo under newbase'
-        $mydata.string2 | Should Be 'string2 for fr-FR from foo under newbase'
+        $mydata.string1 | Should -BeExactly 'string1 for fr-FR from foo under newbase'
+        $mydata.string2 | Should -BeExactly 'string2 for fr-FR from foo under newbase'
         }
 
     It "Import variable that doesn't exist" {
 
         import-localizedData mydata2
 
-        $mydata2.string1 | Should Be 'string1 for en-US'
-        $mydata2.string2 | Should Be 'string2 for en-US'
+        $mydata2.string1 | Should -BeExactly 'string1 for en-US'
+        $mydata2.string2 | Should -BeExactly 'string2 for en-US'
     }
 
     It 'Import bad psd1 file - tests the use of disallowed variables' {
@@ -112,8 +112,8 @@ Describe 'Testing of script internationalization' -Tags "CI" {
             import-localizedData mydata -filename bad
           }
 
-        $script:exception.exception | Should Not BeNullOrEmpty
-        $script:exception.exception | Should BeOfType System.management.automation.psinvalidoperationexception
+        $script:exception.exception | Should -Not -BeNullOrEmpty
+        $script:exception.exception | Should -BeOfType System.management.automation.psinvalidoperationexception
         }
 
     It 'Import if psd1 file is done correctly' {
@@ -122,12 +122,12 @@ Describe 'Testing of script internationalization' -Tags "CI" {
 
         if ($psculture -eq 'en-US')
         {
-            $mydata.string1 | Should Be 'string1 for en-US in if'
-            $mydata.string2 | Should Be 'string2 for en-US in if'
+            $mydata.string1 | Should -BeExactly 'string1 for en-US in if'
+            $mydata.string2 | Should -BeExactly 'string2 for en-US in if'
         }
         else
         {
-            $mydata | Should Be $null
+            $mydata | Should -BeNullOrEmpty
         }
     }
 
@@ -146,7 +146,7 @@ Describe 'Testing of script internationalization' -Tags "CI" {
             invoke-expression $cmd
         }
 
-        $exception | Should Match $Expected
+        $exception | Should -Match $Expected
     }
 
     it 'Check alternate syntax that also supports complex variable names' {
@@ -154,20 +154,20 @@ Describe 'Testing of script internationalization' -Tags "CI" {
        & {
             $script:mydata = data { 123 }
          }
-        $mydata | Should Be 123
+        $mydata | Should -Be 123
 
         $mydata = data { 456 }
         & {
             # This import should not clobber the one at script scope
             import-localizedData mydata -uiculture en-US
         }
-        $mydata | Should Be 456
+        $mydata | Should -Be 456
 
         & {
             # This import should clobber the one at script scope
             import-localizedData script:mydata -uiculture en-US
         }
-        $script:mydata.string1 | Should Be 'string1 for en-US'
+        $script:mydata.string1 | Should -BeExactly 'string1 for en-US'
     }
 
     It 'Check fallback to current directory plus -SupportedCommand parameter is done correctly' {
@@ -175,7 +175,7 @@ Describe 'Testing of script internationalization' -Tags "CI" {
         new-alias MyConvertFrom-StringData ConvertFrom-StringData
 
         import-localizeddata local:mydata -uiculture fr-ca -filename I18n.Tests_fallback.psd1 -SupportedCommand MyConvertFrom-StringData
-        $mydata[0].string1 | Should Be 'fallback string1 for en-US'
-        $mydata[1] | Should Be 42
+        $mydata[0].string1 | Should -BeExactly 'fallback string1 for en-US'
+        $mydata[1] | Should -Be 42
     }
 }
diff --git a/test/powershell/Language/Scripting/Indexer.Tests.ps1 b/test/powershell/Language/Scripting/Indexer.Tests.ps1
index 9ba3e4a272..ded67dbdd0 100644
--- a/test/powershell/Language/Scripting/Indexer.Tests.ps1
+++ b/test/powershell/Language/Scripting/Indexer.Tests.ps1
@@ -4,24 +4,24 @@ Describe 'Tests for indexers' -Tags "CI" {
     It 'Indexer in dictionary' {
 
         $hashtable = @{ "Hello"="There" }
-        $hashtable["Hello"] | Should Be "There"
+        $hashtable["Hello"] | Should -BeExactly "There"
     }
 
     It 'Accessing a Indexed property of a dictionary that does not exist should return $NULL' {
         $hashtable = @{ "Hello"="There" }
-        $hashtable["Hello There"] | Should Be $null
+        $hashtable["Hello There"] | Should -BeNullOrEmpty
         }
 
     It 'Wmi object implements an indexer' -Skip:$IsCoreCLR  {
 
         $service = Get-WmiObject -List -Amended Win32_Service
 
-        $service.Properties["DisplayName"].Name | Should Be 'DisplayName'
+        $service.Properties["DisplayName"].Name | Should -BeExactly 'DisplayName'
     }
 
     It 'Accessing a Indexed property of a wmi object that does not exist should return $NULL' -skip:$IsCoreCLR {
 
         $service = Get-WmiObject -List -Amended Win32_Service
-        $service.Properties["Hello There"] | Should Be $null
+        $service.Properties["Hello There"] | Should -BeNullOrEmpty
     }
 }
diff --git a/test/powershell/Language/Scripting/LineEndings.Tests.ps1 b/test/powershell/Language/Scripting/LineEndings.Tests.ps1
index 181b433bf1..787101426b 100644
--- a/test/powershell/Language/Scripting/LineEndings.Tests.ps1
+++ b/test/powershell/Language/Scripting/LineEndings.Tests.ps1
@@ -116,7 +116,7 @@ Describe 'Line endings' -Tags "CI" {
         $actual = iex $content
 
         # $actual should be the content string ($expected) without the begin and end quoting characters.
-        $actual | Should Be $expected
+        $actual | Should -BeExactly $expected
     }
 
     It '<Name> in ps file' -TestCases:$testData {
@@ -135,7 +135,7 @@ Describe 'Line endings' -Tags "CI" {
         $actual = &( "TESTDRIVE:\$fileName")
 
         # $actual should be the content string ($expected) without the begin and end quoting characters.
-        $actual | Should Be $expected
+        $actual | Should -BeExactly $expected
     }
 }
 
diff --git a/test/powershell/Language/Scripting/MyInvocation.Tests.ps1 b/test/powershell/Language/Scripting/MyInvocation.Tests.ps1
index a899630cb1..24f7a4ba48 100644
--- a/test/powershell/Language/Scripting/MyInvocation.Tests.ps1
+++ b/test/powershell/Language/Scripting/MyInvocation.Tests.ps1
@@ -5,43 +5,43 @@ Describe 'Testing of MyInvocation' -Tags "CI" {
 
         function myfunc
         {
-            $MyInvocation.Line.IndexOf("myfunc") | Should BeGreaterThan -1
+            $MyInvocation.Line.IndexOf("myfunc") | Should -BeGreaterThan -1
         }
 
-        { . myfunc } | Should Not Throw
-        {& myfunc } | Should Not Throw
+        { . myfunc } | Should -Not -Throw
+        {& myfunc } | Should -Not -Throw
     }
 
     It 'MyInvocation works in Filter' {
 
         filter myfilter
         {
-            $MyInvocation.Line.IndexOf("myfilter") | Should BeGreaterThan -1
+            $MyInvocation.Line.IndexOf("myfilter") | Should -BeGreaterThan -1
         }
 
-        {. myfilter } | Should Not Throw
-        { & myfilter } | Should Not Throw
+        {. myfilter } | Should -Not -Throw
+        { & myfilter } | Should -Not -Throw
     }
 
     Context 'MyInvocation works in Script block' {
 
         It 'MyInvocation works in dot sourced Script block' {
             $a = . {$MyInvocation.Line}
-            $a.IndexOf('$a = . {$MyInvocation.Line}') | Should BeGreaterThan -1
+            $a.IndexOf('$a = . {$MyInvocation.Line}') | Should -BeGreaterThan -1
         }
         It 'MyInvocation works in & Script block2' {
             $a = & {$MyInvocation.Line}
-            $a.IndexOf('$a = & {$MyInvocation.Line}') | Should BeGreaterThan -1
+            $a.IndexOf('$a = & {$MyInvocation.Line}') | Should -BeGreaterThan -1
         }
 
         It 'MyInvocation works when run Script file' {
             $a = & {$MyInvocation.ScriptName}
-            $a.ToLower().IndexOf("myinvocation.tests.ps1") | Should BeGreaterThan -1
+            $a.ToLower().IndexOf("myinvocation.tests.ps1") | Should -BeGreaterThan -1
         }
 
         It 'MyInvocation works when dot source Script file' {
             $a = . {$MyInvocation.ScriptName}
-            $a.ToLower().IndexOf("myinvocation.tests.ps1") | Should BeGreaterThan -1
+            $a.ToLower().IndexOf("myinvocation.tests.ps1") | Should -BeGreaterThan -1
         }
     }
 }
diff --git a/test/powershell/Language/Scripting/NativeExecution/NativeCommandArguments.Tests.ps1 b/test/powershell/Language/Scripting/NativeExecution/NativeCommandArguments.Tests.ps1
index e9a629be15..602b13976a 100644
--- a/test/powershell/Language/Scripting/NativeExecution/NativeCommandArguments.Tests.ps1
+++ b/test/powershell/Language/Scripting/NativeExecution/NativeCommandArguments.Tests.ps1
@@ -10,10 +10,10 @@ Describe "Native Command Arguments" -tags "CI" {
     It "Should handle quoted spaces correctly" {
         $a = 'a"b c"d'
         $lines = testexe -echoargs $a 'a"b c"d' a"b c"d
-        $lines.Count | Should Be 3
-        $lines[0] | Should Be 'Arg 0 is <ab cd>'
-        $lines[1] | Should Be 'Arg 1 is <ab cd>'
-        $lines[2] | Should Be 'Arg 2 is <ab cd>'
+        $lines.Count | Should -Be 3
+        $lines[0] | Should -BeExactly 'Arg 0 is <ab cd>'
+        $lines[1] | Should -BeExactly 'Arg 1 is <ab cd>'
+        $lines[2] | Should -BeExactly 'Arg 2 is <ab cd>'
     }
 
     # In order to pass '"' characters so they are actually part of command line
@@ -29,9 +29,9 @@ Describe "Native Command Arguments" -tags "CI" {
     # looking at how it got the arguments.
     It "Should handle spaces between escaped quotes" {
         $lines = testexe -echoargs 'a\"b c\"d' "a\`"b c\`"d"
-        $lines.Count | Should Be 2
-        $lines[0] | Should Be 'Arg 0 is <a"b c"d>'
-        $lines[1] | Should Be 'Arg 1 is <a"b c"d>'
+        $lines.Count | Should -Be 2
+        $lines[0] | Should -BeExactly 'Arg 0 is <a"b c"d>'
+        $lines[1] | Should -BeExactly 'Arg 1 is <a"b c"d>'
     }
 
     It "Should correctly quote paths with spaces: <arguments>" -TestCases @(
@@ -40,9 +40,9 @@ Describe "Native Command Arguments" -tags "CI" {
     ) {
         param($arguments, $expected)
         $lines = Invoke-Expression "testexe -echoargs $arguments"
-        $lines.Count | Should Be $expected.Count
+        $lines.Count | Should -Be $expected.Count
         for ($i = 0; $i -lt $lines.Count; $i++) {
-            $lines[$i] | Should Be "Arg $i is <$($expected[$i])>"
+            $lines[$i] | Should -BeExactly "Arg $i is <$($expected[$i])>"
         }
     }
 
@@ -58,9 +58,9 @@ Describe "Native Command Arguments" -tags "CI" {
     ) {
         param($arguments, $expected)
         $lines = @(Invoke-Expression "testexe -echoargs $arguments")
-        $lines.Count | Should Be $expected.Count
+        $lines.Count | Should -Be $expected.Count
         for ($i = 0; $i -lt $expected.Count; $i++) {
-            $lines[$i] | Should Be "Arg $i is <$($expected[$i])>"
+            $lines[$i] | Should -BeExactly "Arg $i is <$($expected[$i])>"
         }
     }
 }
diff --git a/test/powershell/Language/Scripting/NativeExecution/NativeCommandProcessor.Tests.ps1 b/test/powershell/Language/Scripting/NativeExecution/NativeCommandProcessor.Tests.ps1
index 5f3000073f..4bbef895f8 100644
--- a/test/powershell/Language/Scripting/NativeExecution/NativeCommandProcessor.Tests.ps1
+++ b/test/powershell/Language/Scripting/NativeExecution/NativeCommandProcessor.Tests.ps1
@@ -2,8 +2,8 @@
 # Licensed under the MIT License.
 Describe 'Native pipeline should have proper encoding' -tags 'CI' {
     It '$OutputEncoding should be set to UTF8 without BOM' {
-        $OutputEncoding.BodyName | Should Be "utf-8"
-        $OutputEncoding.GetPreamble().Length | Should Be 0
+        $OutputEncoding.BodyName | Should -Be "utf-8"
+        $OutputEncoding.GetPreamble().Length | Should -Be 0
     }
 }
 
@@ -27,7 +27,7 @@ Describe 'native commands with pipeline' -tags 'Feature' {
 
         # waiting 30 seconds, because powershell startup time could be long on the slow machines,
         # such as CI
-        Wait-UntilTrue { $rs.RunspaceAvailability -eq 'Available' } -timeout 30000 -interval 100 | Should Be $true
+        Wait-UntilTrue { $rs.RunspaceAvailability -eq 'Available' } -timeout 30000 -interval 100 | Should -BeTrue
 
         $ps.Stop()
         $rs.ResetRunspaceState()
@@ -37,10 +37,10 @@ Describe 'native commands with pipeline' -tags 'Feature' {
 
         if ($IsWindows) {
             $result = @(ping.exe | findstr.exe count | findstr.exe ping)
-            $result[0] | Should Match "Usage: ping"
+            $result[0] | Should -Match "Usage: ping"
         } else {
             $result = @(ps aux | grep pwsh | grep -v grep)
-            $result[0] | Should Match "pwsh"
+            $result[0] | Should -Match "pwsh"
         }
     }
 }
@@ -60,10 +60,10 @@ Describe "Native Command Processor" -tags "Feature" {
         $ps.AddArgument("-createchildprocess")
         $ps.AddArgument($numToCreate)
         $async = $ps.BeginInvoke()
-        $ps.InvocationStateInfo.State | Should Be "Running"
+        $ps.InvocationStateInfo.State | Should -Be "Running"
 
         [bool] $childrenCreated = $false
-        while (-not $childrenCreated)
+        while (-Not $childrenCreated)
         {
             $childprocesses = Get-Process testexe -ErrorAction SilentlyContinue
             if ($childprocesses.count -eq $numToCreate+1)
@@ -85,13 +85,13 @@ Describe "Native Command Processor" -tags "Feature" {
         $childprocesses = Get-Process testexe
         $count = $childprocesses.count
         $childprocesses | Stop-Process
-        $count | Should Be 0
+        $count | Should -Be 0
     }
 
     It "Should not block running Windows executables" -Skip:(!$IsWindows -or !(Get-Command notepad.exe)) {
         function FindNewNotepad
         {
-            Get-Process -Name notepad -ErrorAction Ignore | Where-Object { $_.Id -notin $dontKill }
+            Get-Process -Name notepad -ErrorAction Ignore | Where-Object { $_.Id -NotIn $dontKill }
         }
 
         # We need to kill the windows process we start and can't know the process id, so get a list of
@@ -113,11 +113,11 @@ Describe "Native Command Processor" -tags "Feature" {
 
             # Stop the new instance of notepad
             $newNotepad = FindNewNotepad
-            $newNotepad | Should Not Be $null
+            $newNotepad | Should -Not -BeNullOrEmpty
             $newNotepad | Stop-Process
 
-            $async.IsCompleted | Should Be $true
-            $ps.EndInvoke($async) | Should Be "ran notepad"
+            $async.IsCompleted | Should -BeTrue
+            $ps.EndInvoke($async) | Should -Be "ran notepad"
         }
         finally
         {
@@ -197,8 +197,8 @@ Categories=Application;
                 $title = 'tell application "TextEdit" to get name of front window' | osascript
             }
             $afterCount = [int]('tell application "TextEdit" to count of windows' | osascript)
-            $afterCount | Should Be ($beforeCount + 1)
-            $title | Should Be $expectedTitle
+            $afterCount | Should -Be ($beforeCount + 1)
+            $title | Should -BeExactly $expectedTitle
             "tell application ""TextEdit"" to close window ""$expectedTitle""" | osascript
             'tell application "TextEdit" to quit' | osascript
         }
@@ -207,13 +207,13 @@ Categories=Application;
             & $TestFile
             # It may take time for handler to start
             Wait-FileToBePresent -File "$HOME/nativeCommandProcessor.Success" -TimeoutInSeconds 10 -IntervalInMilliseconds 100
-            Get-Content $HOME/nativeCommandProcessor.Success | Should Be $TestFile
+            Get-Content $HOME/nativeCommandProcessor.Success | Should -BeExactly $TestFile
         }
         else {
             & $TestFile
             Wait-FileToBePresent -File $TestDrive\foo.txt -TimeoutInSeconds 10 -IntervalInMilliseconds 100
-            "$TestDrive\foo.txt" | Should Exist
-            Get-Content $TestDrive\foo.txt | Should BeExactly $TestFile
+            "$TestDrive\foo.txt" | Should -Exist
+            Get-Content $TestDrive\foo.txt | Should -BeExactly $TestFile
         }
     }
 
diff --git a/test/powershell/Language/Scripting/NativeExecution/NativeLinuxCommands.Tests.ps1 b/test/powershell/Language/Scripting/NativeExecution/NativeLinuxCommands.Tests.ps1
index db49c9f207..b068b9fe33 100644
--- a/test/powershell/Language/Scripting/NativeExecution/NativeLinuxCommands.Tests.ps1
+++ b/test/powershell/Language/Scripting/NativeExecution/NativeLinuxCommands.Tests.ps1
@@ -14,27 +14,27 @@ Describe "NativeLinuxCommands" -tags "CI" {
     }
 
     It "Should find Application grep" {
-        (get-command grep).CommandType | Should Be Application
+        (get-command grep).CommandType | Should -Be Application
     }
 
     It "Should pipe to grep and get result" {
-        "hello world" | grep hello | Should Be "hello world"
+        "hello world" | grep hello | Should -BeExactly "hello world"
     }
 
     It "Should find Application touch" {
-        (get-command touch).CommandType | Should Be Application
+        (get-command touch).CommandType | Should -Be Application
     }
 
     It "Should not redirect standard input if native command is the first command in pipeline (1)" {
         df | ForEach-Object -Begin { $out = @() } -Process { $out += $_ }
-        $out.Length -gt 0 | Should Be $true
-        $out[0] -like "Filesystem*Available*" | Should Be $true
+        $out.Length -gt 0 | Should -BeTrue
+        $out[0] -like "Filesystem*Available*" | Should -BeTrue
     }
 
     It "Should not redirect standard input if native command is the first command in pipeline (2)" {
         $out = df
-        $out.Length -gt 0 | Should Be $true
-        $out[0] -like "Filesystem*Available*" | Should Be $true
+        $out.Length -gt 0 | Should -BeTrue
+        $out[0] -like "Filesystem*Available*" | Should -BeTrue
     }
 
     It "Should find command before script with same name" {
@@ -46,7 +46,7 @@ echo 'command'
         Set-Content "$TestDrive\foo.ps1" -Value @"
 'script'
 "@ -Encoding Ascii
-        foo | Should BeExactly 'command'
+        foo | Should -BeExactly 'command'
     }
 }
 
@@ -63,10 +63,10 @@ Describe "Scripts with extensions" -tags "CI" {
     }
 
     It "Should run a script with its full name" {
-        testScript.ps1 | Should Be $data
+        testScript.ps1 | Should -BeExactly $data
     }
 
     It "Should run a script with its short name" {
-        testScript | Should Be $data
+        testScript | Should -BeExactly $data
     }
 }
diff --git a/test/powershell/Language/Scripting/NativeExecution/NativeStreams.Tests.ps1 b/test/powershell/Language/Scripting/NativeExecution/NativeStreams.Tests.ps1
index 93357815a4..aa38172497 100644
--- a/test/powershell/Language/Scripting/NativeExecution/NativeStreams.Tests.ps1
+++ b/test/powershell/Language/Scripting/NativeExecution/NativeStreams.Tests.ps1
@@ -20,36 +20,36 @@ Describe "Native streams behavior with PowerShell" -Tags 'CI' {
         # this check should be the first one, because $error is a global shared variable
         It 'should not add records to $error variable' {
             # we are keeping existing Windows PS v5.1 behavior for $error variable
-            $error.Count | Should Be 9
+            $error.Count | Should -Be 9
         }
 
         It 'uses ErrorRecord object to return stderr output' {
-            ($out | measure).Count | Should BeGreaterThan 1
+            ($out | measure).Count | Should -BeGreaterThan 1
 
-            $out[0] | Should BeOfType 'System.Management.Automation.ErrorRecord'
-            $out[0].FullyQualifiedErrorId | Should Be 'NativeCommandError'
+            $out[0] | Should -BeOfType 'System.Management.Automation.ErrorRecord'
+            $out[0].FullyQualifiedErrorId | Should -Be 'NativeCommandError'
 
             $out | Select-Object -Skip 1 | ForEach-Object {
-                $_ | Should BeOfType 'System.Management.Automation.ErrorRecord'
-                $_.FullyQualifiedErrorId | Should Be 'NativeCommandErrorMessage'
+                $_ | Should -BeOfType 'System.Management.Automation.ErrorRecord'
+                $_.FullyQualifiedErrorId | Should -Be 'NativeCommandErrorMessage'
             }
         }
 
         It 'uses correct exception messages for error stream' {
-            ($out | measure).Count | Should Be 9
-            $out[0].Exception.Message | Should Be 'foo'
-            $out[1].Exception.Message | Should Be ''
-            $out[2].Exception.Message | Should Be 'bar'
-            $out[3].Exception.Message | Should Be ''
-            $out[4].Exception.Message | Should Be 'bazmiddlefoo'
-            $out[5].Exception.Message | Should Be ''
-            $out[6].Exception.Message | Should Be 'bar'
-            $out[7].Exception.Message | Should Be ''
-            $out[8].Exception.Message | Should Be 'baz'
+            ($out | measure).Count | Should -Be 9
+            $out[0].Exception.Message | Should -BeExactly 'foo'
+            $out[1].Exception.Message | Should -BeExactly ''
+            $out[2].Exception.Message | Should -BeExactly 'bar'
+            $out[3].Exception.Message | Should -BeExactly ''
+            $out[4].Exception.Message | Should -BeExactly 'bazmiddlefoo'
+            $out[5].Exception.Message | Should -BeExactly ''
+            $out[6].Exception.Message | Should -BeExactly 'bar'
+            $out[7].Exception.Message | Should -BeExactly ''
+            $out[8].Exception.Message | Should -BeExactly 'baz'
         }
 
         It 'preserves error stream as is with Out-String' {
-            ($out | Out-String).Replace("`r", '') | Should Be "foo`n`nbar`n`nbazmiddlefoo`n`nbar`n`nbaz`n"
+            ($out | Out-String).Replace("`r", '') | Should -BeExactly "foo`n`nbar`n`nbazmiddlefoo`n`nbar`n`nbaz`n"
         }
 
         It 'does not get truncated or split when redirected' {
@@ -59,8 +59,8 @@ Describe "Native streams behavior with PowerShell" -Tags 'CI' {
             }
             pwsh -c "& { [Console]::Error.WriteLine('$longtext') }" 2>&1 > $testdrive\error.txt
             $e = Get-Content -Path $testdrive\error.txt
-            $e.Count | Should BeExactly 1
-            $e | Should BeExactly $longtext
+            $e.Count | Should -Be 1
+            $e | Should -BeExactly $longtext
         }
     }
 }
@@ -71,6 +71,6 @@ Describe 'piping powershell objects to finished native executable' -Tags 'CI' {
             Start-Sleep -Milliseconds 100
             # yield some multi-line formatted object
             @{'a' = 'b'}
-        } | testexe -echoargs | Should Be $null
+        } | testexe -echoargs | Should -BeNullOrEmpty
     }
 }
diff --git a/test/powershell/Language/Scripting/NativeExecution/NativeUnixGlobbing.Tests.ps1 b/test/powershell/Language/Scripting/NativeExecution/NativeUnixGlobbing.Tests.ps1
index d301bc3a14..b059398974 100644
--- a/test/powershell/Language/Scripting/NativeExecution/NativeUnixGlobbing.Tests.ps1
+++ b/test/powershell/Language/Scripting/NativeExecution/NativeUnixGlobbing.Tests.ps1
@@ -4,7 +4,7 @@
 Describe 'Native UNIX globbing tests' -tags "CI" {
 
     BeforeAll {
-        if (-not $IsWindows )
+        if (-Not $IsWindows )
         {
             "" > "$TESTDRIVE/abc.txt"
             "" > "$TESTDRIVE/bbb.txt"
@@ -21,37 +21,37 @@ Describe 'Native UNIX globbing tests' -tags "CI" {
 
     # Test * expansion
     It 'The globbing pattern *.txt should match 3 files' {
-        (/bin/ls $TESTDRIVE/*.txt).Length | Should Be 3
+        (/bin/ls $TESTDRIVE/*.txt).Length | Should -Be 3
     }
     It 'The globbing pattern *b.txt should match 2 files whose basenames end in "b"' {
-        (/bin/ls $TESTDRIVE/*b.txt).Length | Should Be 2
+        (/bin/ls $TESTDRIVE/*b.txt).Length | Should -Be 2
     }
     # Test character classes
     It 'The globbing pattern should match 2 files whose names start with either "a" or "b"' {
-        (/bin/ls $TESTDRIVE/[ab]*.txt).Length | Should Be 2
+        (/bin/ls $TESTDRIVE/[ab]*.txt).Length | Should -Be 2
     }
     It 'Globbing abc.* should return one file name "abc.txt"' {
-        /bin/ls $TESTDRIVE/abc.* | Should Match "abc.txt"
+        /bin/ls $TESTDRIVE/abc.* | Should -Match "abc.txt"
     }
     # Test that ? matches any single character
     It 'Globbing [cde]b?.* should return one file name "cbb.txt"' {
-        /bin/ls $TESTDRIVE/[cde]b?.* | Should Match "cbb.txt"
+        /bin/ls $TESTDRIVE/[cde]b?.* | Should -Match "cbb.txt"
     }
 	# Test globbing with expressions
 	It 'Globbing should work with unquoted expressions' {
 	    $v = "$TESTDRIVE/abc*"
-		/bin/ls $v | Should Match "abc.txt"
+		/bin/ls $v | Should -Match "abc.txt"
 
 		$h = [pscustomobject]@{P=$v}
-		/bin/ls $h.P | Should Match "abc.txt"
+		/bin/ls $h.P | Should -Match "abc.txt"
 
 		$a = $v,$v
-		/bin/ls $a[1] | Should Match "abc.txt"
+		/bin/ls $a[1] | Should -Match "abc.txt"
 	}
 	It 'Globbing should not happen with quoted expressions' {
 	    $v = "$TESTDRIVE/abc*"
-		/bin/echo "$v" | Should BeExactly $v
-		/bin/echo '$v' | Should BeExactly '$v'
+		/bin/echo "$v" | Should -BeExactly $v
+		/bin/echo '$v' | Should -BeExactly '$v'
 	}
     It 'Should return the original pattern (<arg>) if there are no matches' -TestCases @(
         @{arg = '/nOSuCH*file'},               # No matching file
@@ -65,7 +65,7 @@ Describe 'Native UNIX globbing tests' -tags "CI" {
         @{arg = '[]'}                          # Invalid wildcard
     ) {
         param($arg)
-        /bin/echo $arg | Should BeExactly $arg
+        /bin/echo $arg | Should -BeExactly $arg
     }
     $quoteTests = @(
         @{arg = '"*"'},
@@ -73,7 +73,7 @@ Describe 'Native UNIX globbing tests' -tags "CI" {
     )
     It 'Should not expand quoted strings: <arg>' -TestCases $quoteTests {
         param($arg)
-        Invoke-Expression "/bin/echo $arg" | Should BeExactly '*'
+        Invoke-Expression "/bin/echo $arg" | Should -BeExactly '*'
     }
 	# Splat tests are skipped because they should work, but don't.
 	# Supporting this scenario would require adding a NoteProperty
@@ -86,7 +86,7 @@ Describe 'Native UNIX globbing tests' -tags "CI" {
         {
             /bin/echo @args
         }
-        Invoke-Expression "Invoke-Echo $arg" | Should BeExactly '*'
+        Invoke-Expression "Invoke-Echo $arg" | Should -BeExactly '*'
     }
     It 'Should not expand quoted strings via splat hash: <arg>' -TestCases $quoteTests -Skip {
         param($arg)
@@ -95,35 +95,35 @@ Describe 'Native UNIX globbing tests' -tags "CI" {
         {
             /bin/echo @PSBoundParameters
         }
-        Invoke-Expression "Invoke-Echo -quotedArg:$arg" | Should BeExactly "-quotedArg:*"
+        Invoke-Expression "Invoke-Echo -quotedArg:$arg" | Should -BeExactly "-quotedArg:*"
 
         # When specifing a space after the parameter, the space is removed when splatting.
         # This behavior is debatable, but it's worth adding this test anyway to detect
         # a change in behavior.
-        Invoke-Expression "Invoke-Echo -quotedArg: $arg" | Should BeExactly "-quotedArg:*"
+        Invoke-Expression "Invoke-Echo -quotedArg: $arg" | Should -BeExactly "-quotedArg:*"
     }
     # Test the behavior in non-filesystem drives
     It 'Should not expand patterns on non-filesystem drives' {
-        /bin/echo env:ps* | Should BeExactly "env:ps*"
+        /bin/echo env:ps* | Should -BeExactly "env:ps*"
     }
     # Test the behavior for files with spaces in the names
     It 'Globbing filenames with spaces should match 2 files' {
         "" > "$TESTDRIVE/foo bar.txt"
         "" > "$TESTDRIVE/foo baz.txt"
-        (/bin/ls $TESTDRIVE/foo*.txt).Length | Should Be 2
+        (/bin/ls $TESTDRIVE/foo*.txt).Length | Should -Be 2
     }
     # Test ~ expansion
     It 'Tilde should be replaced by the filesystem provider home directory' {
-        /bin/echo ~ | Should BeExactly ($executioncontext.SessionState.Provider.Get("FileSystem").Home)
+        /bin/echo ~ | Should -BeExactly ($executioncontext.SessionState.Provider.Get("FileSystem").Home)
     }
     # Test ~ expansion with a path fragment (e.g. ~/foo)
     It '~/foo should be replaced by the <filesystem provider home directory>/foo' {
-        /bin/echo ~/foo | Should BeExactly "$($executioncontext.SessionState.Provider.Get("FileSystem").Home)/foo"
+        /bin/echo ~/foo | Should -BeExactly "$($executioncontext.SessionState.Provider.Get("FileSystem").Home)/foo"
     }
 	It '~ should not be replaced when quoted' {
-		/bin/echo '~' | Should BeExactly '~'
-		/bin/echo "~" | Should BeExactly '~'
-		/bin/echo '~/foo' | Should BeExactly '~/foo'
-		/bin/echo "~/foo" | Should BeExactly '~/foo'
+		/bin/echo '~' | Should -BeExactly '~'
+		/bin/echo "~" | Should -BeExactly '~'
+		/bin/echo '~/foo' | Should -BeExactly '~/foo'
+		/bin/echo "~/foo" | Should -BeExactly '~/foo'
 	}
 }
diff --git a/test/powershell/Language/Scripting/OrderedAttributeForHashTables.Tests.ps1 b/test/powershell/Language/Scripting/OrderedAttributeForHashTables.Tests.ps1
index 1c40c70108..3ab575ca4a 100644
--- a/test/powershell/Language/Scripting/OrderedAttributeForHashTables.Tests.ps1
+++ b/test/powershell/Language/Scripting/OrderedAttributeForHashTables.Tests.ps1
@@ -14,8 +14,8 @@ Describe 'Test for cmdlet to support Ordered Attribute on hash literal nodes' -T
 
     It 'New-Object - Property Parameter Must take IDictionary' {
         $a = new-object psobject -property ([ordered]@{one=1;two=2})
-        $a | Should Not Be $null
-        $a.one | Should Be 1
+        $a | Should -Not -BeNullOrEmpty
+        $a.one | Should -Be 1
     }
 
     Context 'Select-Xml cmdlet - Namespace parameter must take IDictionary' {
@@ -40,9 +40,9 @@ Describe 'Test for cmdlet to support Ordered Attribute on hash literal nodes' -T
         { $script:a = select-xml -content $helpXml -xpath "//command:name" -namespace (
                         [ordered]@{command="http://schemas.microsoft.com/maml/dev/command/2004/10";
                                    maml="http://schemas.microsoft.com/maml/2004/10";
-                                   dev="http://schemas.microsoft.com/maml/dev/2004/10"})  } | Should Not Throw
+                                   dev="http://schemas.microsoft.com/maml/dev/2004/10"})  } | Should -Not -Throw
 
-        It '$a should not be $null' { $script:a | Should Not Be $null }
+        It '$a should not be $null' { $script:a | Should -Not -BeNullOrEmpty }
    }
 
     It 'Set-WmiInstance cmdlet - Argument parameter must take IDictionary' -skip:$IsCoreCLR {
@@ -51,9 +51,9 @@ Describe 'Test for cmdlet to support Ordered Attribute on hash literal nodes' -T
 
         { $script:a = set-wmiinstance -class win32_environment -argument ([ordered]@{Name="TestWmiInstance";
                         VariableValue="testvalu234e";
-                        UserName="<SYSTEM>"}) } | Should Not Throw
-        $script:a | Should Not Be $null
-        $script:a.Name | Should Be "TestWmiInstance"
+                        UserName="<SYSTEM>"}) } | Should -Not -Throw
+        $script:a | Should -Not -BeNullOrEmpty
+        $script:a.Name | Should -BeExactly "TestWmiInstance"
     }
 
     Context 'Select-Object cmdlet - Property parameter (Calculated properties) must take IDictionary' {
@@ -62,8 +62,8 @@ Describe 'Test for cmdlet to support Ordered Attribute on hash literal nodes' -T
 
         {$script:a = dir | select-object -property Name, (
                     [ordered]@{Name="IsDirectory";
-                               Expression ={$_.PSIsContainer}})} | Should Not Throw
+                               Expression ={$_.PSIsContainer}})} | Should -Not -Throw
 
-        It '$a should not be $null'  { $script:a | Should Not Be $null }
+        It '$a should not be $null'  { $script:a | Should -Not -BeNullOrEmpty }
     }
 }
diff --git a/test/powershell/Language/Scripting/OutErrorVariable.Tests.ps1 b/test/powershell/Language/Scripting/OutErrorVariable.Tests.ps1
index 68d0388df5..149dcd15a5 100644
--- a/test/powershell/Language/Scripting/OutErrorVariable.Tests.ps1
+++ b/test/powershell/Language/Scripting/OutErrorVariable.Tests.ps1
@@ -66,14 +66,14 @@ Describe "Tests OutVariable only" -Tags "CI" {
             & $Command -OutVariable $OutVariable > $null
         }
         $a = Get-Variable -ValueOnly $OutVariable
-        $a | Should Be $Expected
+        $a | Should -BeExactly $Expected
     }
 
     It 'Nested OutVariable' {
 
         get-bar -outVariable b > $null
-        $script:a | Should Be 'foo'
-        $b | Should Be @("bar", "foo")
+        $script:a | Should -BeExactly 'foo'
+        $b | Should -BeExactly @("bar", "foo")
     }
 }
 
@@ -137,7 +137,7 @@ Describe "Test ErrorVariable only" -Tags "CI" {
 
         }
         $a = (Get-Variable -ValueOnly $ErrorVariable) | ForEach-Object {$_.ToString()}
-        $a | should be $Expected
+        $a | Should -BeExactly $Expected
     }
 
     It 'Appending ErrorVariable Case 2: $pscmdlet.writeerror' {
@@ -146,24 +146,24 @@ Describe "Test ErrorVariable only" -Tags "CI" {
 
         get-foo2 -errorVariable +a 2> $null
 
-        $a.count | Should Be 3
-        $a| ForEach-Object {$_.ToString()} | Should Be @('a', 'b', 'foo')
+        $a.count | Should -Be 3
+        $a| ForEach-Object {$_.ToString()} | Should -BeExactly @('a', 'b', 'foo')
     }
 
     It 'Nested ErrorVariable' {
 
         get-bar -errorVariable b 2> $null
 
-        $script:a | Should be 'foo'
-        $b | Should be @("bar","foo")
+        $script:a | Should -BeExactly 'foo'
+        $b | Should -BeExactly @("bar","foo")
     }
 
     It 'Nested ErrorVariable with redirection' {
 
         get-bar -errorVariable b 2>&1 > $null
 
-        $script:a | Should be 'foo'
-        $b | Should be @("bar", "foo")
+        $script:a | Should -BeExactly 'foo'
+        $b | Should -BeExactly @("bar", "foo")
     }
 
 }
@@ -231,19 +231,19 @@ Describe "Update both OutVariable and ErrorVariable" -Tags "CI" {
 
         get-foo3 -OutVariable out -errorVariable err 2> $null > $null
 
-        $out | Should be @("foo-output-0", "foo-output-1")
-        $err | Should be "foo-error"
+        $out | Should -BeExactly @("foo-output-0", "foo-output-1")
+        $err | Should -BeExactly "foo-error"
     }
 
     It 'Update OutVariable and ErrorVariable' {
 
         get-bar2 -OutVariable script:bar_out -errorVariable script:bar_err 2> $null > $null
 
-        $foo_out | Should be @("foo-output-0", "foo-output-1")
-        $foo_err | Should be 'foo-error'
+        $foo_out | Should -BeExactly @("foo-output-0", "foo-output-1")
+        $foo_err | Should -BeExactly 'foo-error'
 
-        $bar_out | Should be @("bar-output-0", "bar-output-1", "foo-output-0", "foo-output-1")
-        $bar_err | Should be @("bar-error", "foo-error")
+        $bar_out | Should -BeExactly @("bar-output-0", "bar-output-1", "foo-output-0", "foo-output-1")
+        $bar_err | Should -BeExactly @("bar-error", "foo-error")
     }
 
     It 'Verify that exceptions are added to the ErrorVariable' {
@@ -264,7 +264,7 @@ Describe "Update both OutVariable and ErrorVariable" -Tags "CI" {
 
         get-foo4 -errorVariable err 2> $null
 
-        $err | Should be @("foo-error", "foo-exception")
+        $err | Should -BeExactly @("foo-error", "foo-exception")
     }
 
     It 'Error variable in multi-command pipeline' {
@@ -282,12 +282,12 @@ Describe "Update both OutVariable and ErrorVariable" -Tags "CI" {
 
         (get-foo5 "foo-message" -ev foo_err1 -ov foo_out1 | get-foo5 -ev foo_err2 -ov foo_out2 | get-foo5 -ev foo_err3 -ov foo_out3) 2>&1 > $null
 
-        $foo_out1 | Should be "foo-message"
-        $foo_out2 | Should be "foo-message"
-        $foo_out3 | Should be "foo-message"
-        $foo_err1 | Should be "foo-message"
-        $foo_err2 | Should be "foo-message"
-        $foo_err3 | Should be "foo-message"
+        $foo_out1 | Should -BeExactly "foo-message"
+        $foo_out2 | Should -BeExactly "foo-message"
+        $foo_out3 | Should -BeExactly "foo-message"
+        $foo_err1 | Should -BeExactly "foo-message"
+        $foo_err2 | Should -BeExactly "foo-message"
+        $foo_err3 | Should -BeExactly "foo-message"
     }
 
     Context 'Error variable in multi-command pipeline (with native cmdlet)' {
@@ -297,13 +297,13 @@ Describe "Update both OutVariable and ErrorVariable" -Tags "CI" {
         }
 
         It '$foo_err should be "foo-error"' {
-            $foo_err | Should Be "foo-error"
+            $foo_err | Should -BeExactly "foo-error"
         }
 
         It '$get_item_err.count and $get_item_err[0].exception' {
-            $get_item_err.count | Should Be 1
-            $get_item_err[0].exception | Should Not BeNullOrEmpty
-            $get_item_err[0].exception | Should BeOftype 'System.Management.Automation.ItemNotFoundException'
+            $get_item_err.count | Should -Be 1
+            $get_item_err[0].exception | Should -Not -BeNullOrEmpty
+            $get_item_err[0].exception | Should -BeOftype 'System.Management.Automation.ItemNotFoundException'
         }
     }
 
@@ -321,8 +321,8 @@ Describe "Update both OutVariable and ErrorVariable" -Tags "CI" {
 
         (get-foo -errorVariable foo_err | get-bar3 -errorVariable bar_err) 2>&1 > $null
 
-        $foo_err | Should be 'foo-error'
-        $bar_err | Should be @("bar-error", "foo-error")
+        $foo_err | Should -BeExactly 'foo-error'
+        $bar_err | Should -BeExactly @("bar-error", "foo-error")
     }
 
     It 'multi-command pipeline with nested commands' {
@@ -347,9 +347,9 @@ Describe "Update both OutVariable and ErrorVariable" -Tags "CI" {
 
         get-bar4 -errorVariable script:bar_err 2>&1 > $null
 
-        $script:foo_err1 | Should be "foo-error"
-        $script:foo_err2 | Should be "foo-error"
-        $script:bar_err | Should be @("bar-error", "foo-error")
+        $script:foo_err1 | Should -BeExactly "foo-error"
+        $script:foo_err2 | Should -BeExactly "foo-error"
+        $script:bar_err | Should -BeExactly @("bar-error", "foo-error")
     }
 
     It 'Nested output variables' {
@@ -375,20 +375,20 @@ Describe "Update both OutVariable and ErrorVariable" -Tags "CI" {
 
         get-bar5 -ev script:bar_err -ov script:bar_out 2>&1 > $null
 
-        $script:foo_out1 | Should be "foo-output"
-        $script:foo_err1 | Should be "foo-error"
+        $script:foo_out1 | Should -BeExactly "foo-output"
+        $script:foo_err1 | Should -BeExactly "foo-error"
 
-        $script:foo_out2 | Should be "foo-output"
-        $script:foo_err2 | Should be "foo-error"
+        $script:foo_out2 | Should -BeExactly "foo-output"
+        $script:foo_err2 | Should -BeExactly "foo-error"
 
-        $script:foo_out3 | Should be "foo-output"
-        $script:foo_err3 | Should be "foo-error"
+        $script:foo_out3 | Should -BeExactly "foo-output"
+        $script:foo_err3 | Should -BeExactly "foo-error"
 
-        $script:foo_out4 | Should be "foo-output"
-        $script:foo_err4 | Should be "foo-error"
+        $script:foo_out4 | Should -BeExactly "foo-output"
+        $script:foo_err4 | Should -BeExactly "foo-error"
 
-        $script:bar_out | Should be @("bar-output", "foo-output", "foo-output")
-        $script:bar_err | Should be @("bar-error", "foo-error", "foo-error")
+        $script:bar_out | Should -BeExactly @("bar-output", "foo-output", "foo-output")
+        $script:bar_err | Should -BeExactly @("bar-error", "foo-error", "foo-error")
     }
 }
 
diff --git a/test/powershell/Language/Scripting/ParameterBinding.Tests.ps1 b/test/powershell/Language/Scripting/ParameterBinding.Tests.ps1
index 589597013f..a572b74a59 100644
--- a/test/powershell/Language/Scripting/ParameterBinding.Tests.ps1
+++ b/test/powershell/Language/Scripting/ParameterBinding.Tests.ps1
@@ -18,8 +18,8 @@ Describe "Tests for parameter binding" -Tags "CI" {
                 $asyncResult = $ps.BeginInvoke()
                 $ps.EndInvoke($asyncResult)
 
-                $ps.Streams.Error.Count | Should Be 1 # the host does not implement it.
-                $ps.InvocationStateInfo.State | Should Be 'Completed'
+                $ps.Streams.Error.Count | Should -Be 1 # the host does not implement it.
+                $ps.InvocationStateInfo.State | Should -BeExactly 'Completed'
             } finally {
                 $ps.Dispose()
                 $rs.Dispose()
@@ -37,10 +37,10 @@ Describe "Tests for parameter binding" -Tags "CI" {
             {
                 $ps.AddScript($f + "get-foo").invoke()
                 $prompt = $th.ui.streams.prompt[0]
-                $prompt | should Not BeNullOrEmpty
+                $prompt | Should -Not -BeNullOrEmpty
                 $result = $prompt.split(":")
-                $result[0] | Should Match 'get-foo'
-                $result[-1] | should be 'a'
+                $result[0] | Should -Match 'get-foo'
+                $result[-1] | Should -BeExactly 'a'
             } finally {
                 $rs.Close()
                 $rs.Dispose()
@@ -57,8 +57,8 @@ Describe "Tests for parameter binding" -Tags "CI" {
             $a
         }
 
-        get-foo a | Should Be a
-        get-foo -a b | Should Be b
+        get-foo a | Should -BeExactly 'a'
+        get-foo -a b | Should -BeExactly 'b'
     }
 
     It 'Positional parameters when only one position specified: position = 1' {
@@ -68,7 +68,7 @@ Describe "Tests for parameter binding" -Tags "CI" {
             $a
         }
 
-        get-foo b | Should Be b
+        get-foo b | Should -BeExactly 'b'
     }
 
     It 'Positional parameters when only position specified: position = 2' {
@@ -78,7 +78,7 @@ Describe "Tests for parameter binding" -Tags "CI" {
             $a
         }
 
-        get-foo b | Should Be b
+        get-foo b | Should -BeExactly 'b'
     }
 
     It 'Multiple positional parameters case 1' {
@@ -89,11 +89,11 @@ Describe "Tests for parameter binding" -Tags "CI" {
             $a; $b
         }
 
-        ( get-foo c d ) -join ',' | Should Be 'c,d'
-        ( get-foo -a c d ) -join ',' | Should Be 'c,d'
-        ( get-foo -a c -b d ) -join ',' | Should Be 'c,d'
-        ( get-foo -b d c ) -join ',' | Should Be 'c,d'
-        ( get-foo c -b d ) -join ',' | Should Be 'c,d'
+        ( get-foo c d ) -join ',' | Should -BeExactly 'c,d'
+        ( get-foo -a c d ) -join ',' | Should -BeExactly 'c,d'
+        ( get-foo -a c -b d ) -join ',' | Should -BeExactly 'c,d'
+        ( get-foo -b d c ) -join ',' | Should -BeExactly 'c,d'
+        ( get-foo c -b d ) -join ',' | Should -BeExactly 'c,d'
     }
 
     It 'Multiple positional parameters case 2:  the parameters are put in different order?' {
@@ -105,7 +105,7 @@ Describe "Tests for parameter binding" -Tags "CI" {
             $a; $b
         }
 
-        (get-foo c d) -join ',' | Should Be 'd,c'
+        (get-foo c d) -join ',' | Should -BeExactly 'd,c'
     }
 
     It 'Value from pipeline' {
@@ -121,7 +121,7 @@ Describe "Tests for parameter binding" -Tags "CI" {
             }
         }
 
-        (1..10 | get-foo) -join ',' | Should Be '2,4,6,8,10'
+        (1..10 | get-foo) -join ',' | Should -BeExactly '2,4,6,8,10'
     }
 
     It 'Value from pipeline by property name' {
@@ -138,7 +138,7 @@ Describe "Tests for parameter binding" -Tags "CI" {
         }
 
         $b = 1..10 | select-object @{name='foo'; expression={$_ * 10}} | get-foo
-        $b -join ',' | Should Be '10,20,30,40,50,60,70,80,90,100'
+        $b -join ',' | Should -BeExactly '10,20,30,40,50,60,70,80,90,100'
     }
 
     It 'Value from remaining arguments' {
@@ -151,9 +151,9 @@ Describe "Tests for parameter binding" -Tags "CI" {
             $foo
         }
 
-        ( get-foo a b c d ) -join ',' | Should Be 'b,c,d'
-        ( get-foo a b -a c d ) -join ',' | Should Be 'a,b,d'
-        ( get-foo a b -a c -q d ) -join ',' | Should Be 'a,b,-q,d'
+        ( get-foo a b c d ) -join ',' | Should -BeExactly 'b,c,d'
+        ( get-foo a b -a c d ) -join ',' | Should -BeExactly 'a,b,d'
+        ( get-foo a b -a c -q d ) -join ',' | Should -BeExactly 'a,b,-q,d'
     }
 
     It 'Multiple parameter sets with Value from remaining arguments' {
@@ -166,8 +166,8 @@ Describe "Tests for parameter binding" -Tags "CI" {
         }
 
         { get-foo -a a -b b c d } | ShouldBeErrorId 'AmbiguousParameterSet,get-foo'
-        ( get-foo -a a b c d ) -join ',' | Should Be 'b,c,d'
-        ( get-foo -b b a c d ) -join ',' | Should Be 'a,c,d'
+        ( get-foo -a a b c d ) -join ',' | Should -BeExactly 'b,c,d'
+        ( get-foo -b b a c d ) -join ',' | Should -BeExactly 'a,c,d'
     }
 
     It 'Default parameter set with value from remaining arguments case 1' {
@@ -181,9 +181,9 @@ Describe "Tests for parameter binding" -Tags "CI" {
         }
 
         $x,$y,$z=get-foo a b c d
-        $x | Should Be a
-        $y | Should Be $null
-        $z -join ',' | Should Be 'b,c,d'
+        $x | Should -BeExactly 'a'
+        $y | Should -BeNullOrEmpty
+        $z -join ',' | Should -BeExactly 'b,c,d'
     }
 
     It 'Default parameter set with value from remaining argument case 2' {
@@ -198,9 +198,9 @@ Describe "Tests for parameter binding" -Tags "CI" {
 
         $x,$y,$z=get-foo a b c d
 
-        $x | Should Be $null
-        $y | Should Be 'a'
-        $z -join ',' | Should Be 'b,c,d'
+        $x | Should -BeNullOrEmpty
+        $y | Should -BeExactly 'a'
+        $z -join ',' | Should -BeExactly 'b,c,d'
     }
 
     It 'Alias are specified for parameters' {
@@ -210,17 +210,17 @@ Describe "Tests for parameter binding" -Tags "CI" {
             $a
         }
 
-        get-foo -foo b | Should Be 'b'
+        get-foo -foo b | Should -BeExactly 'b'
     }
 
     It 'Invoking with script block' {
         $foo = . { param([Parameter(position=2)] $a, [Parameter(position=1)]$b); $a; $b} a b
-        $foo[0] | Should Be b
+        $foo[0] | Should -BeExactly 'b'
     }
 
     It 'Normal functions' {
         function foo ($a, $b) {$b, $a}
-        ( foo a b ) -join ',' | Should Be 'b,a'
+        ( foo a b ) -join ',' | Should -BeExactly 'b,a'
     }
 
     It 'Null is not Allowed when AllowNull attribute is not set' {
@@ -241,7 +241,7 @@ Describe "Tests for parameter binding" -Tags "CI" {
             $a
         }
 
-        (get-foo -a $null) | Should Be $null
+        (get-foo -a $null) | Should -BeNullOrEmpty
 
     }
 
@@ -262,7 +262,7 @@ Describe "Tests for parameter binding" -Tags "CI" {
             $a
         }
 
-        get-foo -a '' | Should Be ''
+        get-foo -a '' | Should -BeExactly ''
     }
 
     It 'Empty collection is not allowed when AllowEmptyCollection it not set' {
@@ -282,7 +282,7 @@ Describe "Tests for parameter binding" -Tags "CI" {
             $a
         }
 
-        get-foo -a @() | Should Be $null
+        get-foo -a @() | Should -BeNullOrEmpty
     }
 
     It 'Unspecified non-mandatory bool should not cause exception' {
@@ -293,7 +293,7 @@ Describe "Tests for parameter binding" -Tags "CI" {
             $a
         }
 
-        42 | get-foo | Should be 42
+        42 | get-foo | Should -Be 42
     }
 
     It 'Parameter binding failure on Parameter1 should not cause parameter binding failure on Length' {
@@ -304,7 +304,7 @@ Describe "Tests for parameter binding" -Tags "CI" {
           process  { $Length }
         }
 
-        'abc' | get-foo | Should Be 3
+        'abc' | get-foo | Should -Be 3
     }
 
     It 'Binding array of string to array of bool should fail (cmdletbinding)' {
@@ -326,8 +326,8 @@ Describe "Tests for parameter binding" -Tags "CI" {
         }
 
         $x = get-foo 'a','b'
-        $x[0] | Should be $true
-        $x[1] | Should be $true
+        $x[0] | Should -BeTrue
+        $x[1] | Should -BeTrue
     }
 
     Context 'Default value conversion tests' {
@@ -335,7 +335,7 @@ Describe "Tests for parameter binding" -Tags "CI" {
             function get-fooa
             {
                 param( [System.Reflection.MemberTypes] $memberTypes = $([Enum]::GetNames("System.Reflection.MemberTypes") -join ",") )
-                $memberTypes | Should BeOfType System.Reflection.MemberTypes
+                $memberTypes | Should -BeOfType System.Reflection.MemberTypes
             }
 
             get-fooa
@@ -346,7 +346,7 @@ Describe "Tests for parameter binding" -Tags "CI" {
             {
                 [CmdletBinding()]
                 param( [System.Reflection.MemberTypes] $memberTypes = $([Enum]::GetNames("System.Reflection.MemberTypes") -join ",") )
-                $memberTypes | Should BeOfType System.Reflection.MemberTypes
+                $memberTypes | Should -BeOfType System.Reflection.MemberTypes
             }
 
             get-foob
@@ -356,7 +356,7 @@ Describe "Tests for parameter binding" -Tags "CI" {
             function get-fooc
             {
                 param( [Parameter()] [System.Reflection.MemberTypes] $memberTypes )
-                $memberTypes | Should Be $null
+                $memberTypes | Should -BeNullOrEmpty
             }
 
             get-fooc
@@ -366,7 +366,7 @@ Describe "Tests for parameter binding" -Tags "CI" {
             function get-food
             {
                 param( [System.Reflection.MemberTypes] $memberTypes )
-                $memberTypes | Should Be $null
+                $memberTypes | Should -BeNullOrEmpty
             }
 
             get-food
@@ -379,7 +379,7 @@ Describe "Tests for parameter binding" -Tags "CI" {
                 $p
             }
 
-            get-fooe| Should Be 55
+            get-fooe| Should -Be 55
         }
 
         It "Validation attributes should not run on default values when CmdletBinding is set on the parameter" {
@@ -390,7 +390,7 @@ Describe "Tests for parameter binding" -Tags "CI" {
                 $p
             }
 
-            get-foof| Should Be 55
+            get-foof| Should -Be 55
         }
 
         It "Validation attributes should not run on default values" {
@@ -400,7 +400,7 @@ Describe "Tests for parameter binding" -Tags "CI" {
                 $p
             }
 
-            { get-foog } | Should not throw
+            { get-foog } | Should -Not -throw
         }
 
         It "Validation attributes should not run on default values when CmdletBinding is set" {
@@ -411,7 +411,7 @@ Describe "Tests for parameter binding" -Tags "CI" {
                 $p
             }
 
-            { get-fooh } | Should not throw
+            { get-fooh } | Should -Not -throw
         }
 
         It "ValidateScript can use custom ErrorMessage" {
@@ -429,7 +429,7 @@ Describe "Tests for parameter binding" -Tags "CI" {
             {
                 $errMsg = $_.Exception.Message
             }
-            $errMsg | Should Be "Cannot validate argument on parameter 'p'. Item '2' failed '`$_ -gt 2' validation"
+            $errMsg | Should -BeExactly "Cannot validate argument on parameter 'p'. Item '2' failed '`$_ -gt 2' validation"
         }
 
         It "ValidatePattern can use custom ErrorMessage" {
@@ -448,7 +448,7 @@ Describe "Tests for parameter binding" -Tags "CI" {
             {
                 $errMsg = $_.Exception.Message
             }
-            $errMsg | Should Be "Cannot validate argument on parameter 'p'. Item '2' failed '\s+' regex"
+            $errMsg | Should -BeExactly "Cannot validate argument on parameter 'p'. Item '2' failed '\s+' regex"
         }
 
         It "ValidateSet can use custom ErrorMessage" {
@@ -466,7 +466,7 @@ Describe "Tests for parameter binding" -Tags "CI" {
                 $errMsg = $_.Exception.Message
             }
             $set = 'A','B','C' -join [Globalization.CultureInfo]::CurrentUICulture.TextInfo.ListSeparator
-            $errMsg | Should Be "Cannot validate argument on parameter 'p'. Item '2' is not in '$set'"
+            $errMsg | Should -BeExactly "Cannot validate argument on parameter 'p'. Item '2' is not in '$set'"
         }
 
     }
@@ -510,7 +510,7 @@ Describe "Tests for parameter binding" -Tags "CI" {
 '@ | ForEach-Object {$_.assembly} | Import-module
             }
 
-        Get-TestCmdlet -MyParameter @{ a = 42 } | Should Be 'hashtable'
+        Get-TestCmdlet -MyParameter @{ a = 42 } | Should -BeExactly 'hashtable'
     }
 
     It 'Parameter pasing is consuming enumerators' {
@@ -521,6 +521,6 @@ Describe "Tests for parameter binding" -Tags "CI" {
         & { } $b
 
         #The position of the enumerator shouldn't be modified
-        $b.current |Should Be 1
+        $b.current | Should -Be 1
     }
 }
diff --git a/test/powershell/Language/Scripting/Requires.Tests.ps1 b/test/powershell/Language/Scripting/Requires.Tests.ps1
index d4a25d04a7..c7bcd051fd 100644
--- a/test/powershell/Language/Scripting/Requires.Tests.ps1
+++ b/test/powershell/Language/Scripting/Requires.Tests.ps1
@@ -22,7 +22,7 @@ Describe "Requires tests" -Tags "CI" {
             }
             catch
             {
-                $_.FullyQualifiedErrorId | Should Be "ParseException"
+                $_.FullyQualifiedErrorId | Should -BeExactly "ParseException"
             }
         }
     }
diff --git a/test/powershell/Language/Scripting/ScriptHelp.Tests.ps1 b/test/powershell/Language/Scripting/ScriptHelp.Tests.ps1
index 3e54716545..a870b50a39 100644
--- a/test/powershell/Language/Scripting/ScriptHelp.Tests.ps1
+++ b/test/powershell/Language/Scripting/ScriptHelp.Tests.ps1
@@ -11,26 +11,26 @@ Describe 'get-help HelpFunc1' -Tags "Feature" {
         [System.Management.Automation.ErrorRecord[]]$e,
         [string] $expectedError
         )
-        It 'Help result should be $null' { $x | Should Be $null }
-        It '$e.Count' { $e.Count | Should BeGreaterThan 0 }
-        It 'FullyQualifiedErrorId' { $e[0].FullyQualifiedErrorId | Should Be $expectedError }
+        It 'Help result should be $null' { $x | Should -BeNullOrEmpty }
+        It '$e.Count' { $e.Count | Should -BeGreaterThan 0 }
+        It 'FullyQualifiedErrorId' { $e[0].FullyQualifiedErrorId | Should -BeExactly $expectedError }
     }
 
     function TestHelpFunc1 {
         [CmdletBinding()]
         param( $x )
-        It '$x should not be $null' { $x | Should Not Be $null }
-        It '$x.Synopsis' { $x.Synopsis | Should Be "A relatively useless function." }
-        It '$x.Description' { $x.Description[0].Text | Should Be "A description`n`n    with indented text and a blank line." }
-        It '$x.alertSet.alert' { $x.alertSet.alert[0].Text | Should Be "This function is mostly harmless." }
-        It '$x.relatedLinks.navigationLink[0].uri' {  $x.relatedLinks.navigationLink[0].uri | Should Be "http://blogs.msdn.com/powershell" }
-        It '$x.relatedLinks.navigationLink[1].linkText' { $x.relatedLinks.navigationLink[1].linkText | Should Be "other commands" }
-        It '$x.examples.example.code' { $x.examples.example.code | Should Be "If you need an example, you're hopeless." }
-        It '$x.inputTypes.inputType.type.name' { $x.inputTypes.inputType.type.name | Should Be "Anything you like." }
-        It '$x.returnValues.returnValue.type.name' { $x.returnValues.returnValue.type.name | Should Be  "Nothing." }
-        It '$x.Component' { $x.Component | Should Be "Something" }
-        It '$x.Role' { $x.Role | Should Be "CrazyUser" }
-        It '$x.Functionality' { $x.Functionality | Should Be "Useless" }
+        It '$x should not be $null' { $x | Should -Not -BeNullOrEmpty }
+        It '$x.Synopsis' { $x.Synopsis | Should -BeExactly "A relatively useless function." }
+        It '$x.Description' { $x.Description[0].Text | Should -BeExactly "A description`n`n    with indented text and a blank line." }
+        It '$x.alertSet.alert' { $x.alertSet.alert[0].Text | Should -BeExactly "This function is mostly harmless." }
+        It '$x.relatedLinks.navigationLink[0].uri' {  $x.relatedLinks.navigationLink[0].uri | Should -BeExactly "http://blogs.msdn.com/powershell" }
+        It '$x.relatedLinks.navigationLink[1].linkText' { $x.relatedLinks.navigationLink[1].linkText | Should -BeExactly "other commands" }
+        It '$x.examples.example.code' { $x.examples.example.code | Should -BeExactly "If you need an example, you're hopeless." }
+        It '$x.inputTypes.inputType.type.name' { $x.inputTypes.inputType.type.name | Should -BeExactly "Anything you like." }
+        It '$x.returnValues.returnValue.type.name' { $x.returnValues.returnValue.type.name | Should -BeExactly "Nothing." }
+        It '$x.Component' { $x.Component | Should -BeExactly "Something" }
+        It '$x.Role' { $x.Role | Should -BeExactly "CrazyUser" }
+        It '$x.Functionality' { $x.Functionality | Should -BeExactly "Useless" }
         }
 
         # .SYNOPSIS
@@ -95,7 +95,7 @@ Describe 'get-help HelpFunc1' -Tags "Feature" {
     Context 'get-help helpFunc1 -component Something' {
         $x = get-help helpFunc1 -component Something -ea SilentlyContinue -ev e
         TestHelpFunc1 $x
-        It '$e should be empty' { $e.Count | Should Be 0 }
+        It '$e should be empty' { $e.Count | Should -Be 0 }
     }
 
     Context 'get-help helpFunc1 -role blah' {
@@ -106,7 +106,7 @@ Describe 'get-help HelpFunc1' -Tags "Feature" {
     Context 'get-help helpFunc1 -role CrazyUser' {
         $x = get-help helpFunc1 -role CrazyUser -ea SilentlyContinue -ev e
         TestHelpFunc1 $x
-        It '$e should be empty' { $e.Count | Should Be 0 }
+        It '$e should be empty' { $e.Count | Should -Be 0 }
     }
 
     Context '$x = get-help helpFunc1 -functionality blah' {
@@ -117,7 +117,7 @@ Describe 'get-help HelpFunc1' -Tags "Feature" {
     Context '$x = get-help helpFunc1 -functionality Useless' {
         $x = get-help helpFunc1 -functionality Useless -ea SilentlyContinue -ev e
         TestHelpFunc1 $x
-        It '$e should be empty' { $e.Count | Should Be 0 }
+        It '$e should be empty' { $e.Count | Should -Be 0 }
     }
 }
 
@@ -147,9 +147,9 @@ Describe 'get-help file' -Tags "CI" {
 '@ > $tmpfile
 
         $x = get-help $tmpfile
-        It '$x should not be $null' { $x | Should Not Be $null }
+        It '$x should not be $null' { $x | Should -Not -BeNullOrEmpty }
         $x = & $tmpfile
-        It '$x.Synopsis' { $x.Synopsis | Should Be 'Function help, not script help' }
+        It '$x.Synopsis' { $x.Synopsis | Should -BeExactly 'Function help, not script help' }
     }
 
     Context 'get-help file2' {
@@ -168,9 +168,9 @@ Describe 'get-help file' -Tags "CI" {
 '@ > $tmpfile
 
         $x = get-help $tmpfile
-        It '$x.Synopsis' { $x.Synopsis | Should Be 'Script help, not function help' }
+        It '$x.Synopsis' { $x.Synopsis | Should -BeExactly 'Script help, not function help' }
         $x = & $tmpfile
-        It '$x should not be $null' { $x | Should Not Be $null }
+        It '$x should not be $null' { $x | Should -Not -BeNullOrEmpty }
     }
 }
 
@@ -198,8 +198,8 @@ Describe 'get-help other tests' -Tags "CI" {
 
         function missingHelp { param($abc) }
             $x = get-help missingHelp
-            It '$x should not be $null' { $x | Should Not Be $null }
-            It '$x.Synopsis' { $x.Synopsis.Trim() | Should Be 'missingHelp [[-abc] <Object>]' }
+            It '$x should not be $null' { $x | Should -Not -BeNullOrEmpty }
+            It '$x.Synopsis' { $x.Synopsis.Trim() | Should -BeExactly 'missingHelp [[-abc] <Object>]' }
         }
 
     Context 'get-help helpFunc2' {
@@ -212,8 +212,8 @@ Describe 'get-help other tests' -Tags "CI" {
     function helpFunc2 { param($abc) }
 
         $x = get-help helpFunc2
-        It '$x should not be $null' { $x | Should Not Be $null }
-        It '$x.Synopsis' { $x.Synopsis.Trim() | Should Be 'This help block goes on helpFunc2' }
+        It '$x should not be $null' { $x | Should -Not -BeNullOrEmpty }
+        It '$x.Synopsis' { $x.Synopsis.Trim() | Should -BeExactly 'This help block goes on helpFunc2' }
     }
 
     Context 'get-help file and get-help helpFunc2' {
@@ -234,10 +234,10 @@ Describe 'get-help other tests' -Tags "CI" {
 
         Set-Content $tempFile $script
         $x = get-help $tempFile
-        It '$x.Synopsis' { $x.Synopsis | Should Be "This is script help" }
+        It '$x.Synopsis' { $x.Synopsis | Should -BeExactly "This is script help" }
 
         $x = & $tempFile
-        It '$x.Synopsis' { $x.Synopsis | Should Be "This is function help for helpFunc2" }
+        It '$x.Synopsis' { $x.Synopsis | Should -BeExactly "This is function help for helpFunc2" }
     }
 
     Context 'get-help file and get-help helpFunc2' {
@@ -258,10 +258,10 @@ Describe 'get-help other tests' -Tags "CI" {
 
         Set-Content $tempFile $script
         $x = get-help $tempFile
-        It $x.Synopsis { $x.Synopsis | Should Be "This is script help" }
+        It $x.Synopsis { $x.Synopsis | Should -BeExactly "This is script help" }
 
         $x = & $tempFile
-        It $x.Synopsis { $x.Synopsis | Should Be "This is function help for helpFunc2" }
+        It $x.Synopsis { $x.Synopsis | Should -BeExactly "This is function help for helpFunc2" }
     }
 
     Context 'get-help psuedo file' {
@@ -294,13 +294,13 @@ Describe 'get-help other tests' -Tags "CI" {
         Set-Content $tempFile $script
         $x = get-help $tempFile
 
-        It '$x.Synopsis' { $x.Synopsis | Should Be "Changes Admin passwords across all KDE servers." }
-        It '$x.parameters.parameter[0].required' { $x.parameters.parameter[0].required | Should Be $true}
-        It '$x.syntax.syntaxItem[0].parameter.required' { $x.syntax.syntaxItem[0].parameter.required | Should Be $true}
-        It '$x.syntax.syntaxItem[0].parameter.parameterValue.required' { $x.syntax.syntaxItem[0].parameter.parameterValue.required | Should Be $true}
-        It 'Common parameters should not be appear in the syntax' { $x.Syntax -like "*verbose*" | Should Be $false }
-        It 'Common parameters should not be in syntax maml' {@($x.syntax.syntaxItem[0].parameter).Count | Should Be 1}
-        It 'Common parameters should also not appear in parameters maml' { $x.parameters.parameter.Count | Should Be 2}
+        It '$x.Synopsis' { $x.Synopsis | Should -BeExactly "Changes Admin passwords across all KDE servers." }
+        It '$x.parameters.parameter[0].required' { $x.parameters.parameter[0].required | Should -BeTrue}
+        It '$x.syntax.syntaxItem[0].parameter.required' { $x.syntax.syntaxItem[0].parameter.required | Should -BeTrue}
+        It '$x.syntax.syntaxItem[0].parameter.parameterValue.required' { $x.syntax.syntaxItem[0].parameter.parameterValue.required | Should -BeTrue}
+        It 'Common parameters should not be appear in the syntax' { $x.Syntax -like "*verbose*" | Should -BeFalse }
+        It 'Common parameters should not be in syntax maml' {@($x.syntax.syntaxItem[0].parameter).Count | Should -Be 1}
+        It 'Common parameters should also not appear in parameters maml' { $x.parameters.parameter.Count | Should -Be 2}
     }
 
     It 'helpFunc3 -?' {
@@ -319,7 +319,7 @@ Describe 'get-help other tests' -Tags "CI" {
         }
 
         $x = helpFunc3 -?
-        $x.Synopsis | Should Be "A synopsis of helpFunc3."
+        $x.Synopsis | Should -BeExactly "A synopsis of helpFunc3."
     }
 
     It 'get-help helpFunc4' {
@@ -338,7 +338,7 @@ Describe 'get-help other tests' -Tags "CI" {
         }
 
         $x = get-help helpFunc4
-        $x.Synopsis | Should Be ""
+        $x.Synopsis | Should -BeExactly ""
     }
 
     Context 'get-help helpFunc5' {
@@ -348,8 +348,8 @@ Describe 'get-help other tests' -Tags "CI" {
             # .EXTERNALHELP scriptHelp.Tests.xml
         }
         $x = get-help helpFunc5
-        It '$x should not be $null' { $x | Should Not Be $null }
-        It '$x.Synopsis' { $x.Synopsis | Should Be "A useless function, really." }
+        It '$x should not be $null' { $x | Should -Not -BeNullOrEmpty }
+        It '$x.Synopsis' { $x.Synopsis | Should -BeExactly "A useless function, really." }
     }
 
     Context 'get-help helpFunc6 script help xml' {
@@ -360,8 +360,8 @@ Describe 'get-help other tests' -Tags "CI" {
         if ($PSUICulture -ieq "en-us")
         {
             $x = get-help helpFunc6
-            It '$x should not be $null' { $x | Should Not Be $null }
-            It '$x.Synopsis' { $x.Synopsis | Should Be "Useless.  Really, trust me on this one." }
+            It '$x should not be $null' { $x | Should -Not -BeNullOrEmpty }
+            It '$x.Synopsis' { $x.Synopsis | Should -BeExactly "Useless.  Really, trust me on this one." }
         }
     }
 
@@ -373,8 +373,8 @@ Describe 'get-help other tests' -Tags "CI" {
         if ($PSUICulture -ieq "en-us")
         {
             $x = get-help helpFunc6
-            It '$x should not be $null' { $x | Should Not Be $null }
-            It '$x.Synopsis' { $x.Synopsis | Should Be "Useless in newbase.  Really, trust me on this one." }
+            It '$x should not be $null' { $x | Should -Not -BeNullOrEmpty }
+            It '$x.Synopsis' { $x.Synopsis | Should -BeExactly "Useless in newbase.  Really, trust me on this one." }
         }
     }
 
@@ -386,17 +386,17 @@ Describe 'get-help other tests' -Tags "CI" {
             # .FORWARDHELPCATEGORY Cmdlet
         }
         $x = Get-Help helpFunc7
-        It '$x.Name' { $x.Name | Should Be 'Get-Help' }
-        It '$x.Category' { $x.Category | Should Be 'Cmdlet' }
+        It '$x.Name' { $x.Name | Should -BeExactly 'Get-Help' }
+        It '$x.Category' { $x.Category | Should -BeExactly 'Cmdlet' }
 
         # Make sure help is a function, or the test would fail
         if ($null -ne (get-command -type Function help))
         {
-            if ((get-content function:help) -match "FORWARDHELP")
+            if ((get-content function:help) -Match "FORWARDHELP")
             {
                 $x = Get-Help help
-                It '$x.Name' { $x.Name | Should Be 'Get-Help' }
-                It '$x.Category' { $x.Category | Should Be 'Cmdlet' }
+                It '$x.Name' { $x.Name | Should -BeExactly 'Get-Help' }
+                It '$x.Category' { $x.Category | Should -BeExactly 'Cmdlet' }
             }
         }
     }
@@ -414,10 +414,10 @@ Describe 'get-help other tests' -Tags "CI" {
         }
 
         $x = Get-Help func8
-        It '$x should not be $null' { $x | Should Not Be $null }
+        It '$x should not be $null' { $x | Should -Not -BeNullOrEmpty }
 
         $x = func8
-        It '$x.Synopsis' { $x.Synopsis | Should Be 'Help on helpFunc8, not func8' }
+        It '$x.Synopsis' { $x.Synopsis | Should -BeExactly 'Help on helpFunc8, not func8' }
     }
 
     Context 'get-help helpFunc9' {
@@ -433,9 +433,9 @@ Describe 'get-help other tests' -Tags "CI" {
             get-help func9
         }
         $x = Get-Help helpFunc9
-        It 'help is on the outer functon' { $x.Synopsis | Should Be 'Help on helpFunc9, not func9' }
+        It 'help is on the outer functon' { $x.Synopsis | Should -BeExactly 'Help on helpFunc9, not func9' }
         $x = helpFunc9
-        It '$x should not be $null' { $x | Should Not Be $null }
+        It '$x should not be $null' { $x | Should -Not -BeNullOrEmpty }
     }
 
     It 'get-help helpFunc10' {
@@ -448,7 +448,7 @@ Describe 'get-help other tests' -Tags "CI" {
         }
 
         $x = get-help helpFunc10
-        $x.Synopsis | Should Be 'Help on helpFunc10'
+        $x.Synopsis | Should -BeExactly 'Help on helpFunc10'
     }
 
     Context 'get-help helpFunc11' {
@@ -485,7 +485,7 @@ Describe 'get-help other tests' -Tags "CI" {
 
         $x = get-help helpFunc11 -det
         $x.Parameters.parameter | ForEach-Object {
-        It '$_.description' { $_.description[0].text | Should match "^$($_.Name)\s+help" }
+        It '$_.description' { $_.description[0].text | Should -Match "^$($_.Name)\s+help" }
         }
     }
 
@@ -518,20 +518,20 @@ Describe 'get-help other tests' -Tags "CI" {
          #>
         }
         $x = get-help helpFunc12
-        It '$x.syntax' { ($x.syntax | Out-String -width 250) | Should match "helpFunc12 \[-Name] <String> \[\[-Extension] <String>] \[\[-NoType] <Object>] \[-ASwitch] \[\[-AnEnum] \{Alias.*All}] \[<CommonParameters>]" }
-        It '$x.syntax.syntaxItem.parameter[3].position' { $x.syntax.syntaxItem.parameter[3].position | Should Be 'named' }
-        It '$x.syntax.syntaxItem.parameter[3].parameterValue' { $x.syntax.syntaxItem.parameter[3].parameterValue | Should Be $null }
-        It '$x.parameters.parameter[3].parameterValue' { $x.parameters.parameter[3].parameterValue | Should Not Be $null }
-        It '$x.syntax.syntaxItem.parameter[4].parameterValueGroup' { $x.syntax.syntaxItem.parameter[4].parameterValueGroup | Should Not be $null }
-        It '$x.parameters.parameter[4].parameterValueGroup' { $x.parameters.parameter[4].parameterValueGroup | Should Not be $null }
-        It '$x.examples.example[0].introduction[0].text' { $x.examples.example[0].introduction[0].text | Should Be 'PS>' }
-        It '$x.examples.example[0].code' { $x.examples.example[0].code | Should Be 'helpFunc12 -Name foo' }
-        It '$x.examples.example[0].remarks[0].text' { $x.examples.example[0].remarks[0].text | Should Be 'Adds .txt to foo' }
-        It '$x.examples.example[0].remarks.length' { $x.examples.example[0].remarks.length | Should Be 5 }
-        It '$x.examples.example[1].introduction[0].text' { $x.examples.example[1].introduction[0].text | Should Be 'C:\PS>' }
-        It '$x.examples.example[1].code' { $x.examples.example[1].code | Should Be 'helpFunc12 bar txt' }
-        It '$x.examples.example[1].remarks[0].text' { $x.examples.example[1].remarks[0].text | Should Be 'Adds .txt to bar' }
-        It '$x.examples.example[1].remarks.length' { $x.examples.example[1].remarks.length | Should Be 5 }
+        It '$x.syntax' { ($x.syntax | Out-String -width 250) | Should -Match "helpFunc12 \[-Name] <String> \[\[-Extension] <String>] \[\[-NoType] <Object>] \[-ASwitch] \[\[-AnEnum] \{Alias.*All}] \[<CommonParameters>]" }
+        It '$x.syntax.syntaxItem.parameter[3].position' { $x.syntax.syntaxItem.parameter[3].position | Should -BeExactly 'named' }
+        It '$x.syntax.syntaxItem.parameter[3].parameterValue' { $x.syntax.syntaxItem.parameter[3].parameterValue | Should -BeNullOrEmpty }
+        It '$x.parameters.parameter[3].parameterValue' { $x.parameters.parameter[3].parameterValue | Should -Not -BeNullOrEmpty }
+        It '$x.syntax.syntaxItem.parameter[4].parameterValueGroup' { $x.syntax.syntaxItem.parameter[4].parameterValueGroup | Should -Not -BeNullOrEmpty }
+        It '$x.parameters.parameter[4].parameterValueGroup' { $x.parameters.parameter[4].parameterValueGroup | Should -Not -BeNullOrEmpty }
+        It '$x.examples.example[0].introduction[0].text' { $x.examples.example[0].introduction[0].text | Should -BeExactly 'PS>' }
+        It '$x.examples.example[0].code' { $x.examples.example[0].code | Should -BeExactly 'helpFunc12 -Name foo' }
+        It '$x.examples.example[0].remarks[0].text' { $x.examples.example[0].remarks[0].text | Should -BeExactly 'Adds .txt to foo' }
+        It '$x.examples.example[0].remarks.length' { $x.examples.example[0].remarks.length | Should -Be 5 }
+        It '$x.examples.example[1].introduction[0].text' { $x.examples.example[1].introduction[0].text | Should -BeExactly 'C:\PS>' }
+        It '$x.examples.example[1].code' { $x.examples.example[1].code | Should -BeExactly 'helpFunc12 bar txt' }
+        It '$x.examples.example[1].remarks[0].text' { $x.examples.example[1].remarks[0].text | Should -BeExactly 'Adds .txt to bar' }
+        It '$x.examples.example[1].remarks.length' { $x.examples.example[1].remarks.length | Should -Be 5 }
     }
 
     Context 'get-help helpFunc12' {
@@ -553,8 +553,8 @@ Describe 'get-help other tests' -Tags "CI" {
 
         $x = get-help helpFunc13
 
-        It '$x.Parameters.parameter[0].globbing' { $x.Parameters.parameter[0].globbing | Should Be 'true' }
-        It '$x.Parameters.parameter[1].defaultValue' { $x.Parameters.parameter[1].defaultValue | Should Be '42' }
-        It '$x.Parameters.parameter[2].defaultValue' { $x.Parameters.parameter[2].defaultValue | Should Be 'parameter is mandatory' }
+        It '$x.Parameters.parameter[0].globbing' { $x.Parameters.parameter[0].globbing | Should -BeExactly 'true' }
+        It '$x.Parameters.parameter[1].defaultValue' { $x.Parameters.parameter[1].defaultValue | Should -BeExactly '42' }
+        It '$x.Parameters.parameter[2].defaultValue' { $x.Parameters.parameter[2].defaultValue | Should -BeExactly 'parameter is mandatory' }
     }
 }
diff --git a/test/powershell/Language/Scripting/Scripting.Followup.Tests.ps1 b/test/powershell/Language/Scripting/Scripting.Followup.Tests.ps1
index ff315f5e52..d80b059184 100644
--- a/test/powershell/Language/Scripting/Scripting.Followup.Tests.ps1
+++ b/test/powershell/Language/Scripting/Scripting.Followup.Tests.ps1
@@ -4,9 +4,9 @@ Describe "Scripting.Followup.Tests" -Tags "CI" {
     It "'[void](New-Item) | <Cmdlet>' should work and behave like passing AutomationNull to the pipe" {
         try {
             $testFile = Join-Path $TestDrive (New-Guid)
-            [void](New-Item $testFile -ItemType File) | ForEach-Object { "YES" } | Should Be $null
+            [void](New-Item $testFile -ItemType File) | ForEach-Object { "YES" } | Should -BeNullOrEmpty
             ## file should be created
-            $testFile | Should Exist
+            $testFile | Should -Exist
         } finally {
             Remove-Item $testFile -Force -ErrorAction SilentlyContinue
         }
@@ -15,18 +15,18 @@ Describe "Scripting.Followup.Tests" -Tags "CI" {
     ## cast non-void method call to [void]
     It "'[void]`$arraylist.Add(1) | <Cmdlet>' should work and behave like passing AutomationNull to the pipe" {
         $arraylist = [System.Collections.ArrayList]::new()
-        [void]$arraylist.Add(1) | ForEach-Object { "YES" } | Should Be $null
+        [void]$arraylist.Add(1) | ForEach-Object { "YES" } | Should -BeNullOrEmpty
         ## $arraylist.Add(1) should be executed
-        $arraylist.Count | Should Be 1
-        $arraylist[0] | Should Be 1
+        $arraylist.Count | Should -Be 1
+        $arraylist[0] | Should -Be 1
     }
 
     ## void method call
     It "'`$arraylist2.Clear() | <Cmdlet>' should work and behave like passing AutomationNull to the pipe" {
         $arraylist = [System.Collections.ArrayList]::new()
         $arraylist.Add(1) > $null
-        $arraylist.Clear() | ForEach-Object { "YES" } | Should Be $null
+        $arraylist.Clear() | ForEach-Object { "YES" } | Should -BeNullOrEmpty
         ## $arraylist.Clear() should be executed
-        $arraylist.Count | Should Be 0
+        $arraylist.Count | Should -Be 0
     }
 }
diff --git a/test/powershell/Language/Scripting/TestsOnWinFullOnly.ps1 b/test/powershell/Language/Scripting/TestsOnWinFullOnly.ps1
index 435ccea893..3a273c02b8 100644
--- a/test/powershell/Language/Scripting/TestsOnWinFullOnly.ps1
+++ b/test/powershell/Language/Scripting/TestsOnWinFullOnly.ps1
@@ -12,7 +12,7 @@ function Run-TestOnWinFull
 
             $r = TestErrorActionSuspend -ErrorAction Suspend
 
-            $r | Should Be Hello
+            $r | Should -BeExactly 'Hello'
             break;   }
 
         "ForeachParallel:ASTOfParallelForeachOnWorkflow" {
@@ -20,8 +20,8 @@ function Run-TestOnWinFull
             $errors = @()
             $ast = [System.Management.Automation.Language.Parser]::ParseInput(
         'workflow foo { foreach -parallel ($foo in $bar) {} }', [ref] $null, [ref] $errors)
-            $errors.Count | Should Be 0
-            $ast.EndBlock.Statements[0].Body.EndBlock.Statements[0].Flags | Should Be 'Parallel'
+            $errors.Count | Should -Be 0
+            $ast.EndBlock.Statements[0].Body.EndBlock.Statements[0].Flags | Should -BeExactly 'Parallel'
             break;
             }
         default {
diff --git a/test/powershell/Language/Scripting/Trap.Tests.ps1 b/test/powershell/Language/Scripting/Trap.Tests.ps1
index ed6537102e..6bf76e553b 100644
--- a/test/powershell/Language/Scripting/Trap.Tests.ps1
+++ b/test/powershell/Language/Scripting/Trap.Tests.ps1
@@ -5,26 +5,26 @@ Describe "Test trap" -Tags "CI" {
     Context "Trap with flow control" {
         It "Line after exception should NOT be continued when it's from a nested script block" {
             $a = . {trap {"trapped"; continue;}; . {"hello"; throw "exception"; "world"}}
-            $a.Length | Should Be 2
-            $a -join "," | Should Be "hello,trapped"
+            $a.Length | Should -Be 2
+            $a -join "," | Should -BeExactly "hello,trapped"
         }
 
         It "Line after exception should NOT be continued and both inner and outter traps should be triggered" {
             $a = . {trap {"outer trap"; continue;}; . {trap {"inner trap"; break;}; "hello"; throw "exception"; "world"}}
-            $a.Length | Should Be 3
-            $a -join "," | Should Be "hello,inner trap,outer trap"
+            $a.Length | Should -Be 3
+            $a -join "," | Should -BeExactly "hello,inner trap,outer trap"
         }
 
         It "Line after exception should be invoked after continue" {
             $a = . {trap {"outer trap"; continue;} "hello"; throw "exception"; "world"}
-            $a.Length | Should Be 3
-            $a -join "," | Should Be "hello,outer trap,world"
+            $a.Length | Should -Be 3
+            $a -join "," | Should -BeExactly "hello,outer trap,world"
         }
 
         It "Line after exception should NOT be invoked and inner trap should not be triggered" {
             $a = . {trap {"outer trap"; continue;}; . {trap [system.Argumentexception] {"inner trap"; continue;}; "hello"; throw "exception"; "world"}}
-            $a.Length | Should Be 2
-            $a -join "," | Should Be "hello,outer trap"
+            $a.Length | Should -Be 2
+            $a -join "," | Should -BeExactly "hello,outer trap"
         }
     }
 }
diff --git a/test/powershell/Language/Scripting/TryCatch.Tests.ps1 b/test/powershell/Language/Scripting/TryCatch.Tests.ps1
index fa82524fc6..63df99d1db 100644
--- a/test/powershell/Language/Scripting/TryCatch.Tests.ps1
+++ b/test/powershell/Language/Scripting/TryCatch.Tests.ps1
@@ -12,9 +12,9 @@ Describe "Test try/catch" -Tags "CI" {
     BeforeAll {
         function AssertArraysEqual ($result, $expected)
         {
-            $result.Count | Should Be $expected.Count
+            $result.Count | Should -BeExactly $expected.Count
             for ($i = 0; $i -lt $result.Count; $i++) {
-                $result[$i] | Should Be $expected[$i]
+                $result[$i] | Should -BeExactly $expected[$i]
             }
         }
     }
@@ -86,7 +86,7 @@ Describe "Test try/catch" -Tags "CI" {
         {
         }
 
-        $true | Should Be $true # we only verify that there is no parsing error. This line contains a dummy Should to make pester happy.
+        $true | Should -BeTrue # we only verify that there is no parsing error. This line contains a dummy Should to make pester happy.
     }
 
     Context "Basic exception handling" {
@@ -515,7 +515,7 @@ Describe "Test try/catch" -Tags "CI" {
               }
             }
 
-            [int]$a.ToString() | Should Be 42
+            [int]$a.ToString() | Should -Be 42
         }
     }
 
@@ -565,7 +565,7 @@ Describe "Test try/catch" -Tags "CI" {
             }
 
             AssertArraysEqual $a ("inner catch", "outer catch")
-            ($ex_inner.Exception -eq $ex_outer.Exception) | Should Be $true
+            $ex_inner.Exception | Should -BeExactly $ex_outer.Exception
         }
 
         It "throw; outside catch threw wrong object" {
@@ -587,7 +587,7 @@ Describe "Test try/catch" -Tags "CI" {
               }
             }
 
-            ($a -eq "test passed") | Should Be $true
+            $a | Should -BeExactly "test passed"
         }
     }
 
@@ -601,9 +601,9 @@ Describe "Test try/catch" -Tags "CI" {
                     $exception = $_.Exception.GetType().FullName
                     "ActionPreferenceStopException Caught"
                  }
-            $a | Should Be "ActionPreferenceStopException Caught"
+            $a | Should -BeExactly "ActionPreferenceStopException Caught"
             ## Many legacy scripts from PSv2 catch 'ActionPreferenceStopException' and then check '$_.Exception' to do the real handling
-            $exception | Should Be "System.Management.Automation.ItemNotFoundException"
+            $exception | Should -BeExactly "System.Management.Automation.ItemNotFoundException"
         }
 
         It "Catch CmdletInvocationException" {
@@ -614,8 +614,8 @@ Describe "Test try/catch" -Tags "CI" {
                     $exception = $_.Exception.GetType().FullName
                     "CmdletInvocationException Caught"
                  }
-            $a | Should Be "CmdletInvocationException Caught"
-            $exception | Should Be "System.Management.Automation.ParameterBindingException"
+            $a | Should -BeExactly "CmdletInvocationException Caught"
+            $exception | Should -BeExactly "System.Management.Automation.ParameterBindingException"
         }
 
         It "Choose 'ItemNotFoundException' over 'Exception' when searching handler" {
@@ -626,7 +626,7 @@ Describe "Test try/catch" -Tags "CI" {
                  } catch [System.Exception] {
                     "System.Exception caught"
                  }
-            $a | Should Be "ItemNotFoundException caught"
+            $a | Should -BeExactly "ItemNotFoundException caught"
         }
 
         It "Choose 'ItemNotFoundException' over 'RuntimeException' when searching handler" {
@@ -639,7 +639,7 @@ Describe "Test try/catch" -Tags "CI" {
                  } catch [System.Exception] {
                     "System.Exception caught"
                  }
-            $a | Should Be "ItemNotFoundException caught"
+            $a | Should -BeExactly "ItemNotFoundException caught"
         }
 
         It "Choose 'ItemNotFoundException' over 'RuntimeException' and 'Exception' when throw ItemNotFoundException directly" {
@@ -652,7 +652,7 @@ Describe "Test try/catch" -Tags "CI" {
                  } catch [System.Exception] {
                     "System.Exception caught"
                  }
-            $a | Should Be "ItemNotFoundException caught"
+            $a | Should -BeExactly "ItemNotFoundException caught"
         }
     }
 }