Plumb error codes through.

johanste · johanste · commit 51facfa5cf8d · 2015-12-10T19:55:15.000-08:00
Add basic batch file and test cmdlets for error codes and pipeline aliasing
diff --git a/src/CLU/Microsoft.CLU.Common/ICommandModel.cs b/src/CLU/Microsoft.CLU.Common/ICommandModel.cs
@@ -1,4 +1,4 @@
-﻿namespace Microsoft.CLU.Common
+﻿namespace Microsoft.CLU
 {
     public enum CommandModelErrorCode
     {
diff --git a/src/CLU/Microsoft.CLU.Run/CommandExecMode.cs b/src/CLU/Microsoft.CLU.Run/CommandExecMode.cs
@@ -27,12 +27,12 @@ public bool CanHandle(string[] arguments)
         /// IRunMode implementation for executing command.
         /// </summary>
         /// <param name="arguments">The arguments</param>
-        public Microsoft.CLU.Common.CommandModelErrorCode Run(string[] arguments)
+        public Microsoft.CLU.CommandModelErrorCode Run(string[] arguments)
         {
             if (arguments.Length < 2)
             {
                 CLUEnvironment.Console.WriteErrorLine(Strings.CommandExecMode_Run_MissingCommandConfigFileArgument);
-                return Microsoft.CLU.Common.CommandModelErrorCode.MissingParameters;
+                return Microsoft.CLU.CommandModelErrorCode.MissingParameters;
             }
 
             try
@@ -52,7 +52,7 @@ public Microsoft.CLU.Common.CommandModelErrorCode Run(string[] arguments)
                                 arguments[argsBase + 1].StartsWith("-", StringComparison.Ordinal))
                             {
                                 CLUEnvironment.Console.WriteErrorLine(Strings.CommandExecMode_Run_MissingScriptName);
-                                return Microsoft.CLU.Common.CommandModelErrorCode.MissingParameters;
+                                return Microsoft.CLU.CommandModelErrorCode.MissingParameters;
                             }
 
                             CLUEnvironment.ScriptName = arguments[argsBase + 1];
@@ -65,7 +65,7 @@ public Microsoft.CLU.Common.CommandModelErrorCode Run(string[] arguments)
                                 arguments[argsBase + 1].StartsWith("-", StringComparison.Ordinal))
                             {
                                 CLUEnvironment.Console.WriteErrorLine(Strings.CommandExecMode_Run_MissingScriptConfigFileName);
-                                return Microsoft.CLU.Common.CommandModelErrorCode.MissingParameters;
+                                return Microsoft.CLU.CommandModelErrorCode.MissingParameters;
                             }
 
                             commandConfiguration = CommandConfig.Load(arguments[argsBase + 1]);
@@ -90,7 +90,7 @@ public Microsoft.CLU.Common.CommandModelErrorCode Run(string[] arguments)
                 CLUEnvironment.Console.WriteDebugLine($"{exc.GetType().FullName}\n{exc.StackTrace}");
             }
 
-            return Common.CommandModelErrorCode.InternalFailure;
+            return CommandModelErrorCode.InternalFailure;
         }
 
         #endregion
diff --git a/src/CLU/Microsoft.CLU.Run/CommandModel.cs b/src/CLU/Microsoft.CLU.Run/CommandModel.cs
@@ -19,7 +19,7 @@ internal class CommandModel
         /// </summary>
         /// <param name="commandConfiguration"></param>
         /// <param name="modelArguments"></param>
-        public static Microsoft.CLU.Common.CommandModelErrorCode Run(CommandConfig commandConfiguration, string[] modelArguments)
+        public static Microsoft.CLU.CommandModelErrorCode Run(CommandConfig commandConfiguration, string[] modelArguments)
         {
             CommandModel commandModel = new CommandModel()
             {
diff --git a/src/CLU/Microsoft.CLU.Run/IRunMode.cs b/src/CLU/Microsoft.CLU.Run/IRunMode.cs
@@ -17,6 +17,6 @@ internal interface IRunMode
         /// IRunMode implementation.
         /// </summary>
         /// <param name="arguments">The arguments</param>
-        Microsoft.CLU.Common.CommandModelErrorCode Run(string[] arguments);
+        Microsoft.CLU.CommandModelErrorCode Run(string[] arguments);
     }
 }
