/// <summary> /// Parses the Command-Line Args or Shows the Help, whichever is appropriate. /// Appropriateness is determined by whether there are Remaining Args, or /// whether the Help option was specified. /// </summary> /// <param name="writer"></param> /// <param name="args"></param> /// <returns>true when parsing was successful and no help was requested.</returns> /// <remarks>Which, by simplifying the model in SOLID-, DRY-style, the need /// for many in the way of helpers vanishes altogether.</remarks> public bool TryParseOrShowHelp(TextWriter writer, params string[] args) { var remaining = _optionSet.Parse(args); //Not-parsed determined here. var parsed = !(remaining.Any() || _optionSet.GetMissingVariables().Any() || _helpInfo.Help.Enabled); //Show-error when any-remaining or missing-variables. if (remaining.Any() || _optionSet.GetMissingVariables().Any()) { writer.WriteLine("{0}: error parsing arguments:", ConsoleName); } else if (!parsed) { writer.WriteLine("{0} options:", ConsoleName); } //Show-help when not-parsed. if (!parsed) { _optionSet.WriteOptionDescriptions(writer); } return(parsed); }
public void Should_Detect_Required_VariableLists() { var optionSet = new RequiredValuesOptionSet(); var n = optionSet.AddRequiredVariableList <string>("n", ""); var a = optionSet.AddRequiredVariableList <int>("a", ""); var m = optionSet.AddRequiredVariableList <string>("m", ""); //TODO: Screaming for an NUnit-test-case-coverage. var args = "-n FindThisString -n:Findit2 -n:Findit3 -a2 -a3 -a5565 -a:23".Split(' '); optionSet.Parse(args); Action <IEnumerable <string> > verifyN = x => { // ReSharper disable PossibleMultipleEnumeration Assert.AreEqual(3, x.Count()); Assert.IsTrue(x.Contains("FindThisString")); Assert.IsTrue(x.Contains("Findit2")); Assert.IsTrue(x.Contains("Findit3")); // ReSharper restore PossibleMultipleEnumeration }; Action <IEnumerable <int> > verifyA = x => { // ReSharper disable PossibleMultipleEnumeration Assert.AreEqual(4, x.Count()); Assert.IsTrue(x.Contains(2)); Assert.IsTrue(x.Contains(3)); Assert.IsTrue(x.Contains(5565)); Assert.IsTrue(x.Contains(23)); // ReSharper restore PossibleMultipleEnumeration }; Action <IEnumerable <string> > verifyM = x => { // ReSharper disable PossibleMultipleEnumeration Assert.AreEqual(0, x.Count()); Assert.AreEqual(1, optionSet.GetMissingVariables().Count()); // ReSharper restore PossibleMultipleEnumeration }; verifyA(a); verifyA(a.Values); verifyN(n); verifyN(n.Values); verifyM(m); verifyM(m.Values); }
public void Should_Detect_Required_Variables() { var optionSet = new RequiredValuesOptionSet(); var name = optionSet.AddRequiredVariable <string>("n", ""); var age = optionSet.AddRequiredVariable <int>("a", ""); var age2 = optionSet.AddRequiredVariable <int>("b", ""); var age3 = optionSet.AddRequiredVariable <int>("c", ""); //TODO: Screaming for NUnit-test-case-coverage. var args = "-n FindThisString".Split(' '); optionSet.Parse(args); /* TODO: Might could (should) also verify that each of the missing ones, * as well as found ones, are either there are not there. */ Assert.AreEqual(3, optionSet.GetMissingVariables().Count()); Assert.AreEqual("FindThisString", name); }