Split code from SabreTools

SabreTools.CommandLine.Test/CommandSetTests.cs

@@ -0,0 +1,72 @@
+using SabreTools.CommandLine.Inputs;
+using Xunit;
+
+namespace SabreTools.CommandLine.Test
+{
+    public class CommandSetTests
+    {
+        [Fact]
+        public void AddAndRetrieveTest()
+        {
+            var input1 = new FlagInput("input1", "--input1", "input1");
+            var input2 = new FlagInput("input2", "--input2", "input2");
+
+            var featureSet = new CommandSet();
+            featureSet.Add(input1);
+            featureSet.Add(input2);
+
+            var actualInput1 = featureSet["input1"];
+            Assert.NotNull(actualInput1);
+            Assert.Equal("input1", actualInput1.Name);
+
+            var actualInput2 = featureSet[input2];
+            Assert.NotNull(actualInput2);
+            Assert.Equal("input2", actualInput2.Name);
+
+            var actualInput3 = featureSet["input3"];
+            Assert.Null(actualInput3);
+        }
+
+        [Fact]
+        public void GetInputNameTest()
+        {
+            var input1 = new FlagInput("input1", "--input1", "input1");
+            var input2 = new FlagInput("input2", "--input2", "input2");
+
+            var featureSet = new CommandSet();
+            featureSet.Add(input1);
+            featureSet.Add(input2);
+
+            var actualName1 = featureSet.GetInputName("input1");
+            Assert.NotEmpty(actualName1);
+            Assert.Equal("input1", actualName1);
+
+            var actualName2 = featureSet.GetInputName("--input2");
+            Assert.NotEmpty(actualName2);
+            Assert.Equal("input2", actualName2);
+
+            var actualName3 = featureSet.GetInputName("input3");
+            Assert.Empty(actualName3);
+        }
+
+        [Fact]
+        public void TopLevelFlagTest()
+        {
+            var input1 = new FlagInput("input1", "--input1", "input1");
+            var input2 = new FlagInput("input2", "--input2", "input2");
+
+            var featureSet = new CommandSet();
+            featureSet.Add(input1);
+            featureSet.Add(input2);
+
+            bool actualTop1 = featureSet.TopLevelFlag("input1");
+            Assert.True(actualTop1);
+
+            bool actualTop2 = featureSet.TopLevelFlag("--input2");
+            Assert.True(actualTop2);
+
+            bool actualTop3 = featureSet.TopLevelFlag("input3");
+            Assert.False(actualTop3);
+        }
+    }
+}

SabreTools.CommandLine.Test/FeatureTests.cs

@@ -0,0 +1,115 @@
+using Xunit;
+
+namespace SabreTools.CommandLine.Test
+{
+    public class FeatureTests
+    {
+        [Fact]
+        public void ProcessArgs_EmptyArgs_Success()
+        {
+            Feature feature = new MockFeature("", "", "");
+
+            string[] args = [];
+            int index = 0;
+
+            bool actual = feature.ProcessArgs(args, index);
+            Assert.True(actual);
+            Assert.Empty(feature.Inputs);
+        }
+
+        [Fact]
+        public void ProcessArgs_NegativeIndex_Failure()
+        {
+            Feature feature = new MockFeature("", "", "");
+
+            string[] args = ["a", "b", "c"];
+            int index = -1;
+
+            bool actual = feature.ProcessArgs(args, index);
+            Assert.False(actual);
+            Assert.Empty(feature.Inputs);
+        }
+
+        [Fact]
+        public void ProcessArgs_OverIndex_Failure()
+        {
+            Feature feature = new MockFeature("", "", "");
+
+            string[] args = ["a", "b", "c"];
+            int index = 3;
+
+            bool actual = feature.ProcessArgs(args, index);
+            Assert.False(actual);
+            Assert.Empty(feature.Inputs);
+        }
+
+        [Fact]
+        public void ProcessArgs_ValidArgs_Success()
+        {
+            Feature feature = new MockFeature("a", "a", "a");
+            feature.Add(new MockFeature("b", "b", "b"));
+            feature.Add(new MockFeature("c", "c", "c"));
+
+            string[] args = ["a", "b", "c"];
+            int index = 0;
+
+            bool actual = feature.ProcessArgs(args, index);
+            Assert.True(actual);
+            Assert.Empty(feature.Inputs);
+        }
+
+        [Fact]
+        public void ProcessArgs_InvalidArg_AddedAsGeneric()
+        {
+            Feature feature = new MockFeature("a", "a", "a");
+            feature.Add(new MockFeature("b", "b", "b"));
+            feature.Add(new MockFeature("d", "d", "d"));
+
+            string[] args = ["a", "b", "c"];
+            int index = 0;
+
+            bool actual = feature.ProcessArgs(args, index);
+            Assert.True(actual);
+            string input = Assert.Single(feature.Inputs);
+            Assert.Equal("c", input);
+        }
+
+        [Fact]
+        public void ProcessArgs_NestedArgs_Success()
+        {
+            Feature feature = new MockFeature("a", "a", "a");
+            var sub = new MockFeature("b", "b", "b");
+            sub.Add(new MockFeature("c", "c", "c"));
+            feature.Add(sub);
+
+            string[] args = ["a", "b", "c"];
+            int index = 0;
+
+            bool actual = feature.ProcessArgs(args, index);
+            Assert.True(actual);
+            Assert.Empty(feature.Inputs);
+        }
+
+        /// <summary>
+        /// Mock Feature implementation for testing
+        /// </summary>
+        private class MockFeature : Feature
+        {
+            public MockFeature(string name, string flag, string description, string? longDescription = null)
+                : base(name, flag, description, longDescription)
+            {
+            }
+
+            public MockFeature(string name, string[] flags, string description, string? longDescription = null)
+                : base(name, flags, description, longDescription)
+            {
+            }
+
+            /// <inheritdoc/>
+            public override bool VerifyInputs() => true;
+
+            /// <inheritdoc/>
+            public override bool Execute() => true;
+        }
+    }
+}