diff --git a/src/CLU/Microsoft.CLU.Run/PackageManagementMode.cs b/src/CLU/Microsoft.CLU.Run/PackageManagementMode.cs
@@ -33,7 +33,7 @@ public bool CanHandle(string[] arguments)
         /// IRunMode implementation for package managment.
         /// </summary>
         /// <param name="arguments">The arguments</param>
-        public Microsoft.CLU.Common.CommandModelErrorCode Run(string[] arguments)
+        public Microsoft.CLU.CommandModelErrorCode Run(string[] arguments)
         {
             _packagesRootPath = CLUEnvironment.GetPackagesRootPath();
             try
@@ -44,13 +44,13 @@ public Microsoft.CLU.Common.CommandModelErrorCode Run(string[] arguments)
             {
                 CLUEnvironment.Console.WriteErrorLine(tie.InnerException.Message);
                 CLUEnvironment.Console.WriteDebugLine($"{tie.InnerException.GetType().FullName}\n{tie.InnerException.StackTrace}");
-                return Microsoft.CLU.Common.CommandModelErrorCode.InternalFailure;
+                return Microsoft.CLU.CommandModelErrorCode.InternalFailure;
             }
             catch (Exception exc)
             {
                 CLUEnvironment.Console.WriteErrorLine(exc.Message);
                 CLUEnvironment.Console.WriteDebugLine($"{exc.GetType().FullName}\n{exc.StackTrace}");
-                return Microsoft.CLU.Common.CommandModelErrorCode.InternalFailure;
+                return Microsoft.CLU.CommandModelErrorCode.InternalFailure;
             }
 
             try
@@ -77,7 +77,7 @@ public Microsoft.CLU.Common.CommandModelErrorCode Run(string[] arguments)
                                     arguments[argsBase + 1].StartsWith("-", StringComparison.Ordinal))
                                 {
                                     CLUEnvironment.Console.WriteLine(Strings.PackageManagementMode_Run_VersionIdMissing);
-                                    return Microsoft.CLU.Common.CommandModelErrorCode.MissingParameters;
+                                    return Microsoft.CLU.CommandModelErrorCode.MissingParameters;
                                 }
                                 version = arguments[argsBase + 1];
                                 argsBase += 2;
@@ -145,13 +145,13 @@ public Microsoft.CLU.Common.CommandModelErrorCode Run(string[] arguments)
             {
                 CLUEnvironment.Console.WriteErrorLine(tie.InnerException.Message);
                 CLUEnvironment.Console.WriteDebugLine($"{tie.InnerException.GetType().FullName}\n{tie.InnerException.StackTrace}");
-                return Microsoft.CLU.Common.CommandModelErrorCode.InternalFailure;
+                return Microsoft.CLU.CommandModelErrorCode.InternalFailure;
             }
             catch (Exception exc)
             {
                 CLUEnvironment.Console.WriteErrorLine(exc.Message);
                 CLUEnvironment.Console.WriteDebugLine($"{exc.GetType().FullName}\n{exc.StackTrace}");
-                return Microsoft.CLU.Common.CommandModelErrorCode.InternalFailure;
+                return Microsoft.CLU.CommandModelErrorCode.InternalFailure;
             }
 
             return CommandModelErrorCode.Success;
diff --git a/src/CLU/Microsoft.CLU.Run/Program.cs b/src/CLU/Microsoft.CLU.Run/Program.cs
@@ -17,7 +17,7 @@ public static void Main(string[] args) { }
         /// Microsoft.CLU.Run (clurun.exe) main entry point.
         /// </summary>
         /// <param name="args">The commandline arguments</param>
-        public static Microsoft.CLU.Common.CommandModelErrorCode Execute(string[] args)
+        public static Microsoft.CLU.CommandModelErrorCode Execute(string[] args)
         {
             CLUEnvironment.Console = new ConsoleInputOutput(args);
 
@@ -36,20 +36,20 @@ public static Microsoft.CLU.Common.CommandModelErrorCode Execute(string[] args)
             {
                 CLUEnvironment.Console.WriteErrorLine(exc.Message);
                 CLUEnvironment.Console.WriteDebugLine(exc.StackTrace);
-                return Microsoft.CLU.Common.CommandModelErrorCode.InternalFailure;
+                return Microsoft.CLU.CommandModelErrorCode.InternalFailure;
             }
         }
 
         /// <summary>
         /// Parse the commandline argument and bootstrap the command execution.
         /// </summary>
         /// <param name="arguments">The commandline arguments</param>
