public void MultiOptionMultiParam()
        {
            Options.OptionSpec[] testOptions = new Options.OptionSpec[] {
                new Options.OptionSpec {
                    ShortOption = 'l', LongOption = "ll", NumberOfParams = 2, MaxOccurs = 100
                },
            };

            var opts = new Options(testOptions);

            int occurrences = 10;
            var rnd         = new Random();
            var pairs       = Enumerable.Range(1, occurrences).Select(x => ($"{rnd.NextDouble() * 100:F3}", $"{rnd.NextDouble() * 100:F3}")).ToList();
            var args        = pairs.Select(x => new[] { "--ll", x.Item1, x.Item2 }).SelectMany(y => y).ToArray();

            Debug.WriteLine(string.Join(" ", args));

            var result = opts.ParseCommandLine(args);

            Assert.IsTrue(result);
            var illegalOptions = opts.IllegalOptions;

            Assert.AreEqual(illegalOptions.Length, 0);

            var llOptionCount = opts.OptionCount("ll");

            Assert.AreEqual(llOptionCount, occurrences);
            for (int i = 0; i < occurrences; i++)
            {
                var optResult = opts.TryGetList("ll", out var pair, i);
                Assert.IsTrue(optResult);
                Assert.AreEqual(pair[0], pairs[i].Item1, pairs[i].Item2);
            }
        }
        public void OptionsTest()
        {
            var args = testOptions;
            var opts = new Options(args);

            // No exception

            Options.OptionSpec[] dupOptions1 = new Options.OptionSpec[] {
                new Options.OptionSpec {
                    ShortOption = 'a', LongOption = "all", NumberOfParams = 0
                },
                new Options.OptionSpec {
                    ShortOption = 'i', LongOption = "ignorecase", NumberOfParams = 0
                },
                // duplicate i:
                new Options.OptionSpec {
                    ShortOption = 'i', LongOption = "input", NumberOfParams = 1
                },
                new Options.OptionSpec {
                    ShortOption = 'f', LongOption = "file", NumberOfParams = 1
                },
            };

            Assert.ThrowsException <ArgumentException>(() => new Options(dupOptions1));

            Options.OptionSpec[] dupOptions2 = new Options.OptionSpec[] {
                new Options.OptionSpec {
                    ShortOption = 'a', LongOption = "all", NumberOfParams = 0
                },
                new Options.OptionSpec {
                    ShortOption = 'i', LongOption = "ignorecase", NumberOfParams = 0
                },
                new Options.OptionSpec {
                    ShortOption = 'j', LongOption = "ignorecase", NumberOfParams = 1
                },
                new Options.OptionSpec {
                    ShortOption = 'f', LongOption = "file", NumberOfParams = 1
                },
            };

            Assert.ThrowsException <ArgumentException>(() => new Options(dupOptions2));
        }
        public void MoreThanOneParamTest()
        {
            Options.OptionSpec[] testOptions = new Options.OptionSpec[] {
                new Options.OptionSpec {
                    ShortOption = 'a', LongOption = "all", NumberOfParams = 0
                },
                new Options.OptionSpec {
                    ShortOption = 'i', LongOption = "ignorecase", NumberOfParams = 0
                },
                new Options.OptionSpec {
                    ShortOption = 'f', LongOption = "file", NumberOfParams = 3
                },
            };

            var opts = new Options(testOptions);
            var args = new[] { "-f", "file1.cpp", "file2.cpp", "file3.cpp", "file4.cpp" };

            opts.ParseCommandLine(args);

            // no options present so these should all be false:
            Assert.IsFalse(opts.IsOptionPresent("ignorecase"));
            Assert.IsFalse(opts.IsOptionPresent('i'));
            Assert.IsFalse(opts.IsOptionPresent("all"));
            Assert.IsFalse(opts.IsOptionPresent('a'));
            Assert.IsTrue(opts.IsOptionPresent('f'));
            Assert.IsTrue(opts.IsOptionPresent("file"));

            var result = opts.TryGetList("file", out var strArray, 0);

            Assert.IsTrue(result);
            string[] arr = { "file1.cpp", "file2.cpp", "file3.cpp" };
            CollectionAssert.AreEqual(arr, strArray);
            var nonOpts = opts.NonOptions;

            Assert.AreEqual(1, nonOpts.Length);
            Assert.AreEqual("file4.cpp", nonOpts[0].arg);
            Assert.AreEqual(4, nonOpts[0].index);
        }
        public void TryMultiOptionTest()
        {
            Options.OptionSpec[] testOptions = new Options.OptionSpec[] {
                new Options.OptionSpec {
                    ShortOption = 'a', LongOption = "all", NumberOfParams = 0
                },
                new Options.OptionSpec {
                    ShortOption = 'i', LongOption = "ignorecase", NumberOfParams = 0
                },
                new Options.OptionSpec {
                    ShortOption = 'f', LongOption = "file", NumberOfParams = 1, MaxOccurs = 255
                },
            };

            var opts = new Options(testOptions);
            var args = new[] { "-f", "file1.cpp", "-f", "file2.cpp", "-f", "file3.cpp" };

            opts.ParseCommandLine(args);

            // no options present so these should all be false:
            Assert.IsFalse(opts.IsOptionPresent("ignorecase"));
            Assert.IsFalse(opts.IsOptionPresent('i'));
            Assert.IsFalse(opts.IsOptionPresent("all"));
            Assert.IsFalse(opts.IsOptionPresent('a'));
            Assert.IsTrue(opts.IsOptionPresent('f'));
            Assert.IsTrue(opts.IsOptionPresent("file"));

            var result = opts.TryGetValue("file", out var str1, 0);

            Assert.IsTrue(result);
            Assert.AreEqual("file1.cpp", str1);
            result = opts.TryGetValue("file", out var str2, 1);
            Assert.IsTrue(result);
            Assert.AreEqual("file2.cpp", str2);
            result = opts.TryGetValue("file", out var str3, 2);
            Assert.IsTrue(result);
            Assert.AreEqual("file3.cpp", str3);
        }
        public void IllegalSingleDashOptions()
        {
            Options.OptionSpec[] testOptions = new Options.OptionSpec[] {
                new Options.OptionSpec {
                    ShortOption = 'a', LongOption = "all", NumberOfParams = 0
                },
                new Options.OptionSpec {
                    ShortOption = 'i', LongOption = "ignorecase", NumberOfParams = 0
                },
                new Options.OptionSpec {
                    ShortOption = 'f', LongOption = "file", NumberOfParams = 1
                },
            };

            var opts   = new Options(testOptions);
            var args   = new[] { "-f", "file1.cpp", "-eqy" };
            var result = opts.ParseCommandLine(args);

            Assert.IsFalse(result);
            var illegalOptions = opts.IllegalOptions;

            Assert.AreEqual(illegalOptions.Length, 3);
        }