SabreTools.CommandLine.Test/Inputs/BooleanInputTests.cs

@@ -0,0 +1,134 @@
+using SabreTools.CommandLine.Inputs;
+using Xunit;
+
+namespace SabreTools.CommandLine.Test.Inputs
+{
+    public class BooleanInputTests
+    {
+        [Fact]
+        public void ProcessInput_EmptyArgs_Failure()
+        {
+            string[] args = [];
+            int index = 0;
+
+            var input = new BooleanInput("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_NegativeIndex_Failure()
+        {
+            string[] args = ["a", "true"];
+            int index = -1;
+
+            var input = new BooleanInput("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(-1, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_OverIndex_Failure()
+        {
+            string[] args = ["a", "true"];
+            int index = 2;
+
+            var input = new BooleanInput("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(2, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Space_InvalidLength_Failure()
+        {
+            string[] args = ["a"];
+            int index = 0;
+
+            var input = new BooleanInput("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Space_InvalidValue_Failure()
+        {
+            string[] args = ["a", "ANY"];
+            int index = 0;
+
+            var input = new BooleanInput("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Space_ValidValue_Success()
+        {
+            string[] args = ["a", "true"];
+            int index = 0;
+
+            var input = new BooleanInput("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.True(actual);
+            Assert.Equal(1, index);
+            Assert.True(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Equal_InvalidLength_Failure()
+        {
+            string[] args = ["a="];
+            int index = 0;
+
+            var input = new BooleanInput("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Equal_InvalidValue_Failure()
+        {
+            string[] args = ["a=ANY"];
+            int index = 0;
+
+            var input = new BooleanInput("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Equal_ValidValue_Success()
+        {
+            string[] args = ["a=true"];
+            int index = 0;
+
+            var input = new BooleanInput("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.True(actual);
+            Assert.Equal(0, index);
+            Assert.True(input.Value);
+        }
+    }
+}

SabreTools.CommandLine.Test/Inputs/FlagInputTests.cs

@@ -0,0 +1,64 @@
+using SabreTools.CommandLine.Inputs;
+using Xunit;
+
+namespace SabreTools.CommandLine.Test.Inputs
+{
+    public class FlagInputTests
+    {
+        [Fact]
+        public void ProcessInput_EmptyArgs_Failure()
+        {
+            string[] args = [];
+            int index = 0;
+
+            var input = new FlagInput("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.False(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_NegativeIndex_Failure()
+        {
+            string[] args = ["a", "true"];
+            int index = -1;
+
+            var input = new FlagInput("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(-1, index);
+            Assert.False(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_OverIndex_Failure()
+        {
+            string[] args = ["a", "true"];
+            int index = 2;
+
+            var input = new FlagInput("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(2, index);
+            Assert.False(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_ValidValue_Success()
+        {
+            string[] args = ["a"];
+            int index = 0;
+
+            var input = new FlagInput("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.True(actual);
+            Assert.Equal(0, index);
+            Assert.True(input.Value);
+        }
+    }
+}

SabreTools.CommandLine.Test/Inputs/Int16InputTests.cs

@@ -0,0 +1,136 @@
+using SabreTools.CommandLine.Inputs;
+using Xunit;
+
+namespace SabreTools.CommandLine.Test.Inputs
+{
+    public class Int16InputTests
+    {
+        [Fact]
+        public void ProcessInput_EmptyArgs_Failure()
+        {
+            string[] args = [];
+            int index = 0;
+
+            var input = new Int16Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_NegativeIndex_Failure()
+        {
+            string[] args = ["a", "5"];
+            int index = -1;
+
+            var input = new Int16Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(-1, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_OverIndex_Failure()
+        {
+            string[] args = ["a", "5"];
+            int index = 2;
+
+            var input = new Int16Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(2, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Space_InvalidLength_Failure()
+        {
+            string[] args = ["a"];
+            int index = 0;
+
+            var input = new Int16Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Space_InvalidValue_Failure()
+        {
+            string[] args = ["a", "ANY"];
+            int index = 0;
+
+            var input = new Int16Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Space_ValidValue_Success()
+        {
+            string[] args = ["a", "5"];
+            int index = 0;
+
+            var input = new Int16Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.True(actual);
+            Assert.Equal(1, index);
+            short value = Assert.NotNull(input.Value);
+            Assert.Equal(5, value);
+        }
+
+        [Fact]
+        public void ProcessInput_Equal_InvalidLength_Failure()
+        {
+            string[] args = ["a="];
+            int index = 0;
+
+            var input = new Int16Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Equal_InvalidValue_Failure()
+        {
+            string[] args = ["a=ANY"];
+            int index = 0;
+
+            var input = new Int16Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Equal_ValidValue_Success()
+        {
+            string[] args = ["a=5"];
+            int index = 0;
+
+            var input = new Int16Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.True(actual);
+            Assert.Equal(0, index);
+            short value = Assert.NotNull(input.Value);
+            Assert.Equal(5, value);
+        }
+    }
+}

SabreTools.CommandLine.Test/Inputs/Int32InputTests.cs

@@ -0,0 +1,136 @@
+using SabreTools.CommandLine.Inputs;
+using Xunit;
+
+namespace SabreTools.CommandLine.Test.Inputs
+{
+    public class Int32InputTests
+    {
+        [Fact]
+        public void ProcessInput_EmptyArgs_Failure()
+        {
+            string[] args = [];
+            int index = 0;
+
+            var input = new Int32Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_NegativeIndex_Failure()
+        {
+            string[] args = ["a", "5"];
+            int index = -1;
+
+            var input = new Int32Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(-1, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_OverIndex_Failure()
+        {
+            string[] args = ["a", "5"];
+            int index = 2;
+
+            var input = new Int32Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(2, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Space_InvalidLength_Failure()
+        {
+            string[] args = ["a"];
+            int index = 0;
+
+            var input = new Int32Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Space_InvalidValue_Failure()
+        {
+            string[] args = ["a", "ANY"];
+            int index = 0;
+
+            var input = new Int32Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Space_ValidValue_Success()
+        {
+            string[] args = ["a", "5"];
+            int index = 0;
+
+            var input = new Int32Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.True(actual);
+            Assert.Equal(1, index);
+            int value = Assert.NotNull(input.Value);
+            Assert.Equal(5, value);
+        }
+
+        [Fact]
+        public void ProcessInput_Equal_InvalidLength_Failure()
+        {
+            string[] args = ["a="];
+            int index = 0;
+
+            var input = new Int32Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Equal_InvalidValue_Failure()
+        {
+            string[] args = ["a=ANY"];
+            int index = 0;
+
+            var input = new Int32Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Equal_ValidValue_Success()
+        {
+            string[] args = ["a=5"];
+            int index = 0;
+
+            var input = new Int32Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.True(actual);
+            Assert.Equal(0, index);
+            int value = Assert.NotNull(input.Value);
+            Assert.Equal(5, value);
+        }
+    }
+}

SabreTools.CommandLine.Test/Inputs/Int64InputTests.cs

@@ -0,0 +1,136 @@
+using SabreTools.CommandLine.Inputs;
+using Xunit;
+
+namespace SabreTools.CommandLine.Test.Inputs
+{
+    public class Int64InputTests
+    {
+        [Fact]
+        public void ProcessInput_EmptyArgs_Failure()
+        {
+            string[] args = [];
+            int index = 0;
+
+            var input = new Int64Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_NegativeIndex_Failure()
+        {
+            string[] args = ["a", "5"];
+            int index = -1;
+
+            var input = new Int64Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(-1, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_OverIndex_Failure()
+        {
+            string[] args = ["a", "5"];
+            int index = 2;
+
+            var input = new Int64Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(2, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Space_InvalidLength_Failure()
+        {
+            string[] args = ["a"];
+            int index = 0;
+
+            var input = new Int64Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Space_InvalidValue_Failure()
+        {
+            string[] args = ["a", "ANY"];
+            int index = 0;
+
+            var input = new Int64Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Space_ValidValue_Success()
+        {
+            string[] args = ["a", "5"];
+            int index = 0;
+
+            var input = new Int64Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.True(actual);
+            Assert.Equal(1, index);
+            long value = Assert.NotNull(input.Value);
+            Assert.Equal(5, value);
+        }
+
+        [Fact]
+        public void ProcessInput_Equal_InvalidLength_Failure()
+        {
+            string[] args = ["a="];
+            int index = 0;
+
+            var input = new Int64Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Equal_InvalidValue_Failure()
+        {
+            string[] args = ["a=ANY"];
+            int index = 0;
+
+            var input = new Int64Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Equal_ValidValue_Success()
+        {
+            string[] args = ["a=5"];
+            int index = 0;
+
+            var input = new Int64Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.True(actual);
+            Assert.Equal(0, index);
+            long value = Assert.NotNull(input.Value);
+            Assert.Equal(5, value);
+        }
+    }
+}

SabreTools.CommandLine.Test/Inputs/Int8InputTests.cs

@@ -0,0 +1,136 @@
+using SabreTools.CommandLine.Inputs;
+using Xunit;
+
+namespace SabreTools.CommandLine.Test.Inputs
+{
+    public class Int8InputTests
+    {
+        [Fact]
+        public void ProcessInput_EmptyArgs_Failure()
+        {
+            string[] args = [];
+            int index = 0;
+
+            var input = new Int8Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_NegativeIndex_Failure()
+        {
+            string[] args = ["a", "5"];
+            int index = -1;
+
+            var input = new Int8Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(-1, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_OverIndex_Failure()
+        {
+            string[] args = ["a", "5"];
+            int index = 2;
+
+            var input = new Int8Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(2, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Space_InvalidLength_Failure()
+        {
+            string[] args = ["a"];
+            int index = 0;
+
+            var input = new Int8Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Space_InvalidValue_Failure()
+        {
+            string[] args = ["a", "ANY"];
+            int index = 0;
+
+            var input = new Int8Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Space_ValidValue_Success()
+        {
+            string[] args = ["a", "5"];
+            int index = 0;
+
+            var input = new Int8Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.True(actual);
+            Assert.Equal(1, index);
+            sbyte value = Assert.NotNull(input.Value);
+            Assert.Equal(5, value);
+        }
+
+        [Fact]
+        public void ProcessInput_Equal_InvalidLength_Failure()
+        {
+            string[] args = ["a="];
+            int index = 0;
+
+            var input = new Int8Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Equal_InvalidValue_Failure()
+        {
+            string[] args = ["a=ANY"];
+            int index = 0;
+
+            var input = new Int8Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Equal_ValidValue_Success()
+        {
+            string[] args = ["a=5"];
+            int index = 0;
+
+            var input = new Int8Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.True(actual);
+            Assert.Equal(0, index);
+            sbyte value = Assert.NotNull(input.Value);
+            Assert.Equal(5, value);
+        }
+    }
+}

SabreTools.CommandLine.Test/Inputs/StringInputTests.cs

@@ -0,0 +1,107 @@
+using SabreTools.CommandLine.Inputs;
+using Xunit;
+
+namespace SabreTools.CommandLine.Test.Inputs
+{
+    public class StringInputTests
+    {
+        [Fact]
+        public void ProcessInput_EmptyArgs_Failure()
+        {
+            string[] args = [];
+            int index = 0;
+
+            var input = new StringInput("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_NegativeIndex_Failure()
+        {
+            string[] args = ["a", "value"];
+            int index = -1;
+
+            var input = new StringInput("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(-1, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_OverIndex_Failure()
+        {
+            string[] args = ["a", "value"];
+            int index = 2;
+
+            var input = new StringInput("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(2, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Space_InvalidLength_Failure()
+        {
+            string[] args = ["a"];
+            int index = 0;
+
+            var input = new StringInput("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Space_ValidValue_Success()
+        {
+            string[] args = ["a", "value"];
+            int index = 0;
+
+            var input = new StringInput("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.True(actual);
+            Assert.Equal(1, index);
+            Assert.Equal("value", input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Equal_Empty_Success()
+        {
+            string[] args = ["a="];
+            int index = 0;
+
+            var input = new StringInput("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.True(actual);
+            Assert.Equal(0, index);
+            Assert.NotNull(input.Value);
+            Assert.Empty(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Equal_ValidValue_Success()
+        {
+            string[] args = ["a=value"];
+            int index = 0;
+
+            var input = new StringInput("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.True(actual);
+            Assert.Equal(0, index);
+            Assert.Equal("value", input.Value);
+        }
+    }
+}

SabreTools.CommandLine.Test/Inputs/StringListInputTests.cs

@@ -0,0 +1,112 @@
+using SabreTools.CommandLine.Inputs;
+using Xunit;
+
+namespace SabreTools.CommandLine.Test.Inputs
+{
+    public class StringListInputTests
+    {
+        [Fact]
+        public void ProcessInput_EmptyArgs_Failure()
+        {
+            string[] args = [];
+            int index = 0;
+
+            var input = new StringListInput("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_NegativeIndex_Failure()
+        {
+            string[] args = ["a", "true"];
+            int index = -1;
+
+            var input = new StringListInput("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(-1, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_OverIndex_Failure()
+        {
+            string[] args = ["a", "true"];
+            int index = 2;
+
+            var input = new StringListInput("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(2, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Space_InvalidLength_Failure()
+        {
+            string[] args = ["a"];
+            int index = 0;
+
+            var input = new StringListInput("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Space_ValidValue_Success()
+        {
+            string[] args = ["a", "value"];
+            int index = 0;
+
+            var input = new StringListInput("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.True(actual);
+            Assert.Equal(1, index);
+            Assert.NotNull(input.Value);
+            var value = Assert.Single(input.Value);
+            Assert.Equal("value", value);
+        }
+
+        [Fact]
+        public void ProcessInput_Equal_Empty_Success()
+        {
+            string[] args = ["a="];
+            int index = 0;
+
+            var input = new StringListInput("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.True(actual);
+            Assert.Equal(0, index);
+            Assert.NotNull(input.Value);
+            var value = Assert.Single(input.Value);
+            Assert.Empty(value);
+        }
+
+        [Fact]
+        public void ProcessInput_Equal_ValidValue_Success()
+        {
+            string[] args = ["a=value"];
+            int index = 0;
+
+            var input = new StringListInput("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.True(actual);
+            Assert.Equal(0, index);
+            Assert.NotNull(input.Value);
+            var value = Assert.Single(input.Value);
+            Assert.Equal("value", value);
+        }
+    }
+}

SabreTools.CommandLine.Test/Inputs/UInt16InputTests.cs

@@ -0,0 +1,136 @@
+using SabreTools.CommandLine.Inputs;
+using Xunit;
+
+namespace SabreTools.CommandLine.Test.Inputs
+{
+    public class UInt16InputTests
+    {
+        [Fact]
+        public void ProcessInput_EmptyArgs_Failure()
+        {
+            string[] args = [];
+            int index = 0;
+
+            var input = new UInt16Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_NegativeIndex_Failure()
+        {
+            string[] args = ["a", "5"];
+            int index = -1;
+
+            var input = new UInt16Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(-1, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_OverIndex_Failure()
+        {
+            string[] args = ["a", "5"];
+            int index = 2;
+
+            var input = new UInt16Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(2, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Space_InvalidLength_Failure()
+        {
+            string[] args = ["a"];
+            int index = 0;
+
+            var input = new UInt16Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Space_InvalidValue_Failure()
+        {
+            string[] args = ["a", "ANY"];
+            int index = 0;
+
+            var input = new UInt16Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Space_ValidValue_Success()
+        {
+            string[] args = ["a", "5"];
+            int index = 0;
+
+            var input = new UInt16Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.True(actual);
+            Assert.Equal(1, index);
+            ushort value = Assert.NotNull(input.Value);
+            Assert.Equal(5, value);
+        }
+
+        [Fact]
+        public void ProcessInput_Equal_InvalidLength_Failure()
+        {
+            string[] args = ["a="];
+            int index = 0;
+
+            var input = new UInt16Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Equal_InvalidValue_Failure()
+        {
+            string[] args = ["a=ANY"];
+            int index = 0;
+
+            var input = new UInt16Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Equal_ValidValue_Success()
+        {
+            string[] args = ["a=5"];
+            int index = 0;
+
+            var input = new UInt16Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.True(actual);
+            Assert.Equal(0, index);
+            ushort value = Assert.NotNull(input.Value);
+            Assert.Equal(5, value);
+        }
+    }
+}

SabreTools.CommandLine.Test/Inputs/UInt32InputTests.cs

@@ -0,0 +1,136 @@
+using SabreTools.CommandLine.Inputs;
+using Xunit;
+
+namespace SabreTools.CommandLine.Test.Inputs
+{
+    public class UInt32InputTests
+    {
+        [Fact]
+        public void ProcessInput_EmptyArgs_Failure()
+        {
+            string[] args = [];
+            int index = 0;
+
+            var input = new UInt32Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_NegativeIndex_Failure()
+        {
+            string[] args = ["a", "5"];
+            int index = -1;
+
+            var input = new UInt32Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(-1, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_OverIndex_Failure()
+        {
+            string[] args = ["a", "5"];
+            int index = 2;
+
+            var input = new UInt32Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(2, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Space_InvalidLength_Failure()
+        {
+            string[] args = ["a"];
+            int index = 0;
+
+            var input = new UInt32Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Space_InvalidValue_Failure()
+        {
+            string[] args = ["a", "ANY"];
+            int index = 0;
+
+            var input = new UInt32Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Space_ValidValue_Success()
+        {
+            string[] args = ["a", "5"];
+            int index = 0;
+
+            var input = new UInt32Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.True(actual);
+            Assert.Equal(1, index);
+            uint value = Assert.NotNull(input.Value);
+            Assert.Equal(5u, value);
+        }
+
+        [Fact]
+        public void ProcessInput_Equal_InvalidLength_Failure()
+        {
+            string[] args = ["a="];
+            int index = 0;
+
+            var input = new UInt32Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Equal_InvalidValue_Failure()
+        {
+            string[] args = ["a=ANY"];
+            int index = 0;
+
+            var input = new UInt32Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Equal_ValidValue_Success()
+        {
+            string[] args = ["a=5"];
+            int index = 0;
+
+            var input = new UInt32Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.True(actual);
+            Assert.Equal(0, index);
+            uint value = Assert.NotNull(input.Value);
+            Assert.Equal(5u, value);
+        }
+    }
+}

SabreTools.CommandLine.Test/Inputs/UInt64InputTests.cs

@@ -0,0 +1,136 @@
+using SabreTools.CommandLine.Inputs;
+using Xunit;
+
+namespace SabreTools.CommandLine.Test.Inputs
+{
+    public class UInt64InputTests
+    {
+        [Fact]
+        public void ProcessInput_EmptyArgs_Failure()
+        {
+            string[] args = [];
+            int index = 0;
+
+            var input = new UInt64Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_NegativeIndex_Failure()
+        {
+            string[] args = ["a", "5"];
+            int index = -1;
+
+            var input = new UInt64Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(-1, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_OverIndex_Failure()
+        {
+            string[] args = ["a", "5"];
+            int index = 2;
+
+            var input = new UInt64Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(2, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Space_InvalidLength_Failure()
+        {
+            string[] args = ["a"];
+            int index = 0;
+
+            var input = new UInt64Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Space_InvalidValue_Failure()
+        {
+            string[] args = ["a", "ANY"];
+            int index = 0;
+
+            var input = new UInt64Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Space_ValidValue_Success()
+        {
+            string[] args = ["a", "5"];
+            int index = 0;
+
+            var input = new UInt64Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.True(actual);
+            Assert.Equal(1, index);
+            ulong value = Assert.NotNull(input.Value);
+            Assert.Equal(5u, value);
+        }
+
+        [Fact]
+        public void ProcessInput_Equal_InvalidLength_Failure()
+        {
+            string[] args = ["a="];
+            int index = 0;
+
+            var input = new UInt64Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Equal_InvalidValue_Failure()
+        {
+            string[] args = ["a=ANY"];
+            int index = 0;
+
+            var input = new UInt64Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Equal_ValidValue_Success()
+        {
+            string[] args = ["a=5"];
+            int index = 0;
+
+            var input = new UInt64Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.True(actual);
+            Assert.Equal(0, index);
+            ulong value = Assert.NotNull(input.Value);
+            Assert.Equal(5u, value);
+        }
+    }
+}

SabreTools.CommandLine.Test/Inputs/UInt8InputTests.cs

@@ -0,0 +1,136 @@
+using SabreTools.CommandLine.Inputs;
+using Xunit;
+
+namespace SabreTools.CommandLine.Test.Inputs
+{
+    public class UInt8InputTests
+    {
+        [Fact]
+        public void ProcessInput_EmptyArgs_Failure()
+        {
+            string[] args = [];
+            int index = 0;
+
+            var input = new UInt8Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_NegativeIndex_Failure()
+        {
+            string[] args = ["a", "5"];
+            int index = -1;
+
+            var input = new UInt8Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(-1, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_OverIndex_Failure()
+        {
+            string[] args = ["a", "5"];
+            int index = 2;
+
+            var input = new UInt8Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(2, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Space_InvalidLength_Failure()
+        {
+            string[] args = ["a"];
+            int index = 0;
+
+            var input = new UInt8Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Space_InvalidValue_Failure()
+        {
+            string[] args = ["a", "ANY"];
+            int index = 0;
+
+            var input = new UInt8Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Space_ValidValue_Success()
+        {
+            string[] args = ["a", "5"];
+            int index = 0;
+
+            var input = new UInt8Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.True(actual);
+            Assert.Equal(1, index);
+            byte value = Assert.NotNull(input.Value);
+            Assert.Equal(5, value);
+        }
+
+        [Fact]
+        public void ProcessInput_Equal_InvalidLength_Failure()
+        {
+            string[] args = ["a="];
+            int index = 0;
+
+            var input = new UInt8Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Equal_InvalidValue_Failure()
+        {
+            string[] args = ["a=ANY"];
+            int index = 0;
+
+            var input = new UInt8Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.False(actual);
+            Assert.Equal(0, index);
+            Assert.Null(input.Value);
+        }
+
+        [Fact]
+        public void ProcessInput_Equal_ValidValue_Success()
+        {
+            string[] args = ["a=5"];
+            int index = 0;
+
+            var input = new UInt8Input("a", "a", "a");
+            bool actual = input.ProcessInput(args, ref index);
+
+            Assert.True(actual);
+            Assert.Equal(0, index);
+            byte value = Assert.NotNull(input.Value);
+            Assert.Equal(5, value);
+        }
+    }
+}

SabreTools.CommandLine.Test/Inputs/UserInputTests.cs

@@ -0,0 +1,691 @@
+using System;
+using System.Collections.Generic;
+using SabreTools.CommandLine.Inputs;
+using Xunit;
+
+namespace SabreTools.CommandLine.Test.Inputs
+{
+    public class UserInputTests
+    {
+        [Fact]
+        public void AddAndRetrieveTest()
+        {
+            var input1 = new FlagInput("input1", "--input1", "input1");
+            var input2 = new FlagInput("input2", "--input2", "input2");
+
+            var userInput = new MockUserInput("a", "a", "a");
+            userInput.Add(input1);
+            userInput.Add(input2);
+
+            var actualInput1 = userInput["input1"];
+            Assert.NotNull(actualInput1);
+            Assert.Equal("input1", actualInput1.Name);
+
+            var actualInput2 = userInput[input2];
+            Assert.NotNull(actualInput2);
+            Assert.Equal("input2", actualInput2.Name);
+
+            var actualInput3 = userInput["input3"];
+            Assert.Null(actualInput3);
+        }
+
+        [Fact]
+        public void ContainsFlagTest()
+        {
+            var userInput = new MockUserInput("a", ["a", "--b"], "a");
+
+            bool exactActual = userInput.ContainsFlag("a");
+            Assert.True(exactActual);
+
+            bool equalsActual = userInput.ContainsFlag("--b=");
+            Assert.True(equalsActual);
+
+            bool noMatchActual = userInput.ContainsFlag("-c");
+            Assert.False(noMatchActual);
+        }
+
+        [Fact]
+        public void StartsWithTest()
+        {
+            var userInput = new MockUserInput("a", ["a", "--b"], "a");
+
+            bool exactActual = userInput.StartsWith('a');
+            Assert.True(exactActual);
+
+            bool trimActual = userInput.StartsWith('b');
+            Assert.True(trimActual);
+
+            bool noMatchActual = userInput.StartsWith('c');
+            Assert.False(noMatchActual);
+        }
+
+        #region GetBoolean
+
+        [Fact]
+        public void GetBoolean_InvalidKey_DefaultValue()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new BooleanInput("b", "b", "b");
+            userInput.Add(child);
+
+            bool actual = userInput.GetBoolean("c");
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void GetBoolean_Exists_WrongType_Throws()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new MockUserInput("b", "b", "b");
+            userInput.Add(child);
+
+            Assert.Throws<ArgumentException>(() => _ = userInput.GetBoolean("b"));
+        }
+
+        [Fact]
+        public void GetBoolean_Exists_Returns()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new BooleanInput("b", "b", "b");
+            userInput.Add(child);
+
+            int index = 0;
+            child.ProcessInput(["b", "true"], ref index);
+
+            bool actual = userInput.GetBoolean("b");
+            Assert.True(actual);
+        }
+
+        [Fact]
+        public void GetBoolean_NestedExists_Returns()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new MockUserInput("b", "b", "b");
+            userInput.Add(child);
+            var subChild = new BooleanInput("c", "c", "c");
+            child.Add(subChild);
+
+            int index = 0;
+            subChild.ProcessInput(["c", "true"], ref index);
+
+            bool actual = userInput.GetBoolean("c");
+            Assert.True(actual);
+        }
+
+        #endregion
+
+        #region GetInt8
+
+        [Fact]
+        public void GetInt8_InvalidKey_DefaultValue()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new Int8Input("b", "b", "b");
+            userInput.Add(child);
+
+            sbyte actual = userInput.GetInt8("c");
+            Assert.Equal(sbyte.MinValue, actual);
+        }
+
+        [Fact]
+        public void GetInt8_Exists_WrongType_Throws()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new MockUserInput("b", "b", "b");
+            userInput.Add(child);
+
+            Assert.Throws<ArgumentException>(() => _ = userInput.GetInt8("b"));
+        }
+
+        [Fact]
+        public void GetInt8_Exists_Returns()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new Int8Input("b", "b", "b");
+            userInput.Add(child);
+
+            int index = 0;
+            child.ProcessInput(["b", "5"], ref index);
+
+            sbyte actual = userInput.GetInt8("b");
+            Assert.Equal(5, actual);
+        }
+
+        [Fact]
+        public void GetInt8_NestedExists_Returns()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new MockUserInput("b", "b", "b");
+            userInput.Add(child);
+            var subChild = new Int8Input("c", "c", "c");
+            child.Add(subChild);
+
+            int index = 0;
+            subChild.ProcessInput(["c", "5"], ref index);
+
+            sbyte actual = userInput.GetInt8("c");
+            Assert.Equal(5, actual);
+        }
+
+        #endregion
+
+        #region GetInt16
+
+        [Fact]
+        public void GetInt16_InvalidKey_DefaultValue()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new Int16Input("b", "b", "b");
+            userInput.Add(child);
+
+            short actual = userInput.GetInt16("c");
+            Assert.Equal(short.MinValue, actual);
+        }
+
+        [Fact]
+        public void GetInt16_Exists_WrongType_Throws()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new MockUserInput("b", "b", "b");
+            userInput.Add(child);
+
+            Assert.Throws<ArgumentException>(() => _ = userInput.GetInt16("b"));
+        }
+
+        [Fact]
+        public void GetInt16_Exists_Returns()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new Int16Input("b", "b", "b");
+            userInput.Add(child);
+
+            int index = 0;
+            child.ProcessInput(["b", "5"], ref index);
+
+            short actual = userInput.GetInt16("b");
+            Assert.Equal(5, actual);
+        }
+
+        [Fact]
+        public void GetInt16_NestedExists_Returns()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new MockUserInput("b", "b", "b");
+            userInput.Add(child);
+            var subChild = new Int16Input("c", "c", "c");
+            child.Add(subChild);
+
+            int index = 0;
+            subChild.ProcessInput(["c", "5"], ref index);
+
+            short actual = userInput.GetInt16("c");
+            Assert.Equal(5, actual);
+        }
+
+        #endregion
+
+        #region GetInt32
+
+        [Fact]
+        public void GetInt32_InvalidKey_DefaultValue()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new Int32Input("b", "b", "b");
+            userInput.Add(child);
+
+            int actual = userInput.GetInt32("c");
+            Assert.Equal(int.MinValue, actual);
+        }
+
+        [Fact]
+        public void GetInt32_Exists_WrongType_Throws()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new MockUserInput("b", "b", "b");
+            userInput.Add(child);
+
+            Assert.Throws<ArgumentException>(() => _ = userInput.GetInt32("b"));
+        }
+
+        [Fact]
+        public void GetInt32_Exists_Returns()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new Int32Input("b", "b", "b");
+            userInput.Add(child);
+
+            int index = 0;
+            child.ProcessInput(["b", "5"], ref index);
+
+            int actual = userInput.GetInt32("b");
+            Assert.Equal(5, actual);
+        }
+
+        [Fact]
+        public void GetInt32_NestedExists_Returns()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new MockUserInput("b", "b", "b");
+            userInput.Add(child);
+            var subChild = new Int32Input("c", "c", "c");
+            child.Add(subChild);
+
+            int index = 0;
+            subChild.ProcessInput(["c", "5"], ref index);
+
+            int actual = userInput.GetInt32("c");
+            Assert.Equal(5, actual);
+        }
+
+        #endregion
+
+        #region GetInt64
+
+        [Fact]
+        public void GetInt64_InvalidKey_DefaultValue()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new Int64Input("b", "b", "b");
+            userInput.Add(child);
+
+            long actual = userInput.GetInt64("c");
+            Assert.Equal(long.MinValue, actual);
+        }
+
+        [Fact]
+        public void GetInt64_Exists_WrongType_Throws()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new MockUserInput("b", "b", "b");
+            userInput.Add(child);
+
+            Assert.Throws<ArgumentException>(() => _ = userInput.GetInt64("b"));
+        }
+
+        [Fact]
+        public void GetInt64_Exists_Returns()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new Int64Input("b", "b", "b");
+            userInput.Add(child);
+
+            int index = 0;
+            child.ProcessInput(["b", "5"], ref index);
+
+            long actual = userInput.GetInt64("b");
+            Assert.Equal(5, actual);
+        }
+
+        [Fact]
+        public void GetInt64_NestedExists_Returns()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new MockUserInput("b", "b", "b");
+            userInput.Add(child);
+            var subChild = new Int64Input("c", "c", "c");
+            child.Add(subChild);
+
+            int index = 0;
+            subChild.ProcessInput(["c", "5"], ref index);
+
+            long actual = userInput.GetInt64("c");
+            Assert.Equal(5, actual);
+        }
+
+        #endregion
+
+        #region GetString
+
+        [Fact]
+        public void GetString_InvalidKey_DefaultValue()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new StringInput("b", "b", "b");
+            userInput.Add(child);
+
+            string? actual = userInput.GetString("c");
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void GetString_Exists_WrongType_Throws()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new MockUserInput("b", "b", "b");
+            userInput.Add(child);
+
+            Assert.Throws<ArgumentException>(() => _ = userInput.GetString("b"));
+        }
+
+        [Fact]
+        public void GetString_Exists_Returns()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new StringInput("b", "b", "b");
+            userInput.Add(child);
+
+            int index = 0;
+            child.ProcessInput(["b", "value"], ref index);
+
+            string? actual = userInput.GetString("b");
+            Assert.Equal("value", actual);
+        }
+
+        [Fact]
+        public void GetString_NestedExists_Returns()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new MockUserInput("b", "b", "b");
+            userInput.Add(child);
+            var subChild = new StringInput("c", "c", "c");
+            child.Add(subChild);
+
+            int index = 0;
+            subChild.ProcessInput(["c", "value"], ref index);
+
+            string? actual = userInput.GetString("c");
+            Assert.Equal("value", actual);
+        }
+
+        #endregion
+
+        #region GetStringList
+
+        [Fact]
+        public void GetStringList_InvalidKey_DefaultValue()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new StringListInput("b", "b", "b");
+            userInput.Add(child);
+
+            List<string> actual = userInput.GetStringList("c");
+            Assert.Empty(actual);
+        }
+
+        [Fact]
+        public void GetStringList_Exists_WrongType_Throws()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new MockUserInput("b", "b", "b");
+            userInput.Add(child);
+
+            Assert.Throws<ArgumentException>(() => _ = userInput.GetStringList("b"));
+        }
+
+        [Fact]
+        public void GetStringList_Exists_Returns()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new StringListInput("b", "b", "b");
+            userInput.Add(child);
+
+            int index = 0;
+            child.ProcessInput(["b", "value"], ref index);
+
+            List<string> actual = userInput.GetStringList("b");
+            string value = Assert.Single(actual);
+            Assert.Equal("value", value);
+        }
+
+        [Fact]
+        public void GetStringList_NestedExists_Returns()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new MockUserInput("b", "b", "b");
+            userInput.Add(child);
+            var subChild = new StringListInput("c", "c", "c");
+            child.Add(subChild);
+
+            int index = 0;
+            subChild.ProcessInput(["c", "value"], ref index);
+
+            List<string> actual = userInput.GetStringList("c");
+            string value = Assert.Single(actual);
+            Assert.Equal("value", value);
+        }
+
+        #endregion
+
+        #region GetUInt8
+
+        [Fact]
+        public void GetUInt8_InvalidKey_DefaultValue()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new UInt8Input("b", "b", "b");
+            userInput.Add(child);
+
+            byte actual = userInput.GetUInt8("c");
+            Assert.Equal(byte.MinValue, actual);
+        }
+
+        [Fact]
+        public void GetUInt8_Exists_WrongType_Throws()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new MockUserInput("b", "b", "b");
+            userInput.Add(child);
+
+            Assert.Throws<ArgumentException>(() => _ = userInput.GetUInt8("b"));
+        }
+
+        [Fact]
+        public void GetUInt8_Exists_Returns()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new UInt8Input("b", "b", "b");
+            userInput.Add(child);
+
+            int index = 0;
+            child.ProcessInput(["b", "5"], ref index);
+
+            byte actual = userInput.GetUInt8("b");
+            Assert.Equal(5, actual);
+        }
+
+        [Fact]
+        public void GetUInt8_NestedExists_Returns()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new MockUserInput("b", "b", "b");
+            userInput.Add(child);
+            var subChild = new UInt8Input("c", "c", "c");
+            child.Add(subChild);
+
+            int index = 0;
+            subChild.ProcessInput(["c", "5"], ref index);
+
+            byte actual = userInput.GetUInt8("c");
+            Assert.Equal(5, actual);
+        }
+
+        #endregion
+
+        #region GetUInt16
+
+        [Fact]
+        public void GetUInt16_InvalidKey_DefaultValue()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new UInt16Input("b", "b", "b");
+            userInput.Add(child);
+
+            ushort actual = userInput.GetUInt16("c");
+            Assert.Equal(ushort.MinValue, actual);
+        }
+
+        [Fact]
+        public void GetUInt16_Exists_WrongType_Throws()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new MockUserInput("b", "b", "b");
+            userInput.Add(child);
+
+            Assert.Throws<ArgumentException>(() => _ = userInput.GetUInt16("b"));
+        }
+
+        [Fact]
+        public void GetUInt16_Exists_Returns()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new UInt16Input("b", "b", "b");
+            userInput.Add(child);
+
+            int index = 0;
+            child.ProcessInput(["b", "5"], ref index);
+
+            ushort actual = userInput.GetUInt16("b");
+            Assert.Equal(5, actual);
+        }
+
+        [Fact]
+        public void GetUInt16_NestedExists_Returns()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new MockUserInput("b", "b", "b");
+            userInput.Add(child);
+            var subChild = new UInt16Input("c", "c", "c");
+            child.Add(subChild);
+
+            int index = 0;
+            subChild.ProcessInput(["c", "5"], ref index);
+
+            ushort actual = userInput.GetUInt16("c");
+            Assert.Equal(5, actual);
+        }
+
+        #endregion
+
+        #region GetUInt32
+
+        [Fact]
+        public void GetUInt32_InvalidKey_DefaultValue()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new UInt32Input("b", "b", "b");
+            userInput.Add(child);
+
+            uint actual = userInput.GetUInt32("c");
+            Assert.Equal(uint.MinValue, actual);
+        }
+
+        [Fact]
+        public void GetUInt32_Exists_WrongType_Throws()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new MockUserInput("b", "b", "b");
+            userInput.Add(child);
+
+            Assert.Throws<ArgumentException>(() => _ = userInput.GetUInt32("b"));
+        }
+
+        [Fact]
+        public void GetUInt32_Exists_Returns()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new UInt32Input("b", "b", "b");
+            userInput.Add(child);
+
+            int index = 0;
+            child.ProcessInput(["b", "5"], ref index);
+
+            uint actual = userInput.GetUInt32("b");
+            Assert.Equal(5u, actual);
+        }
+
+        [Fact]
+        public void GetUInt32_NestedExists_Returns()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new MockUserInput("b", "b", "b");
+            userInput.Add(child);
+            var subChild = new UInt32Input("c", "c", "c");
+            child.Add(subChild);
+
+            int index = 0;
+            subChild.ProcessInput(["c", "5"], ref index);
+
+            uint actual = userInput.GetUInt32("c");
+            Assert.Equal(5u, actual);
+        }
+
+        #endregion
+
+        #region GetUInt64
+
+        [Fact]
+        public void GetUInt64_InvalidKey_DefaultValue()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new UInt64Input("b", "b", "b");
+            userInput.Add(child);
+
+            ulong actual = userInput.GetUInt64("c");
+            Assert.Equal(ulong.MinValue, actual);
+        }
+
+        [Fact]
+        public void GetUInt64_Exists_WrongType_Throws()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new MockUserInput("b", "b", "b");
+            userInput.Add(child);
+
+            Assert.Throws<ArgumentException>(() => _ = userInput.GetUInt64("b"));
+        }
+
+        [Fact]
+        public void GetUInt64_Exists_Returns()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new UInt64Input("b", "b", "b");
+            userInput.Add(child);
+
+            int index = 0;
+            child.ProcessInput(["b", "5"], ref index);
+
+            ulong actual = userInput.GetUInt64("b");
+            Assert.Equal(5u, actual);
+        }
+
+        [Fact]
+        public void GetUInt64_NestedExists_Returns()
+        {
+            UserInput userInput = new MockUserInput("a", "a", "a");
+            var child = new MockUserInput("b", "b", "b");
+            userInput.Add(child);
+            var subChild = new UInt64Input("c", "c", "c");
+            child.Add(subChild);
+
+            int index = 0;
+            subChild.ProcessInput(["c", "5"], ref index);
+
+            ulong actual = userInput.GetUInt64("c");
+            Assert.Equal(5u, actual);
+        }
+
+        #endregion
+
+        /// <summary>
+        /// Mock UserInput implementation for testing
+        /// </summary>
+        private class MockUserInput : UserInput<object?>
+        {
+            public MockUserInput(string name, string flag, string description, string? longDescription = null)
+                : base(name, flag, description, longDescription)
+            {
+            }
+
+            public MockUserInput(string name, string[] flags, string description, string? longDescription = null)
+                : base(name, flags, description, longDescription)
+            {
+            }
+
+            /// <inheritdoc/>
+            public override bool ProcessInput(string[] args, ref int index) => true;
+
+            /// <inheritdoc/>
+            protected override string FormatFlags() => string.Empty;
+        }
+    }
+}

SabreTools.CommandLine.Test/SabreTools.CommandLine.Test.csproj

@@ -0,0 +1,27 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFrameworks>net8.0;net9.0</TargetFrameworks>
+        <IsPackable>false</IsPackable>
+        <LangVersion>latest</LangVersion>
+        <Nullable>enable</Nullable>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <ProjectReference Include="..\SabreTools.CommandLine\SabreTools.CommandLine.csproj" />
+    </ItemGroup>
+
+    <ItemGroup>
+        <PackageReference Include="coverlet.collector" Version="6.0.4">
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+            <PrivateAssets>all</PrivateAssets>
+        </PackageReference>
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />
+        <PackageReference Include="xunit" Version="2.9.3" />
+        <PackageReference Include="xunit.runner.visualstudio" Version="3.1.5">
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+            <PrivateAssets>all</PrivateAssets>
+        </PackageReference>
+    </ItemGroup>
+
+</Project>