public void TestAll(int scenario, int expectedFilesFound)
        {
            var scenarioPath = Scenarios[scenario - 1];
            var finder       = new ModinfoFileFinder(scenarioPath);
            var result       = finder.Find(FindOptions.FindAny);

            Assert.Equal(expectedFilesFound, result.Count());
        }
        public void TestMerge()
        {
            var finder = new ModinfoFileFinder(Scenarios[3]);
            var vars   = finder.Find(FindOptions.FindVariants);
            var all    = finder.Find(FindOptions.FindAny);

            Assert.NotNull(all.Variants.ElementAt(0).GetModinfo().Version);
            Assert.NotNull(vars.Variants.ElementAt(0).GetModinfo().Version);
        }
        private static IMod CreateMod(IGame game, ModType type, DirectoryInfo directory, IModinfo?modInfo, bool searchModFileOnDisk)
        {
            if (game is null)
            {
                throw new ArgumentNullException(nameof(game));
            }
            if (directory is null)
            {
                throw new ArgumentNullException(nameof(directory));
            }

            if (searchModFileOnDisk && modInfo is null)
            {
                var mainModinfoFile = ModinfoFileFinder.FindMain(directory);
                if (mainModinfoFile != null)
                {
                    modInfo = mainModinfoFile !.GetModinfo();
                }
            }


            return(CreateModInstance(game, type, directory, modInfo));
        }
        //public static IEnumerable<IMod> CreateModAndVariants(IGame game, ModType type, DirectoryInfo directory, bool onlyVariantsIfPresent)
        //{
        //    if (game is null)
        //        throw new ArgumentNullException(nameof(game));
        //    if (directory is null)
        //        throw new ArgumentNullException(nameof(directory));

        //    if (!ModInfoFileFinder.TryFind(directory, ModInfoFileFinder.FindOptions.FindAny, out var modInfoCollection) || !modInfoCollection!.Variants.Any())
        //        yield return CreateModInstance(game, type, directory, modInfoCollection?.MainModInfo?.GetModInfo());

        //    if (modInfoCollection is null)
        //        yield break;

        //    if (!onlyVariantsIfPresent)
        //        yield return CreateModInstance(game, type, directory, modInfoCollection.MainModInfo?.GetModInfo());

        //    foreach (var variant in modInfoCollection!.Variants)
        //        yield return CreateModInstance(game, type, directory, variant.GetModInfo());
        //}

        public static IEnumerable <IMod> CreateModAndVariants(IGame game, ModType type, DirectoryInfo directory,
                                                              bool onlyVariantsIfPresent)
        {
            if (game is null)
            {
                throw new ArgumentNullException(nameof(game));
            }
            if (directory is null)
            {
                throw new ArgumentNullException(nameof(directory));
            }

            ModinfoFinderCollection?modInfoCollection = default;

            try
            {
                var finder = new ModinfoFileFinder(directory);
                modInfoCollection = finder.Find(FindOptions.FindAny);

                if (!modInfoCollection.HasMainModinfoFile && !modInfoCollection.HasVariantModinfoFiles)
                {
                    var mod = CreateModInstanceOrNull(game, type, directory, null);
                    if (mod != null)
                    {
                        return new[] { mod }
                    }
                    ;
                }
            }
            catch (Exception e)
            {
                Logger.Info(e, e.Message);
            }

            if (modInfoCollection is null)
            {
                return(Enumerable.Empty <IMod>());
            }

            if (!modInfoCollection.Variants.Any())
            {
                var mod = CreateModInstanceOrNull(game, type, directory, modInfoCollection.MainModinfo?.TryGetModinfo());
                if (mod != null)
                {
                    return new[] { mod }
                }
                ;
            }



            var result = new List <IMod>();

            if (!onlyVariantsIfPresent && TryCreateModInstance(game, type, directory, modInfoCollection.MainModinfo?.TryGetModinfo(), out var baseMod))
            {
                result.Add(baseMod !);
            }

            foreach (var variant in modInfoCollection !.Variants)
            {
                if (TryCreateModInstance(game, type, directory, variant.TryGetModinfo(), out var variantMod))
                {
                    result.Add(variantMod !);
                }
            }

            return(result);
        }
        public void TestThrow()
        {
            var finder = new ModinfoFileFinder(Scenarios[2]);

            Assert.Throws <ModinfoException>(() => finder.FindThrow(FindOptions.FindAny));
        }