Fix another subtile bug in my Interpreter

add some more basic tests and add some more debug helpers.
All in preparation to add the option to tryrun my stuff in CoreConsole

Author: LoneWandererProductions

CoreConsole/ConResources.cs

@@ -34,7 +34,7 @@ internal static class ConResources
         /// <summary>
         ///     The resxtract overload
         /// </summary>
-        internal const int ResxtractOverload = 2;
+        internal const int ResXtractOverload = 2;
 
         /// <summary>
         ///     The analyzer
@@ -65,7 +65,7 @@ internal static class ConResources
                 }
             },
             {
-                ResxtractOverload, new InCommand
+                ResXtractOverload, new InCommand
                 {
                     Command = "resxtract",
                     ParameterCount = 1,

CoreConsole/Program.cs

@@ -188,7 +188,7 @@ private static void HandleCommands(OutCommand outCommand)
                     result = HandleResxtract(outCommand);
                     _prompt.Callback(result);
                     break;
-                case ConResources.ResxtractOverload:
+                case ConResources.ResXtractOverload:
                     result = HandleResxtract(outCommand);
                     _prompt.Callback(result);
                     break;

CoreLibrary.sln.DotSettings.user

@@ -12,6 +12,7 @@
       <TestId>MSTest::D2D1B7B6-0C94-45F8-BD4E-1FB9A318AC21::net5.0-windows7.0::CommonLibraryTests.MemoryVaultTests.GetData_ShouldReturnDefaultWhenExpired</TestId>
       <TestId>MSTest::D2D1B7B6-0C94-45F8-BD4E-1FB9A318AC21::net5.0-windows7.0::CommonLibraryTests.MemoryVaultTests.AddMetadata_ShouldStoreMetadataCorrectly</TestId>
       <TestId>MSTest::B5D5FFD4-0B21-4C0B-9B77-2E6DE5D3FFAF::net5.0::CommonLibrarySqlLiteTests.SqlLiteInternals.TestCreateDatabaseBigInternals</TestId>
+      <TestId>MSTest::18981E7D-2AB9-48B2-8181-9E9DF3263B23::net5.0-windows7.0::InterpreteTests.InterpreterCompleteTests.ConsoleInterpreterShouldHandleNamespaceSwitchFullTest</TestId>
     </TestAncestor>
     <Project Location="C:\Users\Wayfarer\Documents\Projects\CoreLibrary\CommonLibraryGuiTests" Presentation="<CommonLibraryGuiTests>" />
     <Project Location="C:\Users\Wayfarer\Documents\Projects\CoreLibrary\CommonLibraryTests" Presentation="<CommonLibraryTests>" />


InterpreteTests/CommandBuilder.cs

@@ -2,7 +2,7 @@
  * COPYRIGHT:   See COPYING in the top level directory
  * PROJECT:     InterpreteTests
  * FILE:        CommandBuilder.cs
- * PURPOSE:     Your file purpose here
+ * PURPOSE:     Some full command tests mosttly for the scripting part and if else
  * PROGRAMMER:  Peter Geinitz (Wayfarer)
  */
 

InterpreteTests/FeedbackTests.cs

@@ -117,25 +117,37 @@ public void FeedbackExtensionExternal()
             {
                 { 0, new InCommand { Command = "com1", ParameterCount = 2, Description = "Help com1" } },
                 {
-                    1,
-                    new InCommand { Command = "com2", ParameterCount = 0, Description = "com2 Command Namespace 1" }
+                    1, new InCommand { Command = "com2", ParameterCount = 0, Description = "com2 Command Namespace 1" }
                 },
                 {
-                    2,
-                    new InCommand
+                    2, new InCommand
                     {
                         Command = "com3", ParameterCount = 0, Description = "Special case no Parameter"
                     }
                 }
             };
 
+            Dictionary<int, InCommand> extensionCommands = new()
+            {
+                {
+                    0, new InCommand
+                    {
+                        Command = "dryrun",
+                        ParameterCount = 0,
+                        FeedbackId = 1,
+                        Description =
+                            "Show results and optional run commands"
+                    }
+                }
+            };
+
             // Act
             var prompt = new Prompt();
             prompt.SendLogs += SendLogs;
             prompt.SendCommands += SendCommands;
-            //prompt.Initiate(dctCommandOne, "UserSpace 1", extension: Feedback);
-            //prompt.ConsoleInput("coM1(1,2).Help()");
-            //prompt.ConsoleInput("");
+            prompt.Initiate(dctCommandOne, "UserSpace 1", extension: extensionCommands, Feedback);
+            prompt.ConsoleInput("coM1(1,2).Dryrun()");
+            prompt.ConsoleInput("");
 
 
             //Assert.IsFalse(_log.Contains("Help com1"), "No help provided.");

InterpreteTests/IrtParserInputTests.cs

@@ -0,0 +1,220 @@
+/*
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     InterpreteTests
+ * FILE:        IrtParserInputTests.cs
+ * PURPOSE:     Here we test the Parser part of my Script Engine
+ * PROGRAMMER:  Peter Geinitz (Wayfarer)
+ */
+
+
+using System.Collections.Generic;
+using Interpreter;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace InterpreteTests
+{
+    /// <summary>
+    /// IrtParserInput Test Class
+    /// </summary>
+    [TestClass]
+    public class IrtParserInputTests
+    {
+        /// <summary>
+        /// The parser input
+        /// </summary>
+        private IrtParserInput _parserInput;
+
+        /// <summary>
+        /// The prompt
+        /// </summary>
+        private Prompt _prompt;
+
+        /// <summary>
+        /// Setups this instance.
+        /// </summary>
+        [TestInitialize]
+        public void Setup()
+        {
+            _prompt = new Prompt();
+            _parserInput = new IrtParserInput(_prompt);
+
+            var commandDict = new Dictionary<int, InCommand>
+            {
+                { 0, new InCommand { Command = "com1", ParameterCount = 0 } },
+                { 1, new InCommand { Command = "help", ParameterCount = 0 } }
+            };
+
+            IrtParserInput.SwitchUserSpace(new UserSpace
+            {
+                Commands = commandDict,
+                UserSpaceName = "TestSpace"
+            });
+        }
+
+        /// <summary>
+        /// Switches the user space changes user space.
+        /// </summary>
+        [TestMethod]
+        public void SwitchUserSpaceChangesUserSpace()
+        {
+            var newCommands = new Dictionary<int, InCommand>
+            {
+                { 5, new InCommand { Command = "newcmd", ParameterCount = 0 } }
+            };
+
+            var newSpace = new UserSpace
+            {
+                UserSpaceName = "NewSpace",
+                Commands = newCommands
+            };
+
+            IrtParserInput.SwitchUserSpace(newSpace);
+
+            var result = _parserInput.ProcessInput("newcmd()");
+            Assert.IsNotNull(result);
+            Assert.AreEqual(5, result.Command);
+            Assert.AreEqual("NewSpace", result.UsedNameSpace);
+        }
+
+        [TestMethod]
+        public void ProcessInputReturnsOutCommandForValidCommandWithParameters()
+        {
+            // Arrange
+            var commandDict = new Dictionary<int, InCommand>
+            {
+                { 0, new InCommand { Command = "com1", ParameterCount = 2, Description = "Help com1" } }
+            };
+
+            IrtParserInput.SwitchUserSpace(new UserSpace
+            {
+                Commands = commandDict,
+                UserSpaceName = "DefaultSpace"
+            });
+
+            var input = "com1(1,2)";
+
+            // Act
+            var result = _parserInput.ProcessInput(input);
+
+            // Assert
+            Assert.IsNotNull(result);
+            Assert.AreEqual(0, result.Command);
+            CollectionAssert.AreEqual(new List<string> { "1", "2" }, result.Parameter);
+            Assert.AreEqual("DefaultSpace", result.UsedNameSpace);
+        }
+
+        /// <summary>
+        /// Processes the input returns null for unknown command.
+        /// </summary>
+        [TestMethod]
+        public void ProcessInputReturnsNullForUnknownCommand()
+        {
+            // Arrange
+            var commandDict = new Dictionary<int, InCommand>
+            {
+                { 0, new InCommand { Command = "com1", ParameterCount = 2 } }
+            };
+
+            IrtParserInput.SwitchUserSpace(new UserSpace
+            {
+                Commands = commandDict,
+                UserSpaceName = "DefaultSpace"
+            });
+
+            var input = "unknown(1,2)";
+
+            // Act
+            var result = _parserInput.ProcessInput(input);
+
+            // Assert
+            Assert.IsNull(result);
+        }
+
+        /// <summary>
+        /// Processes the input returns null for wrong parameter count.
+        /// </summary>
+        [TestMethod]
+        public void ProcessInputReturnsNullForWrongParameterCount()
+        {
+            // Arrange
+            var commandDict = new Dictionary<int, InCommand>
+            {
+                { 0, new InCommand { Command = "com1", ParameterCount = 2 } }
+            };
+
+            IrtParserInput.SwitchUserSpace(new UserSpace
+            {
+                Commands = commandDict,
+                UserSpaceName = "DefaultSpace"
+            });
+
+            var input = "com1(1)"; // only 1 parameter, should be 2
+
+            // Act
+            var result = _parserInput.ProcessInput(input);
+
+            // Assert
+            Assert.IsNull(result); // error is set inside parser
+        }
+
+        /// <summary>
+        /// Processes the input handles single parameter command.
+        /// </summary>
+        [TestMethod]
+        public void ProcessInputHandlesSingleParameterCommand()
+        {
+            // Arrange
+            var commandDict = new Dictionary<int, InCommand>
+            {
+                { 1, new InCommand { Command = "com2", ParameterCount = 1 } }
+            };
+
+            IrtParserInput.SwitchUserSpace(new UserSpace
+            {
+                Commands = commandDict,
+                UserSpaceName = "Space2"
+            });
+
+            var input = "com2(123)";
+
+            // Act
+            var result = _parserInput.ProcessInput(input);
+
+            // Assert
+            Assert.IsNotNull(result);
+            Assert.AreEqual(1, result.Command);
+            CollectionAssert.AreEqual(new List<string> { "123" }, result.Parameter);
+        }
+
+        /// <summary>
+        /// Handles the input help command works.
+        /// </summary>
+        [TestMethod]
+        public void HandleInputHelpCommandWorks()
+        {
+            _parserInput.HandleInput("help()");
+            Assert.IsTrue(true); // Should process help logic safely
+        }
+
+        /// <summary>
+        /// Handles the input empty line handled gracefully.
+        /// </summary>
+        [TestMethod]
+        public void HandleInputEmptyLineHandledGracefully()
+        {
+            _parserInput.HandleInput("");
+            Assert.IsTrue(true); // Should not throw
+        }
+
+        /// <summary>
+        /// Disposes the can be called multiple times safely.
+        /// </summary>
+        [TestMethod]
+        public void DisposeCanBeCalledMultipleTimesSafely()
+        {
+            _parserInput.Dispose();
+            _parserInput.Dispose(); // Should be idempotent
+            Assert.IsTrue(true);
+        }
+    }
+}

Interpreter/ExtensionCommands.cs

@@ -34,6 +34,7 @@ public sealed class ExtensionCommands
         ///     Gets or sets the parameter.
         /// </summary>
         public List<string> ExtensionParameter { get; internal set; }
+
         /// <summary>
         /// Gets the feedback identifier.
         /// Define the feedback id

Interpreter/InCommand.cs

@@ -9,12 +9,14 @@
 // ReSharper disable MemberCanBeInternal
 
 using System;
+using System.Diagnostics;
 
 namespace Interpreter
 {
     /// <summary>
     ///     Simple Element of the Register
     /// </summary>
+    [DebuggerDisplay("{ToString()}")]
     public sealed class InCommand
     {
         /// <summary>

Interpreter/IrtFeedback.cs

@@ -6,11 +6,14 @@
  * PROGRAMER:   Peter Geinitz (Wayfarer)
  */
 
+using System.Diagnostics;
+
 namespace Interpreter
 {
     /// <summary>
     ///     Control Object that checks if User Feedback is needed
     /// </summary>
+    [DebuggerDisplay("{ToString()}")]
     internal sealed class IrtFeedback
     {
         /// <summary>
@@ -78,5 +81,13 @@ internal IrtFeedbackInputEventArgs GenerateFeedbackAnswer(AvailableFeedback answ
                 Answer = answer
             };
         }
+
+        /// <summary>
+        ///     Returns a string representation of this feedback.
+        /// </summary>
+        public override string ToString()
+        {
+            return $"[Feedback: Cmd={Command}, Key={Key}, ReqId={RequestId}, Branch={BranchId}, Output={AwaitedOutput}]";
+        }
     }
 }

Interpreter/IrtParserInput.cs

@@ -212,6 +212,7 @@ internal void HandleInput(string inputString)
                     }
                     else
                     {
+                        //TODO result is wrong.
                         var command = ProcessInput(inputString, extensionResult.Extension);
                         SetResult(command);
                     }
@@ -236,6 +237,12 @@ internal void HandleInput(string inputString)
         /// <param name="extension">Optional extension commands</param>
         internal OutCommand? ProcessInput(string inputString, ExtensionCommands? extension = null)
         {
+            if (extension != null)
+            {
+                //remove the extension string, and handle only the base command.
+                inputString = extension.BaseCommand;
+            }
+
             var key = IrtKernel.CheckForKeyWord(inputString, IrtConst.InternCommands);
             if (key != IrtConst.Error)
             {
@@ -330,7 +337,7 @@ private void SetErrorWithLog(string errorMessage, string additionalInfo = "")
         /// <param name="command">The command.</param>
         private void SetResult(OutCommand command)
         {
-            if (_com[command.Command].FeedbackId == 0)
+            if (_com[command.Command]?.FeedbackId == 0)
             {
                 _prompt.SendCommand(this, command);
             }