-        private Microsoft.CLU.Common.CommandModelErrorCode Parse(string [] arguments)
+        private Microsoft.CLU.CommandModelErrorCode Parse(string [] arguments)
         {
             if (arguments.Count() == 0)
             {
                 DisplayHelp();
-                return Common.CommandModelErrorCode.MissingParameters;
+                return CommandModelErrorCode.MissingParameters;
             }
 
             var mode = GetMode(arguments);
diff --git a/src/CLU/Microsoft.CLU.Test/PipelineAliasTest.cs b/src/CLU/Microsoft.CLU.Test/PipelineAliasTest.cs
@@ -5,7 +5,7 @@
 
 using System.Management.Automation;
 
-namespace Microsoft.Azure.Commands.Resources.Test
+namespace Microsoft.CLU.Test
 {
 
     public class TestRecord
diff --git a/src/CLU/Microsoft.CLU.Test/ReturnCodeTest.cs b/src/CLU/Microsoft.CLU.Test/ReturnCodeTest.cs
@@ -0,0 +1,45 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+using System.Management.Automation;
+
+namespace Microsoft.CLU.Test
+{
+
+    [Cmdlet(VerbsCommon.Show, "Success")]
+    public class ShowSuccess: PSCmdlet
+    {
+        [Parameter()]
+        public bool GenerateNonTerminatingError{ get; set; }
+
+        [Parameter()]
+        public bool GenerateTerminatingError{ get; set; }
+
+        protected override void ProcessRecord()
+        {
+            base.ProcessRecord();
+
+            if (GenerateNonTerminatingError)
+            {
+                var errorRecord = new ErrorRecord(
+                        new InvalidOperationException("I was asked to generate a non-terminating error"),
+                        "TestAssert",
+                        ErrorCategory.InvalidOperation,
+                        this);
+                this.WriteError(errorRecord);
+            }
+            if (GenerateTerminatingError)
+            {
+                var errorRecord = new ErrorRecord(
+                        new InvalidOperationException("I was asked to generate a terminating error"),
+                        "TestAssert",
+                        ErrorCategory.InvalidOperation,
+                        this);
+                this.ThrowTerminatingError(errorRecord);
+            }
+
+        }
+    }
+}
diff --git a/src/CLU/Microsoft.CLU.Test/TestCLU.bat b/src/CLU/Microsoft.CLU.Test/TestCLU.bat
@@ -0,0 +1,30 @@
+SETLOCAL EnableExtensions
+
+ECHO Test return code success case
+call azure success show
+REM We expect that the commands above succeed (return 0)
+IF ERRORLEVEL 1 (EXIT /B 1)
+
+ECHO Test return codes non terminating error case
+call azure success show --generatenonterminatingerror true
+if ERRORLEVEL 1 goto :verify_error_code_2
+REM We expect the error code to be 1 - so we shouldn't be here
+EXIT /B 1
+:verify_error_code_2
+IF ERRORLEVEL 2 (EXIT /B 1)
+
+ECHO Test return codes terminating error case
+call azure success show --generateterminatingerror true
+if ERRORLEVEL 2 goto :verify_error_code_3
+REM We expect the error code to be 1 - so we shouldn't be here
+EXIT /B 1
+:verify_error_code_3
+IF ERRORLEVEL 3 (EXIT /B 1)
+
+ECHO Test pipeline aliasing
+call azure test record new > testrecordnew.json
+call azure test record show < testrecordnew.json
+
+REM We expect that the commands above succeed
+IF ERRORLEVEL 1 (EXIT /B 1)
+
diff --git a/src/CLU/Microsoft.CLU/CommandModel/CmdletCommandModel.cs b/src/CLU/Microsoft.CLU/CommandModel/CmdletCommandModel.cs
@@ -77,7 +77,11 @@ public CommandModelErrorCode Run(ConfigurationDictionary commandConfiguration, s
                         binderAndCommand.Invoke();
                     }
 
-                    if (runtimeHost.NonTerminatingErrorReported)
+                    if (runtimeHost.TerminatingErrorReported)
+                    {
+                        return CommandModelErrorCode.TerminatingError;
+                    }
+                    else if (runtimeHost.NonTerminatingErrorReported)
                     {
                         return CommandModelErrorCode.NonTerminatingError;
                     }
diff --git a/src/CLU/Microsoft.CLU/System.Management.Automation/CLUHost.cs b/src/CLU/Microsoft.CLU/System.Management.Automation/CLUHost.cs
@@ -315,6 +315,7 @@ public bool ShouldProcess(string verboseDescription, string verboseWarning, stri
         /// <param name="errorRecord">An ErrorRecord object that describes the error condition</param>
         public void ThrowTerminatingError(ErrorRecord errorRecord)
         {
+            TerminatingErrorReported = true;
             throw new CmdletTerminateException(errorRecord);
         }
 
@@ -468,7 +469,10 @@ private void WriteExceptionLine(Exception exc)
         /// </summary>
         internal bool NonTerminatingErrorReported { get; private set; }
 
-
+        /// <summary>
+        /// At least one terminating error has been reported...
+        /// </summary>
+        internal bool TerminatingErrorReported { get; private set;  }
 
         private string InterpretStreamPreference(string variable, string input, string current)
         {

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-namespace Microsoft.CLU.Common`
	`1`	`+namespace Microsoft.CLU`
`2`	`2`	`{`
`3`	`3`	`public enum CommandModelErrorCode`
`4`	`4`	`{`
Original file line number	Diff line number	Diff line change
`@@ -27,12 +27,12 @@ public bool CanHandle(string[] arguments)`
`27`	`27`	`/// IRunMode implementation for executing command.`
`28`	`28`	`/// </summary>`
`29`	`29`	`/// <param name="arguments">The arguments</param>`
`30`		`- public Microsoft.CLU.Common.CommandModelErrorCode Run(string[] arguments)`
	`30`	`+ public Microsoft.CLU.CommandModelErrorCode Run(string[] arguments)`
`31`	`31`	`{`
`32`	`32`	`if (arguments.Length < 2)`
`33`	`33`	`{`
`34`	`34`	`CLUEnvironment.Console.WriteErrorLine(Strings.CommandExecMode_Run_MissingCommandConfigFileArgument);`
`35`		`- return Microsoft.CLU.Common.CommandModelErrorCode.MissingParameters;`
	`35`	`+ return Microsoft.CLU.CommandModelErrorCode.MissingParameters;`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`try`
`@@ -52,7 +52,7 @@ public Microsoft.CLU.Common.CommandModelErrorCode Run(string[] arguments)`
`52`	`52`	`arguments[argsBase + 1].StartsWith("-", StringComparison.Ordinal))`
`53`	`53`	`{`
`54`	`54`	`CLUEnvironment.Console.WriteErrorLine(Strings.CommandExecMode_Run_MissingScriptName);`
`55`		`- return Microsoft.CLU.Common.CommandModelErrorCode.MissingParameters;`
	`55`	`+ return Microsoft.CLU.CommandModelErrorCode.MissingParameters;`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`CLUEnvironment.ScriptName = arguments[argsBase + 1];`
`@@ -65,7 +65,7 @@ public Microsoft.CLU.Common.CommandModelErrorCode Run(string[] arguments)`
`65`	`65`	`arguments[argsBase + 1].StartsWith("-", StringComparison.Ordinal))`
`66`	`66`	`{`
`67`	`67`	`CLUEnvironment.Console.WriteErrorLine(Strings.CommandExecMode_Run_MissingScriptConfigFileName);`
`68`		`- return Microsoft.CLU.Common.CommandModelErrorCode.MissingParameters;`
	`68`	`+ return Microsoft.CLU.CommandModelErrorCode.MissingParameters;`
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`commandConfiguration = CommandConfig.Load(arguments[argsBase + 1]);`
`@@ -90,7 +90,7 @@ public Microsoft.CLU.Common.CommandModelErrorCode Run(string[] arguments)`
`90`	`90`	`CLUEnvironment.Console.WriteDebugLine($"{exc.GetType().FullName}\n{exc.StackTrace}");`
`91`	`91`	`}`
`92`	`92`
`93`		`- return Common.CommandModelErrorCode.InternalFailure;`
	`93`	`+ return CommandModelErrorCode.InternalFailure;`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`#endregion`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ internal class CommandModel`
`19`	`19`	`/// </summary>`
`20`	`20`	`/// <param name="commandConfiguration"></param>`
`21`	`21`	`/// <param name="modelArguments"></param>`
`22`		`- public static Microsoft.CLU.Common.CommandModelErrorCode Run(CommandConfig commandConfiguration, string[] modelArguments)`
	`22`	`+ public static Microsoft.CLU.CommandModelErrorCode Run(CommandConfig commandConfiguration, string[] modelArguments)`
`23`	`23`	`{`
`24`	`24`	`CommandModel commandModel = new CommandModel()`
`25`	`25`	`{`
Original file line number	Diff line number	Diff line change
`@@ -17,6 +17,6 @@ internal interface IRunMode`
`17`	`17`	`/// IRunMode implementation.`
`18`	`18`	`/// </summary>`
`19`	`19`	`/// <param name="arguments">The arguments</param>`
`20`		`- Microsoft.CLU.Common.CommandModelErrorCode Run(string[] arguments);`
	`20`	`+ Microsoft.CLU.CommandModelErrorCode Run(string[] arguments);`
`21`	`21`	`}`
`22`	`22`	`}`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ public bool CanHandle(string[] arguments)`
`33`	`33`	`/// IRunMode implementation for package managment.`
`34`	`34`	`/// </summary>`
`35`	`35`	`/// <param name="arguments">The arguments</param>`
`36`		`- public Microsoft.CLU.Common.CommandModelErrorCode Run(string[] arguments)`
	`36`	`+ public Microsoft.CLU.CommandModelErrorCode Run(string[] arguments)`
`37`	`37`	`{`
`38`	`38`	`_packagesRootPath = CLUEnvironment.GetPackagesRootPath();`
`39`	`39`	`try`
`@@ -44,13 +44,13 @@ public Microsoft.CLU.Common.CommandModelErrorCode Run(string[] arguments)`
`44`	`44`	`{`
`45`	`45`	`CLUEnvironment.Console.WriteErrorLine(tie.InnerException.Message);`
`46`	`46`	`CLUEnvironment.Console.WriteDebugLine($"{tie.InnerException.GetType().FullName}\n{tie.InnerException.StackTrace}");`
`47`		`- return Microsoft.CLU.Common.CommandModelErrorCode.InternalFailure;`
	`47`	`+ return Microsoft.CLU.CommandModelErrorCode.InternalFailure;`
`48`	`48`	`}`
`49`	`49`	`catch (Exception exc)`
`50`	`50`	`{`
`51`	`51`	`CLUEnvironment.Console.WriteErrorLine(exc.Message);`
`52`	`52`	`CLUEnvironment.Console.WriteDebugLine($"{exc.GetType().FullName}\n{exc.StackTrace}");`
`53`		`- return Microsoft.CLU.Common.CommandModelErrorCode.InternalFailure;`
	`53`	`+ return Microsoft.CLU.CommandModelErrorCode.InternalFailure;`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`try`
`@@ -77,7 +77,7 @@ public Microsoft.CLU.Common.CommandModelErrorCode Run(string[] arguments)`
`77`	`77`	`arguments[argsBase + 1].StartsWith("-", StringComparison.Ordinal))`
`78`	`78`	`{`
`79`	`79`	`CLUEnvironment.Console.WriteLine(Strings.PackageManagementMode_Run_VersionIdMissing);`
`80`		`- return Microsoft.CLU.Common.CommandModelErrorCode.MissingParameters;`
	`80`	`+ return Microsoft.CLU.CommandModelErrorCode.MissingParameters;`
`81`	`81`	`}`
`82`	`82`	`version = arguments[argsBase + 1];`
`83`	`83`	`argsBase += 2;`
`@@ -145,13 +145,13 @@ public Microsoft.CLU.Common.CommandModelErrorCode Run(string[] arguments)`
`145`	`145`	`{`
`146`	`146`	`CLUEnvironment.Console.WriteErrorLine(tie.InnerException.Message);`
`147`	`147`	`CLUEnvironment.Console.WriteDebugLine($"{tie.InnerException.GetType().FullName}\n{tie.InnerException.StackTrace}");`
`148`		`- return Microsoft.CLU.Common.CommandModelErrorCode.InternalFailure;`
	`148`	`+ return Microsoft.CLU.CommandModelErrorCode.InternalFailure;`
`149`	`149`	`}`
`150`	`150`	`catch (Exception exc)`
`151`	`151`	`{`
`152`	`152`	`CLUEnvironment.Console.WriteErrorLine(exc.Message);`
`153`	`153`	`CLUEnvironment.Console.WriteDebugLine($"{exc.GetType().FullName}\n{exc.StackTrace}");`
`154`		`- return Microsoft.CLU.Common.CommandModelErrorCode.InternalFailure;`
	`154`	`+ return Microsoft.CLU.CommandModelErrorCode.InternalFailure;`
`155`	`155`	`}`
`156`	`156`
`157`	`157`	`return CommandModelErrorCode.Success;`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ public static void Main(string[] args) { }`
`17`	`17`	`/// Microsoft.CLU.Run (clurun.exe) main entry point.`
`18`	`18`	`/// </summary>`
`19`	`19`	`/// <param name="args">The commandline arguments</param>`
`20`		`- public static Microsoft.CLU.Common.CommandModelErrorCode Execute(string[] args)`
	`20`	`+ public static Microsoft.CLU.CommandModelErrorCode Execute(string[] args)`
`21`	`21`	`{`
`22`	`22`	`CLUEnvironment.Console = new ConsoleInputOutput(args);`
`23`	`23`
`@@ -36,20 +36,20 @@ public static Microsoft.CLU.Common.CommandModelErrorCode Execute(string[] args)`
`36`	`36`	`{`
`37`	`37`	`CLUEnvironment.Console.WriteErrorLine(exc.Message);`
`38`	`38`	`CLUEnvironment.Console.WriteDebugLine(exc.StackTrace);`
`39`		`- return Microsoft.CLU.Common.CommandModelErrorCode.InternalFailure;`
	`39`	`+ return Microsoft.CLU.CommandModelErrorCode.InternalFailure;`
`40`	`40`	`}`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`/// <summary>`
`44`	`44`	`/// Parse the commandline argument and bootstrap the command execution.`
`45`	`45`	`/// </summary>`
`46`	`46`	`/// <param name="arguments">The commandline arguments</param>`
`47`		`- private Microsoft.CLU.Common.CommandModelErrorCode Parse(string [] arguments)`
	`47`	`+ private Microsoft.CLU.CommandModelErrorCode Parse(string [] arguments)`
`48`	`48`	`{`
`49`	`49`	`if (arguments.Count() == 0)`
`50`	`50`	`{`
`51`	`51`	`DisplayHelp();`
`52`		`- return Common.CommandModelErrorCode.MissingParameters;`
	`52`	`+ return CommandModelErrorCode.MissingParameters;`
`53`	`53`	`}`
`54`	`54`
`55`	`55`	`var mode = GetMode(arguments);`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@`
`5`	`5`
`6`	`6`	`using System.Management.Automation;`
`7`	`7`
`8`		`-namespace Microsoft.Azure.Commands.Resources.Test`
	`8`	`+namespace Microsoft.CLU.Test`
`9`	`9`	`{`
`10`	`10`
`11`	`11`	`public class TestRecord`
Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,11 @@ public CommandModelErrorCode Run(ConfigurationDictionary commandConfiguration, s`
`77`	`77`	`binderAndCommand.Invoke();`
`78`	`78`	`}`
`79`	`79`
`80`		`- if (runtimeHost.NonTerminatingErrorReported)`
	`80`	`+ if (runtimeHost.TerminatingErrorReported)`
	`81`	`+ {`
	`82`	`+ return CommandModelErrorCode.TerminatingError;`
	`83`	`+ }`
	`84`	`+ else if (runtimeHost.NonTerminatingErrorReported)`
`81`	`85`	`{`
`82`	`86`	`return CommandModelErrorCode.NonTerminatingError;`
`83`	`87`	`}`
Original file line number	Diff line number	Diff line change
`@@ -315,6 +315,7 @@ public bool ShouldProcess(string verboseDescription, string verboseWarning, stri`
`315`	`315`	`/// <param name="errorRecord">An ErrorRecord object that describes the error condition</param>`
`316`	`316`	`public void ThrowTerminatingError(ErrorRecord errorRecord)`
`317`	`317`	`{`
	`318`	`+ TerminatingErrorReported = true;`
`318`	`319`	`throw new CmdletTerminateException(errorRecord);`
`319`	`320`	`}`
`320`	`321`
`@@ -468,7 +469,10 @@ private void WriteExceptionLine(Exception exc)`
`468`	`469`	`/// </summary>`
`469`	`470`	`internal bool NonTerminatingErrorReported { get; private set; }`
`470`	`471`
`471`		`-`
	`472`	`+ /// <summary>`
	`473`	`+ /// At least one terminating error has been reported...`
	`474`	`+ /// </summary>`
	`475`	`+ internal bool TerminatingErrorReported { get; private set; }`
`472`	`476`
`473`	`477`	`private string InterpretStreamPreference(string variable, string input, string current)`
`474`	`478`	`{`